home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December (Special) / PCWorld_2005-12_Special_cd.bin / Bezpecnost / lsti / lsti.exe / framework-2.5.exe / pp.h < prev    next >
C/C++ Source or Header  |  2005-01-27  |  17KB  |  490 lines
  1. /*    pp.h
  2.  *
  3.  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
  4.  *    2000, 2001, by Larry Wall and others
  5.  *
  6.  *    You may distribute under the terms of either the GNU General Public
  7.  *    License or the Artistic License, as specified in the README file.
  8.  *
  9.  */
  10.  
  11. #ifdef USE_5005THREADS
  12. #define ARGS thr
  13. #define dARGS struct perl_thread *thr;
  14. #else
  15. #define ARGS
  16. #define dARGS
  17. #endif /* USE_5005THREADS */
  18.  
  19. #define PP(s) OP * Perl_##s(pTHX)
  20.  
  21. /*
  22. =head1 Stack Manipulation Macros
  23.  
  24. =for apidoc AmU||SP
  25. Stack pointer.  This is usually handled by C<xsubpp>.  See C<dSP> and
  26. C<SPAGAIN>.
  27.  
  28. =for apidoc AmU||MARK
  29. Stack marker variable for the XSUB.  See C<dMARK>.
  30.  
  31. =for apidoc Am|void|PUSHMARK|SP
  32. Opening bracket for arguments on a callback.  See C<PUTBACK> and
  33. L<perlcall>.
  34.  
  35. =for apidoc Ams||dSP
  36. Declares a local copy of perl's stack pointer for the XSUB, available via
  37. the C<SP> macro.  See C<SP>.
  38.  
  39. =for apidoc ms||djSP
  40.  
  41. Declare Just C<SP>. This is actually identical to C<dSP>, and declares
  42. a local copy of perl's stack pointer, available via the C<SP> macro.
  43. See C<SP>.  (Available for backward source code compatibility with the
  44. old (Perl 5.005) thread model.)
  45.  
  46. =for apidoc Ams||dMARK
  47. Declare a stack marker variable, C<mark>, for the XSUB.  See C<MARK> and
  48. C<dORIGMARK>.
  49.  
  50. =for apidoc Ams||dORIGMARK
  51. Saves the original stack mark for the XSUB.  See C<ORIGMARK>.
  52.  
  53. =for apidoc AmU||ORIGMARK
  54. The original stack mark for the XSUB.  See C<dORIGMARK>.
  55.  
  56. =for apidoc Ams||SPAGAIN
  57. Refetch the stack pointer.  Used after a callback.  See L<perlcall>.
  58.  
  59. =cut */
  60.  
  61. #undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */
  62. #define SP sp
  63. #define MARK mark
  64. #define TARG targ
  65.  
  66. #define PUSHMARK(p) if (++PL_markstack_ptr == PL_markstack_max)    \
  67.             markstack_grow();            \
  68.             *PL_markstack_ptr = (p) - PL_stack_base
  69.  
  70. #define TOPMARK        (*PL_markstack_ptr)
  71. #define POPMARK        (*PL_markstack_ptr--)
  72.  
  73. #define dSP        register SV **sp = PL_stack_sp
  74. #define djSP        dSP
  75. #define dMARK        register SV **mark = PL_stack_base + POPMARK
  76. #define dORIGMARK    I32 origmark = mark - PL_stack_base
  77. #define SETORIGMARK    origmark = mark - PL_stack_base
  78. #define ORIGMARK    (PL_stack_base + origmark)
  79.  
  80. #define SPAGAIN        sp = PL_stack_sp
  81. #define MSPAGAIN    sp = PL_stack_sp; mark = ORIGMARK
  82.  
  83. #define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ))
  84. #define dTARGETSTACKED SV * GETTARGETSTACKED
  85.  
  86. #define GETTARGET targ = PAD_SV(PL_op->op_targ)
  87. #define dTARGET SV * GETTARGET
  88.  
  89. #define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ))
  90. #define dATARGET SV * GETATARGET
  91.  
  92. #define dTARG SV *targ
  93.  
  94. #define NORMAL PL_op->op_next
  95. #define DIE return Perl_die
  96.  
  97. /*
  98. =for apidoc Ams||PUTBACK
  99. Closing bracket for XSUB arguments.  This is usually handled by C<xsubpp>.
  100. See C<PUSHMARK> and L<perlcall> for other uses.
  101.  
  102. =for apidoc Amn|SV*|POPs
  103. Pops an SV off the stack.
  104.  
  105. =for apidoc Amn|char*|POPp
  106. Pops a string off the stack. Deprecated. New code should provide
  107. a STRLEN n_a and use POPpx.
  108.  
  109. =for apidoc Amn|char*|POPpx
  110. Pops a string off the stack.
  111. Requires a variable STRLEN n_a in scope.
  112.  
  113. =for apidoc Amn|char*|POPpbytex
  114. Pops a string off the stack which must consist of bytes i.e. characters < 256.
  115. Requires a variable STRLEN n_a in scope.
  116.  
  117. =for apidoc Amn|NV|POPn
  118. Pops a double off the stack.
  119.  
  120. =for apidoc Amn|IV|POPi
  121. Pops an integer off the stack.
  122.  
  123. =for apidoc Amn|long|POPl
  124. Pops a long off the stack.
  125.  
  126. =cut
  127. */
  128.  
  129. #define PUTBACK        PL_stack_sp = sp
  130. #define RETURN        return PUTBACK, NORMAL
  131. #define RETURNOP(o)    return PUTBACK, o
  132. #define RETURNX(x)    return x, PUTBACK, NORMAL
  133.  
  134. #define POPs        (*sp--)
  135. #define POPp        (SvPVx(POPs, PL_na))        /* deprecated */
  136. #define POPpx        (SvPVx(POPs, n_a))
  137. #define POPpbytex    (SvPVbytex(POPs, n_a))
  138. #define POPn        (SvNVx(POPs))
  139. #define POPi        ((IV)SvIVx(POPs))
  140. #define POPu        ((UV)SvUVx(POPs))
  141. #define POPl        ((long)SvIVx(POPs))
  142. #define POPul        ((unsigned long)SvIVx(POPs))
  143. #ifdef HAS_QUAD
  144. #define POPq        ((Quad_t)SvIVx(POPs))
  145. #define POPuq        ((Uquad_t)SvUVx(POPs))
  146. #endif
  147.  
  148. #define TOPs        (*sp)
  149. #define TOPm1s        (*(sp-1))
  150. #define TOPp1s        (*(sp+1))
  151. #define TOPp        (SvPV(TOPs, PL_na))        /* deprecated */
  152. #define TOPpx        (SvPV(TOPs, n_a))
  153. #define TOPn        (SvNV(TOPs))
  154. #define TOPi        ((IV)SvIV(TOPs))
  155. #define TOPu        ((UV)SvUV(TOPs))
  156. #define TOPl        ((long)SvIV(TOPs))
  157. #define TOPul        ((unsigned long)SvUV(TOPs))
  158. #ifdef HAS_QUAD
  159. #define TOPq        ((Quad_t)SvIV(TOPs))
  160. #define TOPuq        ((Uquad_t)SvUV(TOPs))
  161. #endif
  162.  
  163. /* Go to some pains in the rare event that we must extend the stack. */
  164.  
  165. /*
  166. =for apidoc Am|void|EXTEND|SP|int nitems
  167. Used to extend the argument stack for an XSUB's return values. Once
  168. used, guarantees that there is room for at least C<nitems> to be pushed
  169. onto the stack.
  170.  
  171. =for apidoc Am|void|PUSHs|SV* sv
  172. Push an SV onto the stack.  The stack must have room for this element.
  173. Does not handle 'set' magic.  Does not use C<TARG>.  See also C<PUSHmortal>,
  174. C<XPUSHs> and C<XPUSHmortal>.
  175.  
  176. =for apidoc Am|void|PUSHp|char* str|STRLEN len
  177. Push a string onto the stack.  The stack must have room for this element.
  178. The C<len> indicates the length of the string.  Handles 'set' magic.  Uses
  179. C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not
  180. call multiple C<TARG>-oriented macros to return lists from XSUB's - see
  181. C<mPUSHp> instead.  See also C<XPUSHp> and C<mXPUSHp>.
  182.  
  183. =for apidoc Am|void|PUSHn|NV nv
  184. Push a double onto the stack.  The stack must have room for this element.
  185. Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
  186. called to declare it.  Do not call multiple C<TARG>-oriented macros to
  187. return lists from XSUB's - see C<mPUSHn> instead.  See also C<XPUSHn> and
  188. C<mXPUSHn>.
  189.  
  190. =for apidoc Am|void|PUSHi|IV iv
  191. Push an integer onto the stack.  The stack must have room for this element.
  192. Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
  193. called to declare it.  Do not call multiple C<TARG>-oriented macros to 
  194. return lists from XSUB's - see C<mPUSHi> instead.  See also C<XPUSHi> and
  195. C<mXPUSHi>.
  196.  
  197. =for apidoc Am|void|PUSHu|UV uv
  198. Push an unsigned integer onto the stack.  The stack must have room for this
  199. element.  Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG>
  200. should be called to declare it.  Do not call multiple C<TARG>-oriented
  201. macros to return lists from XSUB's - see C<mPUSHu> instead.  See also
  202. C<XPUSHu> and C<mXPUSHu>.
  203.  
  204. =for apidoc Am|void|XPUSHs|SV* sv
  205. Push an SV onto the stack, extending the stack if necessary.  Does not
  206. handle 'set' magic.  Does not use C<TARG>.  See also C<XPUSHmortal>,
  207. C<PUSHs> and C<PUSHmortal>.
  208.  
  209. =for apidoc Am|void|XPUSHp|char* str|STRLEN len
  210. Push a string onto the stack, extending the stack if necessary.  The C<len>
  211. indicates the length of the string.  Handles 'set' magic.  Uses C<TARG>, so
  212. C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not call
  213. multiple C<TARG>-oriented macros to return lists from XSUB's - see
  214. C<mXPUSHp> instead.  See also C<PUSHp> and C<mPUSHp>.
  215.  
  216. =for apidoc Am|void|XPUSHn|NV nv
  217. Push a double onto the stack, extending the stack if necessary.  Handles
  218. 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
  219. declare it.  Do not call multiple C<TARG>-oriented macros to return lists
  220. from XSUB's - see C<mXPUSHn> instead.  See also C<PUSHn> and C<mPUSHn>.
  221.  
  222. =for apidoc Am|void|XPUSHi|IV iv
  223. Push an integer onto the stack, extending the stack if necessary.  Handles
  224. 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
  225. declare it.  Do not call multiple C<TARG>-oriented macros to return lists
  226. from XSUB's - see C<mXPUSHi> instead.  See also C<PUSHi> and C<mPUSHi>.
  227.  
  228. =for apidoc Am|void|XPUSHu|UV uv
  229. Push an unsigned integer onto the stack, extending the stack if necessary.
  230. Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
  231. called to declare it.  Do not call multiple C<TARG>-oriented macros to
  232. return lists from XSUB's - see C<mXPUSHu> instead.  See also C<PUSHu> and
  233. C<mPUSHu>.
  234.  
  235. =for apidoc Am|void|PUSHmortal
  236. Push a new mortal SV onto the stack.  The stack must have room for this
  237. element.  Does not handle 'set' magic.  Does not use C<TARG>.  See also
  238. C<PUSHs>, C<XPUSHmortal> and C<XPUSHs>.
  239.  
  240. =for apidoc Am|void|mPUSHp|char* str|STRLEN len
  241. Push a string onto the stack.  The stack must have room for this element.
  242. The C<len> indicates the length of the string.  Handles 'set' magic.  Does
  243. not use C<TARG>.  See also C<PUSHp>, C<mXPUSHp> and C<XPUSHp>.
  244.  
  245. =for apidoc Am|void|mPUSHn|NV nv
  246. Push a double onto the stack.  The stack must have room for this element.
  247. Handles 'set' magic.  Does not use C<TARG>.  See also C<PUSHn>, C<mXPUSHn>
  248. and C<XPUSHn>.
  249.  
  250. =for apidoc Am|void|mPUSHi|IV iv
  251. Push an integer onto the stack.  The stack must have room for this element.
  252. Handles 'set' magic.  Does not use C<TARG>.  See also C<PUSHi>, C<mXPUSHi>
  253. and C<XPUSHi>.
  254.  
  255. =for apidoc Am|void|mPUSHu|UV uv
  256. Push an unsigned integer onto the stack.  The stack must have room for this
  257. element.  Handles 'set' magic.  Does not use C<TARG>.  See also C<PUSHu>,
  258. C<mXPUSHu> and C<XPUSHu>.
  259.  
  260. =for apidoc Am|void|XPUSHmortal
  261. Push a new mortal SV onto the stack, extending the stack if necessary.  Does
  262. not handle 'set' magic.  Does not use C<TARG>.  See also C<XPUSHs>,
  263. C<PUSHmortal> and C<PUSHs>.
  264.  
  265. =for apidoc Am|void|mXPUSHp|char* str|STRLEN len
  266. Push a string onto the stack, extending the stack if necessary.  The C<len>
  267. indicates the length of the string.  Handles 'set' magic.  Does not use
  268. C<TARG>.  See also C<XPUSHp>, C<mPUSHp> and C<PUSHp>.
  269.  
  270. =for apidoc Am|void|mXPUSHn|NV nv
  271. Push a double onto the stack, extending the stack if necessary.  Handles
  272. 'set' magic.  Does not use C<TARG>.  See also C<XPUSHn>, C<mPUSHn> and
  273. C<PUSHn>.
  274.  
  275. =for apidoc Am|void|mXPUSHi|IV iv
  276. Push an integer onto the stack, extending the stack if necessary.  Handles
  277. 'set' magic.  Does not use C<TARG>.  See also C<XPUSHi>, C<mPUSHi> and
  278. C<PUSHi>.
  279.  
  280. =for apidoc Am|void|mXPUSHu|UV uv
  281. Push an unsigned integer onto the stack, extending the stack if necessary.
  282. Handles 'set' magic.  Does not use C<TARG>.  See also C<XPUSHu>, C<mPUSHu>
  283. and C<PUSHu>.
  284.  
  285. =cut
  286. */
  287.  
  288. #define EXTEND(p,n)    STMT_START { if (PL_stack_max - p < (int)(n)) {        \
  289.                 sp = stack_grow(sp,p, (int) (n));        \
  290.             } } STMT_END
  291.  
  292. /* Same thing, but update mark register too. */
  293. #define MEXTEND(p,n)    STMT_START {if (PL_stack_max - p < (int)(n)) {        \
  294.                 int markoff = mark - PL_stack_base;        \
  295.                 sp = stack_grow(sp,p,(int) (n));        \
  296.                 mark = PL_stack_base + markoff;        \
  297.             } } STMT_END
  298.  
  299. #define PUSHs(s)    (*++sp = (s))
  300. #define PUSHTARG    STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END
  301. #define PUSHp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END
  302. #define PUSHn(n)    STMT_START { sv_setnv(TARG, (NV)(n)); PUSHTARG; } STMT_END
  303. #define PUSHi(i)    STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END
  304. #define PUSHu(u)    STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
  305.  
  306. #define XPUSHs(s)    STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END
  307. #define XPUSHTARG    STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END
  308. #define XPUSHp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END
  309. #define XPUSHn(n)    STMT_START { sv_setnv(TARG, (NV)(n)); XPUSHTARG; } STMT_END
  310. #define XPUSHi(i)    STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END
  311. #define XPUSHu(u)    STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
  312. #define XPUSHundef    STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END
  313.  
  314. #define PUSHmortal    PUSHs(sv_newmortal())
  315. #define mPUSHp(p,l)    sv_setpvn_mg(PUSHmortal, (p), (l))
  316. #define mPUSHn(n)    sv_setnv_mg(PUSHmortal, (NV)(n))
  317. #define mPUSHi(i)    sv_setiv_mg(PUSHmortal, (IV)(i))
  318. #define mPUSHu(u)    sv_setuv_mg(PUSHmortal, (UV)(u))
  319.  
  320. #define XPUSHmortal    XPUSHs(sv_newmortal())
  321. #define mXPUSHp(p,l)    STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END
  322. #define mXPUSHn(n)    STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END
  323. #define mXPUSHi(i)    STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END
  324. #define mXPUSHu(u)    STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END
  325.  
  326. #define SETs(s)        (*sp = s)
  327. #define SETTARG        STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END
  328. #define SETp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END
  329. #define SETn(n)        STMT_START { sv_setnv(TARG, (NV)(n)); SETTARG; } STMT_END
  330. #define SETi(i)        STMT_START { sv_setiv(TARG, (IV)(i)); SETTARG; } STMT_END
  331. #define SETu(u)        STMT_START { sv_setuv(TARG, (UV)(u)); SETTARG; } STMT_END
  332.  
  333. #define dTOPss        SV *sv = TOPs
  334. #define dPOPss        SV *sv = POPs
  335. #define dTOPnv        NV value = TOPn
  336. #define dPOPnv        NV value = POPn
  337. #define dTOPiv        IV value = TOPi
  338. #define dPOPiv        IV value = POPi
  339. #define dTOPuv        UV value = TOPu
  340. #define dPOPuv        UV value = POPu
  341. #ifdef HAS_QUAD
  342. #define dTOPqv        Quad_t value = TOPu
  343. #define dPOPqv        Quad_t value = POPu
  344. #define dTOPuqv        Uquad_t value = TOPuq
  345. #define dPOPuqv        Uquad_t value = POPuq
  346. #endif
  347.  
  348. #define dPOPXssrl(X)    SV *right = POPs; SV *left = CAT2(X,s)
  349. #define dPOPXnnrl(X)    NV right = POPn; NV left = CAT2(X,n)
  350. #define dPOPXiirl(X)    IV right = POPi; IV left = CAT2(X,i)
  351.  
  352. #define USE_LEFT(sv) \
  353.     (SvOK(sv) || SvGMAGICAL(sv) || !(PL_op->op_flags & OPf_STACKED))
  354. #define dPOPXnnrl_ul(X)    \
  355.     NV right = POPn;                \
  356.     SV *leftsv = CAT2(X,s);                \
  357.     NV left = USE_LEFT(leftsv) ? SvNV(leftsv) : 0.0
  358. #define dPOPXiirl_ul(X) \
  359.     IV right = POPi;                    \
  360.     SV *leftsv = CAT2(X,s);                \
  361.     IV left = USE_LEFT(leftsv) ? SvIV(leftsv) : 0
  362.  
  363. #define dPOPPOPssrl    dPOPXssrl(POP)
  364. #define dPOPPOPnnrl    dPOPXnnrl(POP)
  365. #define dPOPPOPnnrl_ul    dPOPXnnrl_ul(POP)
  366. #define dPOPPOPiirl    dPOPXiirl(POP)
  367. #define dPOPPOPiirl_ul    dPOPXiirl_ul(POP)
  368.  
  369. #define dPOPTOPssrl    dPOPXssrl(TOP)
  370. #define dPOPTOPnnrl    dPOPXnnrl(TOP)
  371. #define dPOPTOPnnrl_ul    dPOPXnnrl_ul(TOP)
  372. #define dPOPTOPiirl    dPOPXiirl(TOP)
  373. #define dPOPTOPiirl_ul    dPOPXiirl_ul(TOP)
  374.  
  375. #define RETPUSHYES    RETURNX(PUSHs(&PL_sv_yes))
  376. #define RETPUSHNO    RETURNX(PUSHs(&PL_sv_no))
  377. #define RETPUSHUNDEF    RETURNX(PUSHs(&PL_sv_undef))
  378.  
  379. #define RETSETYES    RETURNX(SETs(&PL_sv_yes))
  380. #define RETSETNO    RETURNX(SETs(&PL_sv_no))
  381. #define RETSETUNDEF    RETURNX(SETs(&PL_sv_undef))
  382.  
  383. #define ARGTARG        PL_op->op_targ
  384.  
  385.     /* See OPpTARGET_MY: */
  386. #define MAXARG        (PL_op->op_private & 15)
  387.  
  388. #define SWITCHSTACK(f,t) \
  389.     STMT_START {                            \
  390.     AvFILLp(f) = sp - PL_stack_base;                \
  391.     PL_stack_base = AvARRAY(t);                    \
  392.     PL_stack_max = PL_stack_base + AvMAX(t);            \
  393.     sp = PL_stack_sp = PL_stack_base + AvFILLp(t);            \
  394.     PL_curstack = t;                        \
  395.     } STMT_END
  396.  
  397. #define EXTEND_MORTAL(n) \
  398.     STMT_START {                            \
  399.     if (PL_tmps_ix + (n) >= PL_tmps_max)                \
  400.         tmps_grow(n);                        \
  401.     } STMT_END
  402.  
  403. #define AMGf_noright    1
  404. #define AMGf_noleft    2
  405. #define AMGf_assign    4
  406. #define AMGf_unary    8
  407.  
  408. #define tryAMAGICbinW(meth,assign,set) STMT_START { \
  409.           if (PL_amagic_generation) { \
  410.         SV* tmpsv; \
  411.         SV* right= *(sp); SV* left= *(sp-1);\
  412.         if ((SvAMAGIC(left)||SvAMAGIC(right))&&\
  413.         (tmpsv=amagic_call(left, \
  414.                    right, \
  415.                    CAT2(meth,_amg), \
  416.                    (assign)? AMGf_assign: 0))) {\
  417.            SPAGAIN;    \
  418.            (void)POPs; set(tmpsv); RETURN; } \
  419.       } \
  420.     } STMT_END
  421.  
  422. #define tryAMAGICbin(meth,assign) tryAMAGICbinW(meth,assign,SETsv)
  423. #define tryAMAGICbinSET(meth,assign) tryAMAGICbinW(meth,assign,SETs)
  424.  
  425. #define AMG_CALLun(sv,meth) amagic_call(sv,&PL_sv_undef,  \
  426.                     CAT2(meth,_amg),AMGf_noright | AMGf_unary)
  427. #define AMG_CALLbinL(left,right,meth) \
  428.             amagic_call(left,right,CAT2(meth,_amg),AMGf_noright)
  429.  
  430. #define tryAMAGICunW(meth,set,shift,ret) STMT_START { \
  431.           if (PL_amagic_generation) { \
  432.         SV* tmpsv; \
  433.         SV* arg= sp[shift]; \
  434.           if(0) goto am_again;  /* shut up unused warning */ \
  435.       am_again: \
  436.         if ((SvAMAGIC(arg))&&\
  437.         (tmpsv=AMG_CALLun(arg,meth))) {\
  438.            SPAGAIN; if (shift) sp += shift; \
  439.            set(tmpsv); ret; } \
  440.       } \
  441.     } STMT_END
  442.  
  443. #define FORCE_SETs(sv) STMT_START { sv_setsv(TARG, (sv)); SETTARG; } STMT_END
  444.  
  445. #define tryAMAGICun(meth)    tryAMAGICunW(meth,SETsvUN,0,RETURN)
  446. #define tryAMAGICunSET(meth)    tryAMAGICunW(meth,SETs,0,RETURN)
  447. #define tryAMAGICunTARGET(meth, shift)                    \
  448.     { dSP; sp--;     /* get TARGET from below PL_stack_sp */        \
  449.         { dTARGETSTACKED;                         \
  450.         { dSP; tryAMAGICunW(meth,FORCE_SETs,shift,RETURN);}}}
  451.  
  452. #define setAGAIN(ref) sv = ref;                            \
  453.   if (!SvROK(ref))                                \
  454.       Perl_croak(aTHX_ "Overloaded dereference did not return a reference");    \
  455.   if (ref != arg && SvRV(ref) != SvRV(arg)) {                    \
  456.       arg = ref;                                \
  457.       goto am_again;                                \
  458.   }
  459.  
  460. #define tryAMAGICunDEREF(meth) tryAMAGICunW(meth,setAGAIN,0,(void)0)
  461.  
  462. #define opASSIGN (PL_op->op_flags & OPf_STACKED)
  463. #define SETsv(sv)    STMT_START {                    \
  464.         if (opASSIGN || (SvFLAGS(TARG) & SVs_PADMY))        \
  465.            { sv_setsv(TARG, (sv)); SETTARG; }            \
  466.         else SETs(sv); } STMT_END
  467.  
  468. #define SETsvUN(sv)    STMT_START {                    \
  469.         if (SvFLAGS(TARG) & SVs_PADMY)        \
  470.            { sv_setsv(TARG, (sv)); SETTARG; }            \
  471.         else SETs(sv); } STMT_END
  472.  
  473. /* newSVsv does not behave as advertised, so we copy missing
  474.  * information by hand */
  475.  
  476. /* SV* ref causes confusion with the member variable
  477.    changed SV* ref to SV* tmpRef */
  478. #define RvDEEPCP(rv) STMT_START { SV* tmpRef=SvRV(rv);      \
  479.   if (SvREFCNT(tmpRef)>1) {                 \
  480.     SvRV(rv)=AMG_CALLun(rv,copy);    \
  481.     SvREFCNT_dec(tmpRef);                   \
  482.   } } STMT_END
  483.  
  484. /*
  485. =for apidoc mU||LVRET
  486. True if this op will be the return value of an lvalue subroutine
  487.  
  488. =cut */
  489. #define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub())
  490.