This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perlguts: Note that various SAVEfoo macros are documented
[perl5.git] / perl.h
CommitLineData
a0d0e21e 1/* perl.h
a687059c 2 *
1129b882 3 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
5cd3f21a 4 * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others
a687059c 5 *
352d5a3a
LW
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.
8d063cd8 8 *
8d063cd8 9 */
d6376244 10
85e6fe83
LW
11#ifndef H_PERL
12#define H_PERL 1
8d063cd8 13
760ac839
LW
14#ifdef PERL_FOR_X2P
15/*
d460ef45 16 * This file is being used for x2p stuff.
760ac839 17 * Above symbol is defined via -D in 'x2p/Makefile.SH'
d460ef45 18 * Decouple x2p stuff from some of perls more extreme eccentricities.
760ac839 19 */
55497cff 20#undef MULTIPLICITY
760ac839
LW
21#undef USE_STDIO
22#define USE_STDIO
23#endif /* PERL_FOR_X2P */
24
d460ef45 25#ifdef PERL_MICRO
12ae5dfc
JH
26# include "uconfig.h"
27#else
611cf957 28# include "config.h"
12ae5dfc 29#endif
0cb96387 30
70febf4f
CB
31/* this is used for functions which take a depth trailing
32 * argument under debugging */
33#ifdef DEBUGGING
34#define _pDEPTH ,U32 depth
35#define _aDEPTH ,depth
36#else
37#define _pDEPTH
38#define _aDEPTH
39#endif
40
7dc3eb73 41/* NOTE 1: that with gcc -std=c89 the __STDC_VERSION__ is *not* defined
9267464d 42 * because the __STDC_VERSION__ became a thing only with C90. Therefore,
7dc3eb73
JH
43 * with gcc, HAS_C99 will never become true as long as we use -std=c89.
44
45 * NOTE 2: headers lie. Do not expect that if HAS_C99 gets to be true,
46 * all the C99 features are there and are correct. */
9267464d 47#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
996959af 48 defined(_STDC_C99) || defined(__c99)
86a3cabf 49# define HAS_C99 1
86a3cabf
JH
50#endif
51
2c2d71f5
JH
52/* See L<perlguts/"The Perl API"> for detailed notes on
53 * PERL_IMPLICIT_CONTEXT and PERL_IMPLICIT_SYS */
54
7ee02ac1 55/* XXX NOTE that from here --> to <-- the same logic is
ac6bedea
JH
56 * repeated in makedef.pl, so be certain to update
57 * both places when editing. */
58
6f4183fe 59#ifdef USE_ITHREADS
acfe0abc 60# if !defined(MULTIPLICITY)
6f4183fe
GS
61# define MULTIPLICITY
62# endif
63#endif
64
97aff369
JH
65#ifdef MULTIPLICITY
66# ifndef PERL_IMPLICIT_CONTEXT
67# define PERL_IMPLICIT_CONTEXT
68# endif
69#endif
70
026fd48b
GH
71/* undef WIN32 when building on Cygwin (for libwin32) - gph */
72#ifdef __CYGWIN__
73# undef WIN32
74# undef _WIN32
75#endif
76
dd134d2c 77/* Use the reentrant APIs like localtime_r and getpwent_r */
7ee02ac1
KW
78/* Win32 has naturally threadsafe libraries, no need to use any _r variants.
79 * XXX KEEP makedef.pl copy of this code in sync */
14795193 80#if defined(USE_ITHREADS) && !defined(USE_REENTRANT_API) && !defined(NETWARE) && !defined(WIN32)
10bc17b6
JH
81# define USE_REENTRANT_API
82#endif
83
ac6bedea
JH
84/* <--- here ends the logic shared by perl.h and makedef.pl */
85
ea32afd3 86/*
51b56f5c 87=for apidoc_section Compiler directives
ea32afd3
KW
88=for apidoc AmnUu|void|EXTERN_C
89When not compiling using C++, expands to nothing.
90Otherwise is used in a declaration of a function to indicate the function
91should have external C linkage. This is required for things to work for just
92about all functions with external linkage compiled into perl.
93Often, you can use C<L</START_EXTERN_C>> ... C<L</END_EXTERN_C>> blocks
94surrounding all your code that you need to have this linkage.
95
96Example usage:
97
98 EXTERN_C int flock(int fd, int op);
99
100=for apidoc Amnu||START_EXTERN_C
101When not compiling using C++, expands to nothing.
102Otherwise begins a section of code in which every function will effectively
103have C<L</EXTERN_C>> applied to it, that is to have external C linkage. The
104section is ended by a C<L</END_EXTERN_C>>.
105
106=for apidoc Amnu||END_EXTERN_C
107When not compiling using C++, expands to nothing.
108Otherwise ends a section of code already begun by a C<L</START_EXTERN_C>>.
109
110=cut
111*/
112
cf5a8da6
MHM
113#undef START_EXTERN_C
114#undef END_EXTERN_C
115#undef EXTERN_C
116#ifdef __cplusplus
117# define START_EXTERN_C extern "C" {
118# define END_EXTERN_C }
119# define EXTERN_C extern "C"
120#else
121# define START_EXTERN_C
122# define END_EXTERN_C
123# define EXTERN_C extern
124#endif
125
17a6c8e3
AD
126/* Fallback definitions in case we don't have definitions from config.h.
127 This should only matter for systems that don't use Configure and
128 haven't been modified to define PERL_STATIC_INLINE yet.
129*/
130#if !defined(PERL_STATIC_INLINE)
131# ifdef HAS_STATIC_INLINE
132# define PERL_STATIC_INLINE static inline
133# else
134# define PERL_STATIC_INLINE static
135# endif
136#endif
137
f0e5c859
DD
138/* this used to be off by default, now its on, see perlio.h */
139#define PERLIO_FUNCS_CONST
140
c5be433b 141#ifdef PERL_IMPLICIT_CONTEXT
3db8f154
MB
142# ifndef MULTIPLICITY
143# define MULTIPLICITY
c5be433b 144# endif
e8dda941 145# define tTHX PerlInterpreter*
5aaab254 146# define pTHX tTHX my_perl PERL_UNUSED_DECL
3db8f154 147# define aTHX my_perl
9399a70c 148# define aTHXa(a) aTHX = (tTHX)a
8c3a0f6c
DIM
149# define dTHXa(a) pTHX = (tTHX)a
150# define dTHX pTHX = PERL_GET_THX
c5be433b 151# define pTHX_ pTHX,
c5be433b 152# define aTHX_ aTHX,
4373e329 153# define pTHX_1 2
894356b3
GS
154# define pTHX_2 3
155# define pTHX_3 4
156# define pTHX_4 5
4373e329
AL
157# define pTHX_5 6
158# define pTHX_6 7
a3b680e6
AL
159# define pTHX_7 8
160# define pTHX_8 9
161# define pTHX_9 10
a6fc70e5 162# define pTHX_12 13
e8dda941
JD
163# if defined(DEBUGGING) && !defined(PERL_TRACK_MEMPOOL)
164# define PERL_TRACK_MEMPOOL
165# endif
166#else
167# undef PERL_TRACK_MEMPOOL
c5be433b
GS
168#endif
169
2d17fb74
KW
170#ifdef DEBUGGING
171# define dTHX_DEBUGGING dTHX
172#else
173# define dTHX_DEBUGGING dNOOP
174#endif
175
76e3520e 176#define STATIC static
16c91539
BM
177
178#ifndef PERL_CORE
179/* Do not use these macros. They were part of PERL_OBJECT, which was an
180 * implementation of multiplicity using C++ objects. They have been left
181 * here solely for the sake of XS code which has incorrectly
182 * cargo-culted them.
183 */
76e3520e 184#define CPERLscope(x) x
565764a8 185#define CPERLarg void
76e3520e 186#define CPERLarg_
e3b8966e 187#define _CPERLarg
1d583055
GS
188#define PERL_OBJECT_THIS
189#define _PERL_OBJECT_THIS
190#define PERL_OBJECT_THIS_
312caa8e 191#define CALL_FPTR(fptr) (*fptr)
ef69c8fc 192#define MEMBER_TO_FPTR(name) name
16c91539 193#endif /* !PERL_CORE */
76e3520e 194
16c91539 195#define CALLRUNOPS PL_runops
f9f4320a 196
3ab4a224 197#define CALLREGCOMP(sv, flags) Perl_pregcomp(aTHX_ (sv),(flags))
f9f4320a 198
16c91539 199#define CALLREGCOMP_ENG(prog, sv, flags) (prog)->comp(aTHX_ sv, flags)
a340edde 200#define CALLREGEXEC(prog,stringarg,strend,strbeg,minend,sv,data,flags) \
16c91539 201 RX_ENGINE(prog)->exec(aTHX_ (prog),(stringarg),(strend), \
a340edde 202 (strbeg),(minend),(sv),(data),(flags))
52a21eb3
DM
203#define CALLREG_INTUIT_START(prog,sv,strbeg,strpos,strend,flags,data) \
204 RX_ENGINE(prog)->intuit(aTHX_ (prog), (sv), (strbeg), (strpos), \
f9f4320a
YO
205 (strend),(flags),(data))
206#define CALLREG_INTUIT_STRING(prog) \
16c91539 207 RX_ENGINE(prog)->checkstr(aTHX_ (prog))
f8149455 208
f8149455
YO
209#define CALLREGFREE(prog) \
210 Perl_pregfree(aTHX_ (prog))
211
212#define CALLREGFREE_PVT(prog) \
4c8117d3 213 if(prog && RX_ENGINE(prog)) RX_ENGINE(prog)->rxfree(aTHX_ (prog))
f8149455 214
2fdbfb4d 215#define CALLREG_NUMBUF_FETCH(rx,paren,usesv) \
16c91539 216 RX_ENGINE(rx)->numbered_buff_FETCH(aTHX_ (rx),(paren),(usesv))
93b32b6d 217
2fdbfb4d 218#define CALLREG_NUMBUF_STORE(rx,paren,value) \
16c91539 219 RX_ENGINE(rx)->numbered_buff_STORE(aTHX_ (rx),(paren),(value))
2fdbfb4d
AB
220
221#define CALLREG_NUMBUF_LENGTH(rx,sv,paren) \
16c91539 222 RX_ENGINE(rx)->numbered_buff_LENGTH(aTHX_ (rx),(sv),(paren))
2fdbfb4d 223
192b9cd1 224#define CALLREG_NAMED_BUFF_FETCH(rx, key, flags) \
16c91539 225 RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_FETCH))
192b9cd1
AB
226
227#define CALLREG_NAMED_BUFF_STORE(rx, key, value, flags) \
16c91539 228 RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), (value), ((flags) | RXapif_STORE))
192b9cd1
AB
229
230#define CALLREG_NAMED_BUFF_DELETE(rx, key, flags) \
16c91539 231 RX_ENGINE(rx)->named_buff(aTHX_ (rx),(key), NULL, ((flags) | RXapif_DELETE))
192b9cd1
AB
232
233#define CALLREG_NAMED_BUFF_CLEAR(rx, flags) \
16c91539 234 RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_CLEAR))
192b9cd1
AB
235
236#define CALLREG_NAMED_BUFF_EXISTS(rx, key, flags) \
16c91539 237 RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_EXISTS))
192b9cd1
AB
238
239#define CALLREG_NAMED_BUFF_FIRSTKEY(rx, flags) \
16c91539 240 RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), NULL, ((flags) | RXapif_FIRSTKEY))
192b9cd1
AB
241
242#define CALLREG_NAMED_BUFF_NEXTKEY(rx, lastkey, flags) \
16c91539 243 RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), (lastkey), ((flags) | RXapif_NEXTKEY))
192b9cd1
AB
244
245#define CALLREG_NAMED_BUFF_SCALAR(rx, flags) \
16c91539 246 RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_SCALAR))
192b9cd1
AB
247
248#define CALLREG_NAMED_BUFF_COUNT(rx) \
16c91539 249 RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, RXapif_REGNAMES_COUNT)
192b9cd1
AB
250
251#define CALLREG_NAMED_BUFF_ALL(rx, flags) \
16c91539 252 RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, flags)
93b32b6d 253
49d7dfbc 254#define CALLREG_PACKAGE(rx) \
16c91539 255 RX_ENGINE(rx)->qr_package(aTHX_ (rx))
93b32b6d 256
00f254e2 257#if defined(USE_ITHREADS)
f9f4320a 258#define CALLREGDUPE(prog,param) \
f8149455
YO
259 Perl_re_dup(aTHX_ (prog),(param))
260
261#define CALLREGDUPE_PVT(prog,param) \
16c91539 262 (prog ? RX_ENGINE(prog)->dupe(aTHX_ (prog),(param)) \
00f254e2 263 : (REGEXP *)NULL)
f9f4320a 264#endif
14dd3ad8 265
bfde97e0
TK
266/* some compilers impersonate gcc */
267#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
268# define PERL_IS_GCC 1
269#endif
270
09f0a348
TK
271/* In case Configure was not used (we are using a "canned config"
272 * such as Win32, or a cross-compilation setup, for example) try going
273 * by the gcc major and minor versions. One useful URL is
274 * http://www.ohse.de/uwe/articles/gcc-attributes.html,
275 * but contrary to this information warn_unused_result seems
276 * not to be in gcc 3.3.5, at least. --jhi
277 * Also, when building extensions with an installed perl, this allows
278 * the user to upgrade gcc and get the right attributes, rather than
279 * relying on the list generated at Configure time. --AD
280 * Set these up now otherwise we get confused when some of the <*thread.h>
281 * includes below indirectly pull in <perlio.h> (which needs to know if we
282 * have HASATTRIBUTE_FORMAT).
283 */
284
285#ifndef PERL_MICRO
286#if defined __GNUC__ && !defined(__INTEL_COMPILER)
287# if __GNUC__ == 3 && __GNUC_MINOR__ >= 1 || __GNUC__ > 3 /* 3.1 -> */
288# define HASATTRIBUTE_DEPRECATED
289# endif
290# if __GNUC__ >= 3 /* 3.0 -> */ /* XXX Verify this version */
291# define HASATTRIBUTE_FORMAT
292# if defined __MINGW32__
293# define PRINTF_FORMAT_NULL_OK
294# endif
295# endif
296# if __GNUC__ >= 3 /* 3.0 -> */
297# define HASATTRIBUTE_MALLOC
298# endif
299# if __GNUC__ == 3 && __GNUC_MINOR__ >= 3 || __GNUC__ > 3 /* 3.3 -> */
300# define HASATTRIBUTE_NONNULL
301# endif
302# if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 || __GNUC__ > 2 /* 2.5 -> */
303# define HASATTRIBUTE_NORETURN
304# endif
305# if __GNUC__ >= 3 /* gcc 3.0 -> */
306# define HASATTRIBUTE_PURE
307# endif
308# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3 /* 3.4 -> */
309# define HASATTRIBUTE_UNUSED
310# endif
311# if __GNUC__ == 3 && __GNUC_MINOR__ == 3 && !defined(__cplusplus)
312# define HASATTRIBUTE_UNUSED /* gcc-3.3, but not g++-3.3. */
313# endif
314# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3 /* 3.4 -> */
315# define HASATTRIBUTE_WARN_UNUSED_RESULT
316# endif
d7113604
TK
317/* always_inline is buggy in gcc <= 4.6 and causes compilation errors */
318# if __GNUC__ == 4 && __GNUC_MINOR__ >= 7 || __GNUC__ > 4 /* 4.7 -> */
f1e99d0d
TK
319# define HASATTRIBUTE_ALWAYS_INLINE
320# endif
09f0a348
TK
321#endif
322#endif /* #ifndef PERL_MICRO */
a20207d7 323
09f0a348
TK
324#ifdef HASATTRIBUTE_DEPRECATED
325# define __attribute__deprecated__ __attribute__((deprecated))
326#endif
327#ifdef HASATTRIBUTE_FORMAT
328# define __attribute__format__(x,y,z) __attribute__((format(x,y,z)))
329#endif
330#ifdef HASATTRIBUTE_MALLOC
331# define __attribute__malloc__ __attribute__((__malloc__))
332#endif
333#ifdef HASATTRIBUTE_NONNULL
334# define __attribute__nonnull__(a) __attribute__((nonnull(a)))
335#endif
336#ifdef HASATTRIBUTE_NORETURN
337# define __attribute__noreturn__ __attribute__((noreturn))
338#endif
339#ifdef HASATTRIBUTE_PURE
340# define __attribute__pure__ __attribute__((pure))
341#endif
342#ifdef HASATTRIBUTE_UNUSED
343# define __attribute__unused__ __attribute__((unused))
344#endif
345#ifdef HASATTRIBUTE_WARN_UNUSED_RESULT
346# define __attribute__warn_unused_result__ __attribute__((warn_unused_result))
347#endif
f1e99d0d 348#ifdef HASATTRIBUTE_ALWAYS_INLINE
d7113604 349/* always_inline is buggy in gcc <= 4.6 and causes compilation errors */
bfde97e0 350# if !defined(PERL_IS_GCC) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7 || __GNUC__ > 4)
d7113604
TK
351# define __attribute__always_inline__ __attribute__((always_inline))
352# endif
f1e99d0d 353#endif
bcdf7404 354
09f0a348
TK
355/* If we haven't defined the attributes yet, define them to blank. */
356#ifndef __attribute__deprecated__
357# define __attribute__deprecated__
358#endif
359#ifndef __attribute__format__
360# define __attribute__format__(x,y,z)
361#endif
362#ifndef __attribute__malloc__
363# define __attribute__malloc__
364#endif
365#ifndef __attribute__nonnull__
366# define __attribute__nonnull__(a)
367#endif
368#ifndef __attribute__noreturn__
369# define __attribute__noreturn__
370#endif
371#ifndef __attribute__pure__
372# define __attribute__pure__
373#endif
374#ifndef __attribute__unused__
375# define __attribute__unused__
376#endif
377#ifndef __attribute__warn_unused_result__
378# define __attribute__warn_unused_result__
379#endif
f1e99d0d
TK
380#ifndef __attribute__always_inline__
381# define __attribute__always_inline__
382#endif
a20207d7 383
09f0a348
TK
384/* Some OS warn on NULL format to printf */
385#ifdef PRINTF_FORMAT_NULL_OK
386# define __attribute__format__null_ok__(x,y,z) __attribute__format__(x,y,z)
387#else
388# define __attribute__format__null_ok__(x,y,z)
389#endif
a20207d7 390
5ba4cab2
SH
391/*
392 * Because of backward compatibility reasons the PERL_UNUSED_DECL
393 * cannot be changed from postfix to PERL_UNUSED_DECL(x). Sigh.
394 *
395 * Note that there are C compilers such as MetroWerks CodeWarrior
1266ad8c 396 * which do not have an "inlined" way (like the gcc __attribute__) of
5ba4cab2
SH
397 * marking unused variables (they need e.g. a #pragma) and therefore
398 * cpp macros like PERL_UNUSED_DECL cannot work for this purpose, even
399 * if it were PERL_UNUSED_DECL(x), which it cannot be (see above).
400 *
401 */
1266ad8c 402
5b2bd0a5 403#ifndef PERL_UNUSED_DECL
09f0a348 404# define PERL_UNUSED_DECL __attribute__unused__
5b2bd0a5 405#endif
00f254e2 406
349b520e
DM
407/* gcc -Wall:
408 * for silencing unused variables that are actually used most of the time,
a730e3f2
JH
409 * but we cannot quite get rid of, such as "ax" in PPCODE+noargs xsubs,
410 * or variables/arguments that are used only in certain configurations.
fd2362a2 411
fd2362a2
KW
412=for apidoc Am||PERL_UNUSED_ARG|void x
413This is used to suppress compiler warnings that a parameter to a function is
414not used. This situation can arise, for example, when a parameter is needed
415under some configuration conditions, but not others, so that C preprocessor
416conditional compilation causes it be used just some times.
417
418=for apidoc Amn||PERL_UNUSED_CONTEXT
419This is used to suppress compiler warnings that the thread context parameter to
420a function is not used. This situation can arise, for example, when a
421C preprocessor conditional compilation causes it be used just some times.
422
423=for apidoc Am||PERL_UNUSED_VAR|void x
424This is used to suppress compiler warnings that the variable I<x> is not used.
425This situation can arise, for example, when a C preprocessor conditional
426compilation causes it be used just some times.
427
428=cut
349b520e 429 */
53c1dcc0 430#ifndef PERL_UNUSED_ARG
c707756e 431# define PERL_UNUSED_ARG(x) ((void)sizeof(x))
ad73156c 432#endif
53c1dcc0 433#ifndef PERL_UNUSED_VAR
a730e3f2 434# define PERL_UNUSED_VAR(x) ((void)sizeof(x))
53c1dcc0 435#endif
ad73156c 436
8c3a0f6c 437#if defined(USE_ITHREADS)
96a5add6
AL
438# define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
439#else
440# define PERL_UNUSED_CONTEXT
441#endif
442
24e7ff4e
JH
443/* gcc (-ansi) -pedantic doesn't allow gcc statement expressions,
444 * g++ allows them but seems to have problems with them
445 * (insane errors ensue).
446 * g++ does not give insane errors now (RMB 2008-01-30, gcc 4.2.2).
447 */
448#if defined(PERL_GCC_PEDANTIC) || \
449 (defined(__GNUC__) && defined(__cplusplus) && \
450 ((__GNUC__ < 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ < 2))))
451# ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
452# define PERL_GCC_BRACE_GROUPS_FORBIDDEN
453# endif
454#endif
455
fd2362a2
KW
456/*
457
458=for apidoc Am||PERL_UNUSED_RESULT|void x
459
460This macro indicates to discard the return value of the function call inside
00b72c9f 461it, I<e.g.>,
fd2362a2
KW
462
463 PERL_UNUSED_RESULT(foo(a, b))
464
00b72c9f
KW
465The main reason for this is that the combination of C<gcc -Wunused-result>
466(part of C<-Wall>) and the C<__attribute__((warn_unused_result))> cannot
467be silenced with casting to C<void>. This causes trouble when the system
fd2362a2
KW
468header files use the attribute.
469
470Use C<PERL_UNUSED_RESULT> sparingly, though, since usually the warning
471is there for a good reason: you might lose success/failure information,
472or leak resources, or changes in resources.
473
00b72c9f 474But sometimes you just want to ignore the return value, I<e.g.>, on
fd2362a2
KW
475codepaths soon ending up in abort, or in "best effort" attempts,
476or in situations where there is no good way to handle failures.
477
478Sometimes C<PERL_UNUSED_RESULT> might not be the most natural way:
479another possibility is that you can capture the return value
480and use C<L</PERL_UNUSED_VAR>> on that.
481
482=cut
483
484The __typeof__() is used instead of typeof() since typeof() is not
485available under strict C89, and because of compilers masquerading
486as gcc (clang and icc), we want exactly the gcc extension
487__typeof__ and nothing else.
488
489*/
ffea512f 490#ifndef PERL_UNUSED_RESULT
b469f1e0
JH
491# if defined(__GNUC__) && defined(HASATTRIBUTE_WARN_UNUSED_RESULT)
492# define PERL_UNUSED_RESULT(v) STMT_START { __typeof__(v) z = (v); (void)sizeof(z); } STMT_END
ffea512f
JH
493# else
494# define PERL_UNUSED_RESULT(v) ((void)(v))
495# endif
496#endif
497
e7ae132e
KW
498#if defined(_MSC_VER)
499/* XXX older MSVC versions have a smallish macro buffer */
500#define PERL_SMALL_MACRO_BUFFER
501#endif
502
b56aac20
DM
503/* on gcc (and clang), specify that a warning should be temporarily
504 * ignored; e.g.
505 *
7347ee54 506 * GCC_DIAG_IGNORE_DECL(-Wmultichar);
b56aac20 507 * char b = 'ab';
7347ee54 508 * GCC_DIAG_RESTORE_DECL;
b56aac20
DM
509 *
510 * based on http://dbp-consulting.com/tutorials/SuppressingGCCWarnings.html
511 *
512 * Note that "pragma GCC diagnostic push/pop" was added in GCC 4.6, Mar 2011;
513 * clang only pretends to be GCC 4.2, but still supports push/pop.
c1d6452f 514 *
7347ee54
Z
515 * Note on usage: all macros must be used at a place where a declaration
516 * or statement can occur, i.e., not in the middle of an expression.
517 * *_DIAG_IGNORE() and *_DIAG_RESTORE can be used in any such place, but
518 * must be used without a following semicolon. *_DIAG_IGNORE_DECL() and
519 * *_DIAG_RESTORE_DECL must be used with a following semicolon, and behave
520 * syntactically as declarations (like dNOOP). *_DIAG_IGNORE_STMT()
521 * and *_DIAG_RESTORE_STMT must be used with a following semicolon,
522 * and behave syntactically as statements (like NOOP).
c1d6452f 523 *
b56aac20
DM
524 */
525
57d4b8c5 526#if defined(__clang__) || defined(__clang) || \
d28ce8b4 527 (defined( __GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406)
c1d6452f
JH
528# define GCC_DIAG_PRAGMA(x) _Pragma (#x)
529/* clang has "clang diagnostic" pragmas, but also understands gcc. */
b56aac20 530# define GCC_DIAG_IGNORE(x) _Pragma("GCC diagnostic push") \
c1d6452f 531 GCC_DIAG_PRAGMA(GCC diagnostic ignored #x)
b56aac20
DM
532# define GCC_DIAG_RESTORE _Pragma("GCC diagnostic pop")
533#else
8ce6f80a
JH
534# define GCC_DIAG_IGNORE(w)
535# define GCC_DIAG_RESTORE
b56aac20 536#endif
7347ee54
Z
537#define GCC_DIAG_IGNORE_DECL(x) GCC_DIAG_IGNORE(x) dNOOP
538#define GCC_DIAG_RESTORE_DECL GCC_DIAG_RESTORE dNOOP
539#define GCC_DIAG_IGNORE_STMT(x) GCC_DIAG_IGNORE(x) NOOP
540#define GCC_DIAG_RESTORE_STMT GCC_DIAG_RESTORE NOOP
337458b1
JH
541/* for clang specific pragmas */
542#if defined(__clang__) || defined(__clang)
543# define CLANG_DIAG_PRAGMA(x) _Pragma (#x)
544# define CLANG_DIAG_IGNORE(x) _Pragma("clang diagnostic push") \
545 CLANG_DIAG_PRAGMA(clang diagnostic ignored #x)
546# define CLANG_DIAG_RESTORE _Pragma("clang diagnostic pop")
547#else
548# define CLANG_DIAG_IGNORE(w)
549# define CLANG_DIAG_RESTORE
550#endif
7347ee54
Z
551#define CLANG_DIAG_IGNORE_DECL(x) CLANG_DIAG_IGNORE(x) dNOOP
552#define CLANG_DIAG_RESTORE_DECL CLANG_DIAG_RESTORE dNOOP
553#define CLANG_DIAG_IGNORE_STMT(x) CLANG_DIAG_IGNORE(x) NOOP
554#define CLANG_DIAG_RESTORE_STMT CLANG_DIAG_RESTORE NOOP
b56aac20 555
6879a07b
TK
556#if defined(_MSC_VER) && (_MSC_VER >= 1300)
557# define MSVC_DIAG_IGNORE(x) __pragma(warning(push)) \
558 __pragma(warning(disable : x))
559# define MSVC_DIAG_RESTORE __pragma(warning(pop))
560#else
561# define MSVC_DIAG_IGNORE(x)
562# define MSVC_DIAG_RESTORE
563#endif
564#define MSVC_DIAG_IGNORE_DECL(x) MSVC_DIAG_IGNORE(x) dNOOP
565#define MSVC_DIAG_RESTORE_DECL MSVC_DIAG_RESTORE dNOOP
566#define MSVC_DIAG_IGNORE_STMT(x) MSVC_DIAG_IGNORE(x) NOOP
567#define MSVC_DIAG_RESTORE_STMT MSVC_DIAG_RESTORE NOOP
568
6f207bd3 569#define NOOP /*EMPTY*/(void)0
91ca80c3 570#define dNOOP struct Perl___notused_struct
71be2cbc 571
0cb96387 572#ifndef pTHX
a78adc84 573/* Don't bother defining tTHX ; using it outside
e8dda941
JD
574 * code guarded by PERL_IMPLICIT_CONTEXT is an error.
575 */
0cb96387
GS
576# define pTHX void
577# define pTHX_
0cb96387
GS
578# define aTHX
579# define aTHX_
9399a70c 580# define aTHXa(a) NOOP
0cb96387
GS
581# define dTHXa(a) dNOOP
582# define dTHX dNOOP
894356b3
GS
583# define pTHX_1 1
584# define pTHX_2 2
585# define pTHX_3 3
586# define pTHX_4 4
3d42dc86
RGS
587# define pTHX_5 5
588# define pTHX_6 6
a3b680e6
AL
589# define pTHX_7 7
590# define pTHX_8 8
591# define pTHX_9 9
a6fc70e5 592# define pTHX_12 12
0cb96387
GS
593#endif
594
c91f661c
DIM
595#ifndef PERL_CORE
596/* Backwards compatibility macro for XS code. It used to be part of
597 * the PERL_GLOBAL_STRUCT(_PRIVATE) feature, which no longer exists */
27da23d5
JH
598# define dVAR dNOOP
599#endif
600
b4f7f263
GS
601/* these are only defined for compatibility; should not be used internally */
602#if !defined(pTHXo) && !defined(PERL_CORE)
0cb96387
GS
603# define pTHXo pTHX
604# define pTHXo_ pTHX_
0cb96387
GS
605# define aTHXo aTHX
606# define aTHXo_ aTHX_
c5be433b 607# define dTHXo dTHX
71d280e3 608# define dTHXoa(x) dTHXa(x)
0cb96387
GS
609#endif
610
611#ifndef pTHXx
5aaab254 612# define pTHXx PerlInterpreter *my_perl
0cb96387 613# define pTHXx_ pTHXx,
0cb96387
GS
614# define aTHXx my_perl
615# define aTHXx_ aTHXx,
c5be433b 616# define dTHXx dTHX
22c35a8c 617#endif
71be2cbc 618
1de7c2ac
GS
619/* Under PERL_IMPLICIT_SYS (used in Windows for fork emulation)
620 * PerlIO_foo() expands to PL_StdIO->pFOO(PL_StdIO, ...).
621 * dTHXs is therefore needed for all functions using PerlIO_foo(). */
622#ifdef PERL_IMPLICIT_SYS
27da23d5 623# define dTHXs dTHX
1de7c2ac 624#else
27da23d5 625# define dTHXs dNOOP
1de7c2ac
GS
626#endif
627
5b692037
JH
628#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
629# ifndef PERL_USE_GCC_BRACE_GROUPS
630# define PERL_USE_GCC_BRACE_GROUPS
631# endif
632#endif
633
728e2803 634/*
51b56f5c 635=for apidoc_section Compiler directives
16a2918c
KW
636=for apidoc AmnUu|void|STMT_START
637
638 STMT_START { statements; } STMT_END;
639
640can be used as a single statement, as in
641
642 if (x) STMT_START { ... } STMT_END; else ...
643
644These are often used in macro definitions. Note that you can't return a value
645out of them.
646
647=for apidoc AmnUhu|void|STMT_END
648
2ed33a45
KW
649=for apidoc AmnuU|bool|PERL_USE_GCC_BRACE_GROUPS
650
651This C pre-processor value, if defined, indicates that it is permissible to use
652the GCC brace groups extension. This extension is of the form C<({
653I<STATEMENTS> })>, and turns the block consisting of I<STATEMENTS> into an
654expression with a value, unlike plain C language blocks. This can present
655optimization possibilities, but there always needs to be an alternative in case
656this ability doesn't exist or has otherwise been forbidden.
657
16a2918c
KW
658=cut
659
660 Trying to select a version that gives no warnings...
661*/
728e2803 662#if !(defined(STMT_START) && defined(STMT_END))
5b692037 663# ifdef PERL_USE_GCC_BRACE_GROUPS
a0288114 664# define STMT_START (void)( /* gcc supports "({ STATEMENTS; })" */
728e2803
PP
665# define STMT_END )
666# else
728e2803
PP
667# define STMT_START do
668# define STMT_END while (0)
728e2803
PP
669# endif
670#endif
671
d6f9c181
JH
672#ifndef BYTEORDER /* Should never happen -- byteorder is in config.h */
673# define BYTEORDER 0x1234
79072805
LW
674#endif
675
8ada0baa
JH
676#if 'A' == 65 && 'I' == 73 && 'J' == 74 && 'Z' == 90
677#define ASCIIish
678#else
679#undef ASCIIish
680#endif
681
79072805
LW
682/*
683 * The following contortions are brought to you on behalf of all the
684 * standards, semi-standards, de facto standards, not-so-de-facto standards
685 * of the world, as well as all the other botches anyone ever thought of.
686 * The basic theory is that if we work hard enough here, the rest of the
687 * code can be a lot prettier. Well, so much for theory. Sorry, Henry...
688 */
ac58e20f 689
ee0007ab 690/* define this once if either system, instead of cluttering up the src */
7c458fae 691#if defined(MSDOS) || defined(WIN32) || defined(NETWARE)
ee0007ab
LW
692#define DOSISH 1
693#endif
694
3d97541c 695/* These exist only for back-compat with XS modules. */
8162b70e 696#ifndef PERL_CORE
516e10a9 697#define VOL volatile
3d97541c 698#define CAN_PROTOTYPE
ae75e3d0 699#define _(args) args
6c2ae642 700#define I_LIMITS
36a113ce 701#define I_STDARG
6c2ae642 702#define STANDARD_C
8162b70e 703#endif
663a0e37 704
284167a5
SM
705/* By compiling a perl with -DNO_TAINT_SUPPORT or -DSILENT_NO_TAINT_SUPPORT,
706 * you get a perl without taint support, but doubtlessly with a lesser
707 * degree of support. Do not do so unless you know exactly what it means
708 * technically, have a good reason to do so, and know exactly how the
709 * perl will be used. perls with -DSILENT_NO_TAINT_SUPPORT are considered
710 * a potential security risk due to flat out ignoring the security-relevant
711 * taint flags. This being said, a perl without taint support compiled in
712 * has marginal run-time performance benefits.
713 * SILENT_NO_TAINT_SUPPORT implies NO_TAINT_SUPPORT.
714 * SILENT_NO_TAINT_SUPPORT is the same as NO_TAINT_SUPPORT except it
715 * silently ignores -t/-T instead of throwing an exception.
053a3618
SM
716 *
717 * DANGER! Using NO_TAINT_SUPPORT or SILENT_NO_TAINT_SUPPORT
6ecb40c7 718 * voids your nonexistent warranty!
284167a5 719 */
dc6d7f5c 720#if defined(SILENT_NO_TAINT_SUPPORT) && !defined(NO_TAINT_SUPPORT)
284167a5
SM
721# define NO_TAINT_SUPPORT 1
722#endif
723
724/* NO_TAINT_SUPPORT can be set to transform virtually all taint-related
725 * operations into no-ops for a very modest speed-up. Enable only if you
726 * know what you're doing: tests and CPAN modules' tests are bound to fail.
727 */
dc6d7f5c 728#ifdef NO_TAINT_SUPPORT
284167a5
SM
729# define TAINT NOOP
730# define TAINT_NOT NOOP
731# define TAINT_IF(c) NOOP
732# define TAINT_ENV() NOOP
733# define TAINT_PROPER(s) NOOP
734# define TAINT_set(s) NOOP
735# define TAINT_get 0
736# define TAINTING_get 0
737# define TAINTING_set(s) NOOP
738# define TAINT_WARN_get 0
739# define TAINT_WARN_set(s) NOOP
740#else
bc2f1ca1 741 /* Set to tainted if we are running under tainting mode */
d48c660d 742# define TAINT (PL_tainted = PL_tainting)
bc2f1ca1
KW
743
744# define TAINT_NOT (PL_tainted = FALSE) /* Untaint */
745# define TAINT_IF(c) if (UNLIKELY(c)) { TAINT; } /* Conditionally taint */
2439e033 746# define TAINT_ENV() if (UNLIKELY(PL_tainting)) { taint_env(); }
bc2f1ca1
KW
747 /* croak or warn if tainting */
748# define TAINT_PROPER(s) if (UNLIKELY(PL_tainting)) { \
749 taint_proper(NULL, s); \
750 }
284167a5 751# define TAINT_set(s) (PL_tainted = (s))
ea42b70b
TC
752# define TAINT_get (cBOOL(UNLIKELY(PL_tainted))) /* Is something tainted? */
753# define TAINTING_get (cBOOL(UNLIKELY(PL_tainting))) /* Is taint checking enabled? */
284167a5 754# define TAINTING_set(s) (PL_tainting = (s))
bc2f1ca1
KW
755# define TAINT_WARN_get (PL_taint_warn) /* FALSE => tainting violations
756 are fatal
757 TRUE => they're just
758 warnings */
284167a5
SM
759# define TAINT_WARN_set(s) (PL_taint_warn = (s))
760#endif
a687059c 761
20be6587
DM
762/* flags used internally only within pp_subst and pp_substcont */
763#ifdef PERL_CORE
764# define SUBST_TAINT_STR 1 /* string tainted */
765# define SUBST_TAINT_PAT 2 /* pattern tainted */
766# define SUBST_TAINT_REPL 4 /* replacement tainted */
767# define SUBST_TAINT_RETAINT 8 /* use re'taint' in scope */
768# define SUBST_TAINT_BOOLRET 16 /* return is boolean (don't taint) */
769#endif
770
d460ef45 771/* XXX All process group stuff is handled in pp_sys.c. Should these
a6e633de
PP
772 defines move there? If so, I could simplify this a lot. --AD 9/96.
773*/
774/* Process group stuff changed from traditional BSD to POSIX.
775 perlfunc.pod documents the traditional BSD-style syntax, so we'll
776 try to preserve that, if possible.
777*/
778#ifdef HAS_SETPGID
779# define BSD_SETPGRP(pid, pgrp) setpgid((pid), (pgrp))
da5fdda8
AC
780#elif defined(HAS_SETPGRP) && defined(USE_BSD_SETPGRP)
781# define BSD_SETPGRP(pid, pgrp) setpgrp((pid), (pgrp))
782#elif defined(HAS_SETPGRP2)
783# define BSD_SETPGRP(pid, pgrp) setpgrp2((pid), (pgrp))
a6e633de
PP
784#endif
785#if defined(BSD_SETPGRP) && !defined(HAS_SETPGRP)
786# define HAS_SETPGRP /* Well, effectively it does . . . */
787#endif
788
789/* getpgid isn't POSIX, but at least Solaris and Linux have it, and it makes
790 our life easier :-) so we'll try it.
791*/
792#ifdef HAS_GETPGID
793# define BSD_GETPGRP(pid) getpgid((pid))
da5fdda8
AC
794#elif defined(HAS_GETPGRP) && defined(USE_BSD_GETPGRP)
795# define BSD_GETPGRP(pid) getpgrp((pid))
796#elif defined(HAS_GETPGRP2)
797# define BSD_GETPGRP(pid) getpgrp2((pid))
a6e633de
PP
798#endif
799#if defined(BSD_GETPGRP) && !defined(HAS_GETPGRP)
800# define HAS_GETPGRP /* Well, effectively it does . . . */
801#endif
802
d460ef45 803/* These are not exact synonyms, since setpgrp() and getpgrp() may
a6e633de
PP
804 have different behaviors, but perl.h used to define USE_BSDPGRP
805 (prior to 5.003_05) so some extension might depend on it.
806*/
807#if defined(USE_BSD_SETPGRP) || defined(USE_BSD_GETPGRP)
808# ifndef USE_BSDPGRP
809# define USE_BSDPGRP
810# endif
663a0e37
LW
811#endif
812
486ec47a 813/* HP-UX 10.X CMA (Common Multithreaded Architecture) insists that
8ac5a1fe
MH
814 pthread.h must be included before all other header files.
815*/
3db8f154 816#if defined(USE_ITHREADS) && defined(PTHREAD_H_FIRST) && defined(I_PTHREAD)
8ac5a1fe
MH
817# include <pthread.h>
818#endif
819
58ab9e8b 820#include <sys/types.h>
663a0e37 821
d2c9cb53
KW
822# ifdef I_WCHAR
823# include <wchar.h>
824# endif
825
9d82a2b7 826# include <stdarg.h>
760ac839 827
27db2737
JH
828#ifdef I_STDINT
829# include <stdint.h>
830#endif
831
fe14fcc3 832#include <ctype.h>
63b481b9
AC
833#include <float.h>
834#include <limits.h>
a0d0e21e
LW
835
836#ifdef METHOD /* Defined by OSF/1 v3.0 by ctype.h */
837#undef METHOD
a0d0e21e
LW
838#endif
839
12ae5dfc
JH
840#ifdef PERL_MICRO
841# define NO_LOCALE
842#endif
843
4633a7c4 844#ifdef I_LOCALE
36477c24 845# include <locale.h>
4633a7c4
LW
846#endif
847
6ebbc862
KW
848#ifdef I_XLOCALE
849# include <xlocale.h>
850#endif
851
aa8a2baa
KW
852/* If not forbidden, we enable locale handling if either 1) the POSIX 2008
853 * functions are available, or 2) just the setlocale() function. This logic is
854 * repeated in t/loc_tools.pl and makedef.pl; The three should be kept in
855 * sync. */
856#if ! defined(NO_LOCALE)
857
858# if ! defined(NO_POSIX_2008_LOCALE) \
859 && defined(HAS_NEWLOCALE) \
860 && defined(HAS_USELOCALE) \
861 && defined(HAS_DUPLOCALE) \
862 && defined(HAS_FREELOCALE) \
863 && defined(LC_ALL_MASK)
864
865 /* For simplicity, the code is written to assume that any platform advanced
866 * enough to have the Posix 2008 locale functions has LC_ALL. The final
867 * test above makes sure that assumption is valid */
868
869# define HAS_POSIX_2008_LOCALE
870# define USE_LOCALE
871# elif defined(HAS_SETLOCALE)
872# define USE_LOCALE
873# endif
874#endif
875
876#ifdef USE_LOCALE
ccd65d51 877# define HAS_SKIP_LOCALE_INIT /* Solely for XS code to test for this
af573503 878 #define */
36477c24
PP
879# if !defined(NO_LOCALE_COLLATE) && defined(LC_COLLATE) \
880 && defined(HAS_STRXFRM)
881# define USE_LOCALE_COLLATE
882# endif
883# if !defined(NO_LOCALE_CTYPE) && defined(LC_CTYPE)
884# define USE_LOCALE_CTYPE
885# endif
886# if !defined(NO_LOCALE_NUMERIC) && defined(LC_NUMERIC)
887# define USE_LOCALE_NUMERIC
888# endif
fa9b773e
KW
889# if !defined(NO_LOCALE_MESSAGES) && defined(LC_MESSAGES)
890# define USE_LOCALE_MESSAGES
891# endif
892# if !defined(NO_LOCALE_MONETARY) && defined(LC_MONETARY)
893# define USE_LOCALE_MONETARY
894# endif
56e45410
KW
895# if !defined(NO_LOCALE_TIME) && defined(LC_TIME)
896# define USE_LOCALE_TIME
897# endif
9821811f
KW
898# if !defined(NO_LOCALE_ADDRESS) && defined(LC_ADDRESS)
899# define USE_LOCALE_ADDRESS
900# endif
901# if !defined(NO_LOCALE_IDENTIFICATION) && defined(LC_IDENTIFICATION)
902# define USE_LOCALE_IDENTIFICATION
903# endif
904# if !defined(NO_LOCALE_MEASUREMENT) && defined(LC_MEASUREMENT)
905# define USE_LOCALE_MEASUREMENT
906# endif
907# if !defined(NO_LOCALE_PAPER) && defined(LC_PAPER)
908# define USE_LOCALE_PAPER
909# endif
910# if !defined(NO_LOCALE_TELEPHONE) && defined(LC_TELEPHONE)
911# define USE_LOCALE_TELEPHONE
912# endif
36dbc955
KW
913# if !defined(NO_LOCALE_SYNTAX) && defined(LC_SYNTAX)
914# define USE_LOCALE_SYNTAX
915# endif
916# if !defined(NO_LOCALE_TOD) && defined(LC_TOD)
917# define USE_LOCALE_TOD
918# endif
a0d0e21e 919
5a53bf38
KW
920/* XXX The next few defines are unfortunately duplicated in makedef.pl, and
921 * changes here MUST also be made there */
922
aa8a2baa
KW
923# if ! defined(HAS_SETLOCALE) && defined(HAS_POSIX_2008_LOCALE)
924# define USE_POSIX_2008_LOCALE
925# ifndef USE_THREAD_SAFE_LOCALE
926# define USE_THREAD_SAFE_LOCALE
927# endif
e1895adc
KW
928 /* If compiled with
929 * -DUSE_THREAD_SAFE_LOCALE, will do so even
930 * on unthreaded builds */
aa8a2baa
KW
931# elif (defined(USE_ITHREADS) || defined(USE_THREAD_SAFE_LOCALE)) \
932 && ( defined(HAS_POSIX_2008_LOCALE) \
933 || (defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400)) \
934 && ! defined(NO_THREAD_SAFE_LOCALE)
e1895adc
KW
935# ifndef USE_THREAD_SAFE_LOCALE
936# define USE_THREAD_SAFE_LOCALE
937# endif
e9bc6d6b
KW
938# ifdef HAS_POSIX_2008_LOCALE
939# define USE_POSIX_2008_LOCALE
940# endif
941# endif
7f9e9632
KW
942#endif
943
69c5e0db
KW
944/* Microsoft documentation reads in the change log for VS 2015:
945 * "The localeconv function declared in locale.h now works correctly when
946 * per-thread locale is enabled. In previous versions of the library, this
947 * function would return the lconv data for the global locale, not the
948 * thread's locale."
949 */
950#if defined(WIN32) && defined(USE_THREAD_SAFE_LOCALE) && _MSC_VER < 1900
951# define TS_W32_BROKEN_LOCALECONV
952#endif
953
fe14fcc3 954#include <setjmp.h>
79072805 955
a0d0e21e 956#ifdef I_SYS_PARAM
79072805
LW
957# ifdef PARAM_NEEDS_TYPES
958# include <sys/types.h>
959# endif
960# include <sys/param.h>
352d5a3a 961#endif
79072805 962
ce3470dc
AD
963/* On BSD-derived systems, <sys/param.h> defines BSD to a year-month
964 value something like 199306. This may be useful if no more-specific
965 feature test is available.
966*/
967#if defined(BSD)
968# ifndef BSDish
969# define BSDish
970# endif
971#endif
972
dd512de3
AC
973/* Use all the "standard" definitions */
974#include <stdlib.h>
03a14243 975
3f270f98
JH
976/* If this causes problems, set i_unistd=undef in the hint file. */
977#ifdef I_UNISTD
763ee752
AB
978# if defined(__amigaos4__)
979# ifdef I_NETINET_IN
980# include <netinet/in.h>
981# endif
982# endif
3f270f98 983# include <unistd.h>
6e3136a6
AB
984# if defined(__amigaos4__)
985/* Under AmigaOS 4 newlib.library provides an environ. However using
986 * it doesn't give us enough control over inheritance of variables by
987 * subshells etc. so replace with custom version based on abc-shell
988 * code. */
989extern char **myenviron;
990# undef environ
991# define environ myenviron
992# endif
3f270f98
JH
993#endif
994
de8ca8af
NT
995/* for WCOREDUMP */
996#ifdef I_SYS_WAIT
997# include <sys/wait.h>
998#endif
999
21e89b5f 1000#if defined(HAS_SYSCALL) && !defined(HAS_SYSCALL_PROTO)
c45598c5 1001EXTERN_C int syscall(int, ...);
2ef53570
JH
1002#endif
1003
21e89b5f 1004#if defined(HAS_USLEEP) && !defined(HAS_USLEEP_PROTO)
c45598c5 1005EXTERN_C int usleep(unsigned int);
2ef53570
JH
1006#endif
1007
f2f9e01d
KW
1008/* macros for correct constant construction. These are in C99 <stdint.h>
1009 * (so they will not be available in strict C89 mode), but they are nice, so
1010 * let's define them if necessary. */
1011#ifndef UINT16_C
1012# if INTSIZE >= 2
1013# define UINT16_C(x) ((U16_TYPE)x##U)
1014# else
1015# define UINT16_C(x) ((U16_TYPE)x##UL)
1016# endif
1017#endif
1109a392 1018
f2f9e01d
KW
1019#ifndef UINT32_C
1020# if INTSIZE >= 4
1021# define UINT32_C(x) ((U32_TYPE)x##U)
1022# else
1023# define UINT32_C(x) ((U32_TYPE)x##UL)
1024# endif
1025#endif
1109a392 1026
f2f9e01d
KW
1027#ifdef I_STDINT
1028 typedef intmax_t PERL_INTMAX_T;
1029 typedef uintmax_t PERL_UINTMAX_T;
1030#endif
1031
1032/* N.B. We use QUADKIND here instead of HAS_QUAD here, because that doesn't
1033 * actually mean what it has always been documented to mean (see RT #119753)
1034 * and is explicitly turned off outside of core with dire warnings about
1035 * removing the undef. */
1036
1037#if defined(QUADKIND)
1038# undef PeRl_INT64_C
1039# undef PeRl_UINT64_C
1040/* Prefer the native integer types (int and long) over long long
1041 * (which is not C89) and Win32-specific __int64. */
1042# if QUADKIND == QUAD_IS_INT && INTSIZE == 8
1043# define PeRl_INT64_C(c) (c)
1044# define PeRl_UINT64_C(c) CAT2(c,U)
1045# endif
1046# if QUADKIND == QUAD_IS_LONG && LONGSIZE == 8
1047# define PeRl_INT64_C(c) CAT2(c,L)
1048# define PeRl_UINT64_C(c) CAT2(c,UL)
1049# endif
1050# if QUADKIND == QUAD_IS_LONG_LONG && defined(HAS_LONG_LONG)
1051# define PeRl_INT64_C(c) CAT2(c,LL)
1052# define PeRl_UINT64_C(c) CAT2(c,ULL)
1053# endif
1054# if QUADKIND == QUAD_IS___INT64
1055# define PeRl_INT64_C(c) CAT2(c,I64)
1056# define PeRl_UINT64_C(c) CAT2(c,UI64)
1057# endif
1058# ifndef PeRl_INT64_C
1059# define PeRl_INT64_C(c) ((I64)(c)) /* last resort */
1060# define PeRl_UINT64_C(c) ((U64TYPE)(c))
1061# endif
1062/* In OS X the INT64_C/UINT64_C are defined with LL/ULL, which will
1063 * not fly with C89-pedantic gcc, so let's undefine them first so that
1064 * we can redefine them with our native integer preferring versions. */
1065# if defined(PERL_DARWIN) && defined(PERL_GCC_PEDANTIC)
1066# undef INT64_C
1067# undef UINT64_C
1068# endif
1069# ifndef INT64_C
1070# define INT64_C(c) PeRl_INT64_C(c)
1071# endif
1072# ifndef UINT64_C
1073# define UINT64_C(c) PeRl_UINT64_C(c)
1074# endif
1109a392 1075
ebaa1d42 1076/*
51b56f5c 1077=for apidoc_section Integer configuration values
ebaa1d42
KW
1078=for apidoc Am||INTMAX_C|number
1079Returns a token the C compiler recognizes for the constant C<number> of the
1080widest integer type on the machine. For example, if the machine has C<long
1081long>s, C<INTMAX_C(-1)> would yield
1082
1083 -1LL
1084
1085=for apidoc Am||UINTMAX_C|number
1086Returns a token the C compiler recognizes for the constant C<number> of the
1087widest unsigned integer type on the machine. For example, if the machine has
1088C<long>s, C<UINTMAX_C(1)> would yield
1089
1090 1UL
1091
1092=cut
1093*/
1094
f2f9e01d
KW
1095# ifndef I_STDINT
1096 typedef I64TYPE PERL_INTMAX_T;
1097 typedef U64TYPE PERL_UINTMAX_T;
1109a392 1098# endif
f2f9e01d
KW
1099# ifndef INTMAX_C
1100# define INTMAX_C(c) INT64_C(c)
1101# endif
1102# ifndef UINTMAX_C
1103# define UINTMAX_C(c) UINT64_C(c)
1104# endif
1105
1106#else /* below QUADKIND is undefined */
1107
1108/* Perl doesn't work on 16 bit systems, so must be 32 bit */
1109# ifndef I_STDINT
1110 typedef I32TYPE PERL_INTMAX_T;
1111 typedef U32TYPE PERL_UINTMAX_T;
1112# endif
1113# ifndef INTMAX_C
1114# define INTMAX_C(c) INT32_C(c)
1115# endif
1116# ifndef UINTMAX_C
1117# define UINTMAX_C(c) UINT32_C(c)
1118# endif
1119
1120#endif /* no QUADKIND */
1121
1122#ifdef PERL_CORE
1109a392
MHM
1123
1124/* byte-swapping functions for big-/little-endian conversion */
1125# define _swab_16_(x) ((U16)( \
f2f9e01d
KW
1126 (((U16)(x) & UINT16_C(0x00ff)) << 8) | \
1127 (((U16)(x) & UINT16_C(0xff00)) >> 8) ))
1109a392
MHM
1128
1129# define _swab_32_(x) ((U32)( \
f2f9e01d
KW
1130 (((U32)(x) & UINT32_C(0x000000ff)) << 24) | \
1131 (((U32)(x) & UINT32_C(0x0000ff00)) << 8) | \
1132 (((U32)(x) & UINT32_C(0x00ff0000)) >> 8) | \
1133 (((U32)(x) & UINT32_C(0xff000000)) >> 24) ))
1109a392
MHM
1134
1135# ifdef HAS_QUAD
1136# define _swab_64_(x) ((U64)( \
f2f9e01d
KW
1137 (((U64)(x) & UINT64_C(0x00000000000000ff)) << 56) | \
1138 (((U64)(x) & UINT64_C(0x000000000000ff00)) << 40) | \
1139 (((U64)(x) & UINT64_C(0x0000000000ff0000)) << 24) | \
1140 (((U64)(x) & UINT64_C(0x00000000ff000000)) << 8) | \
1141 (((U64)(x) & UINT64_C(0x000000ff00000000)) >> 8) | \
1142 (((U64)(x) & UINT64_C(0x0000ff0000000000)) >> 24) | \
1143 (((U64)(x) & UINT64_C(0x00ff000000000000)) >> 40) | \
1144 (((U64)(x) & UINT64_C(0xff00000000000000)) >> 56) ))
1109a392
MHM
1145# endif
1146
9c17f24a
NC
1147/* The old value was hard coded at 1008. (4096-16) seems to be a bit faster,
1148 at least on FreeBSD. YMMV, so experiment. */
1149#ifndef PERL_ARENA_SIZE
1150#define PERL_ARENA_SIZE 4080
1151#endif
1152
ccb2c8b8 1153/* Maximum level of recursion */
2b9dff67
RGS
1154#ifndef PERL_SUB_DEPTH_WARN
1155#define PERL_SUB_DEPTH_WARN 100
ccb2c8b8
RGS
1156#endif
1157
1109a392
MHM
1158#endif /* PERL_CORE */
1159
e839e6ed
DM
1160/* Maximum number of args that may be passed to an OP_MULTICONCAT op.
1161 * It determines the size of local arrays in S_maybe_multiconcat() and
1162 * pp_multiconcat().
1163 */
1164#define PERL_MULTICONCAT_MAXARG 64
1165
1166/* The indexes of fields of a multiconcat aux struct.
1167 * The fixed fields are followed by nargs+1 const segment lengths,
1168 * and if utf8 and non-utf8 differ, a second nargs+1 set for utf8.
1169 */
1170
1171#define PERL_MULTICONCAT_IX_NARGS 0 /* number of arguments */
1172#define PERL_MULTICONCAT_IX_PLAIN_PV 1 /* non-utf8 constant string */
1173#define PERL_MULTICONCAT_IX_PLAIN_LEN 2 /* non-utf8 constant string length */
1174#define PERL_MULTICONCAT_IX_UTF8_PV 3 /* utf8 constant string */
1175#define PERL_MULTICONCAT_IX_UTF8_LEN 4 /* utf8 constant string length */
1176#define PERL_MULTICONCAT_IX_LENGTHS 5 /* first of nargs+1 const segment lens */
1177#define PERL_MULTICONCAT_HEADER_SIZE 5 /* The number of fields of a
1178 multiconcat header */
1179
bdf3085f
NC
1180/* We no longer default to creating a new SV for GvSV.
1181 Do this before embed. */
1182#ifndef PERL_CREATE_GVSV
7459f06b
NC
1183# ifndef PERL_DONT_CREATE_GVSV
1184# define PERL_DONT_CREATE_GVSV
1185# endif
bdf3085f
NC
1186#endif
1187
ca0c25f6
NC
1188#if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME)
1189#define PERL_USES_PL_PIDSTATUS
1190#endif
1191
822c8b4d 1192#if !defined(OS2) && !defined(WIN32) && !defined(DJGPP)
a62746fa
RGS
1193#define PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION
1194#endif
1195
c31fac66
GS
1196#define MEM_SIZE Size_t
1197
1936d2a7
NC
1198/* Round all values passed to malloc up, by default to a multiple of
1199 sizeof(size_t)
1200*/
1201#ifndef PERL_STRLEN_ROUNDUP_QUANTUM
1202#define PERL_STRLEN_ROUNDUP_QUANTUM Size_t_size
1203#endif
1204
f1200559
WH
1205/* sv_grow() will expand strings by at least a certain percentage of
1206 the previously *used* length to avoid excessive calls to realloc().
1207 The default is 25% of the current length.
1208*/
1209#ifndef PERL_STRLEN_EXPAND_SHIFT
1210# define PERL_STRLEN_EXPAND_SHIFT 2
1211#endif
1212
4bd4e933
SH
1213/* This use of offsetof() requires /Zc:offsetof- for VS2017 (and presumably
1214 * onwards) when building Socket.xs, but we can just use a different definition
1215 * for STRUCT_OFFSET instead. */
1216#if defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1910
1217# define STRUCT_OFFSET(s,m) (Size_t)(&(((s *)0)->m))
1218#else
1219# include <stddef.h>
1220# define STRUCT_OFFSET(s,m) offsetof(s,m)
1221#endif
d0b86e2f 1222
86477e89
KW
1223/* ptrdiff_t is C11, so undef it under pedantic builds. (Actually it is
1224 * in C89, but apparently there are platforms where it doesn't exist. See
1225 * thread beginning at http://nntp.perl.org/group/perl.perl5.porters/251541.)
1226 * */
d0b86e2f
BF
1227#ifdef PERL_GCC_PEDANTIC
1228# undef HAS_PTRDIFF_T
51371543
GS
1229#endif
1230
86477e89
KW
1231#ifdef HAS_PTRDIFF_T
1232# define Ptrdiff_t ptrdiff_t
1233#else
1234# define Ptrdiff_t SSize_t
1235#endif
1236
d54fbe84 1237# include <string.h>
51371543 1238
55497cff
PP
1239/* This comes after <stdlib.h> so we don't try to change the standard
1240 * library prototypes; we'll use our own in proto.h instead. */
03a14243 1241
4633a7c4 1242#ifdef MYMALLOC
86058a2d 1243# ifdef PERL_POLLUTE_MALLOC
ee13e175 1244# ifndef PERL_EXTMALLOC_DEF
86058a2d
GS
1245# define Perl_malloc malloc
1246# define Perl_calloc calloc
1247# define Perl_realloc realloc
1248# define Perl_mfree free
ee13e175 1249# endif
86058a2d
GS
1250# else
1251# define EMBEDMYMALLOC /* for compatibility */
1252# endif
827e134a 1253
651b9576
GS
1254# define safemalloc Perl_malloc
1255# define safecalloc Perl_calloc
1256# define saferealloc Perl_realloc
1257# define safefree Perl_mfree
22f7c9c9 1258# define CHECK_MALLOC_TOO_LATE_FOR_(code) STMT_START { \
54725a52 1259 if (!TAINTING_get && MallocCfg_ptr[MallocCfg_cfg_env_read]) \
22f7c9c9
JH
1260 code; \
1261 } STMT_END
1262# define CHECK_MALLOC_TOO_LATE_FOR(ch) \
1263 CHECK_MALLOC_TOO_LATE_FOR_(MALLOC_TOO_LATE_FOR(ch))
1264# define panic_write2(s) write(2, s, strlen(s))
1265# define CHECK_MALLOC_TAINT(newval) \
1266 CHECK_MALLOC_TOO_LATE_FOR_( \
1267 if (newval) { \
acfd4d8e 1268 PERL_UNUSED_RESULT(panic_write2("panic: tainting with $ENV{PERL_MALLOC_OPT}\n"));\
22f7c9c9 1269 exit(1); })
22f7c9c9 1270# define MALLOC_CHECK_TAINT(argc,argv,env) STMT_START { \
b0891165 1271 if (doing_taint(argc,argv,env)) { \
22f7c9c9
JH
1272 MallocCfg_ptr[MallocCfg_skip_cfg_env] = 1; \
1273 }} STMT_END;
f2517201
GS
1274#else /* MYMALLOC */
1275# define safemalloc safesysmalloc
1276# define safecalloc safesyscalloc
1277# define saferealloc safesysrealloc
1278# define safefree safesysfree
22f7c9c9
JH
1279# define CHECK_MALLOC_TOO_LATE_FOR(ch) ((void)0)
1280# define CHECK_MALLOC_TAINT(newval) ((void)0)
1281# define MALLOC_CHECK_TAINT(argc,argv,env)
55497cff 1282#endif /* MYMALLOC */
4633a7c4 1283
fe13d51d 1284/* diag_listed_as: "-T" is on the #! line, it must also be used on the command line */
27da23d5 1285#define TOO_LATE_FOR_(ch,what) Perl_croak(aTHX_ "\"-%c\" is on the #! line, it must also be used on the command line%s", (char)(ch), what)
22f7c9c9
JH
1286#define TOO_LATE_FOR(ch) TOO_LATE_FOR_(ch, "")
1287#define MALLOC_TOO_LATE_FOR(ch) TOO_LATE_FOR_(ch, " with $ENV{PERL_MALLOC_OPT}")
1288#define MALLOC_CHECK_TAINT2(argc,argv) MALLOC_CHECK_TAINT(argc,argv,NULL)
1289
fc36a67e 1290#ifndef memzero
04322328 1291# define memzero(d,l) memset(d,0,l)
d9d8d8de 1292#endif
378cc40b 1293
ae986130 1294#ifdef I_NETINET_IN
79072805 1295# include <netinet/in.h>
ae986130
LW
1296#endif
1297
28e8609d
JH
1298#ifdef I_ARPA_INET
1299# include <arpa/inet.h>
1300#endif
1301
1aef975c 1302#ifdef I_SYS_STAT
84902520 1303# include <sys/stat.h>
1aef975c 1304#endif
79072805 1305
287a962e
JD
1306/* Microsoft VC's sys/stat.h defines all S_Ixxx macros except S_IFIFO.
1307 This definition should ideally go into win32/win32.h, but S_IFIFO is
1308 used later here in perl.h before win32/win32.h is being included. */
1309#if !defined(S_IFIFO) && defined(_S_IFIFO)
1310# define S_IFIFO _S_IFIFO
1311#endif
1312
cc3315ba 1313/* The stat macros for Unisoft System V/88 (and derivatives
a0d0e21e
LW
1314 like UTekV) are broken, sometimes giving false positives. Undefine
1315 them here and let the code below set them to proper values.
1316
1317 The ghs macro stands for GreenHills Software C-1.8.5 which
1318 is the C compiler for sysV88 and the various derivatives.
1319 This header file bug is corrected in gcc-2.5.8 and later versions.
1320 --Kaveh Ghazi (ghazi@noc.rutgers.edu) 10/3/94. */
1321
cc3315ba 1322#if defined(m88k) && defined(ghs)
79072805
LW
1323# undef S_ISDIR
1324# undef S_ISCHR
1325# undef S_ISBLK
1326# undef S_ISREG
1327# undef S_ISFIFO
1328# undef S_ISLNK
ee0007ab 1329#endif
135863df 1330
9245da2a 1331#include <time.h>
663a0e37 1332
fe14fcc3 1333#ifdef I_SYS_TIME
85e6fe83 1334# ifdef I_SYS_TIME_KERNEL
663a0e37
LW
1335# define KERNEL
1336# endif
1337# include <sys/time.h>
85e6fe83 1338# ifdef I_SYS_TIME_KERNEL
663a0e37
LW
1339# undef KERNEL
1340# endif
a687059c 1341#endif
135863df 1342
55497cff 1343#if defined(HAS_TIMES) && defined(I_SYS_TIMES)
85e6fe83 1344# include <sys/times.h>
d9d8d8de 1345#endif
8d063cd8 1346
663a0e37 1347#include <errno.h>
1e743fda 1348
acfe0abc 1349#if defined(WIN32) && defined(PERL_IMPLICIT_SYS)
b4748376
NIS
1350# define WIN32SCK_IS_STDSCK /* don't pull in custom wsock layer */
1351#endif
1352
da70cfc6 1353#if defined(HAS_SOCKET) && !defined(WIN32) /* WIN32 handles sockets via win32.h */
1e743fda
JH
1354# include <sys/socket.h>
1355# if defined(USE_SOCKS) && defined(I_SOCKS)
1356# if !defined(INCLUDE_PROTOTYPES)
1357# define INCLUDE_PROTOTYPES /* for <socks.h> */
1358# define PERL_SOCKS_NEED_PROTOTYPES
1359# endif
1360# include <socks.h>
1361# ifdef PERL_SOCKS_NEED_PROTOTYPES /* keep cpp space clean */
1362# undef INCLUDE_PROTOTYPES
1363# undef PERL_SOCKS_NEED_PROTOTYPES
ed6116ce 1364# endif
d460ef45 1365# endif
1e743fda 1366# ifdef I_NETDB
2986a63f
JH
1367# ifdef NETWARE
1368# include<stdio.h>
1369# endif
1e743fda
JH
1370# include <netdb.h>
1371# endif
1372# ifndef ENOTSOCK
1373# ifdef I_NET_ERRNO
1374# include <net/errno.h>
1375# endif
1376# endif
1377#endif
1378
fa0a29af 1379/* sockatmark() is so new (2001) that many places might have it hidden
29820b6d
MHM
1380 * behind some -D_BLAH_BLAH_SOURCE guard. The __THROW magic is required
1381 * e.g. in Gentoo, see http://bugs.gentoo.org/show_bug.cgi?id=12605 */
fa0a29af 1382#if defined(HAS_SOCKATMARK) && !defined(HAS_SOCKATMARK_PROTO)
29820b6d
MHM
1383# if defined(__THROW) && defined(__GLIBC__)
1384int sockatmark(int) __THROW;
1385# else
2ef53570 1386int sockatmark(int);
29820b6d 1387# endif
2ef53570
JH
1388#endif
1389
7e827271 1390#if defined(__osf__) && defined(__cplusplus) && !defined(_XOPEN_SOURCE_EXTENDED) /* Tru64 "cxx" (C++), see hints/dec_osf.sh for why the _XOPEN_SOURCE_EXTENDED cannot be defined. */
45d3b546
JH
1391EXTERN_C int fchdir(int);
1392EXTERN_C int flock(int, int);
1393EXTERN_C int fseeko(FILE *, off_t, int);
1394EXTERN_C off_t ftello(FILE *);
1395#endif
1396
7e827271 1397#if defined(__SUNPRO_CC) /* SUNWspro CC (C++) */
1ccb7c8d
JH
1398EXTERN_C char *crypt(const char *, const char *);
1399#endif
1400
a54aca4b 1401#if defined(__cplusplus) && defined(__CYGWIN__)
667e2948
SP
1402EXTERN_C char *crypt(const char *, const char *);
1403#endif
1404
131e4949 1405/*
70b05c7c 1406=for apidoc_section Errno
131e4949
TC
1407
1408=for apidoc m|void|SETERRNO|int errcode|int vmserrcode
1409
1410Set C<errno>, and on VMS set C<vaxc$errno>.
1411
1412=for apidoc mn|void|dSAVEDERRNO
1413
1414Declare variables needed to save C<errno> and any operating system
1415specific error number.
1416
1417=for apidoc mn|void|dSAVE_ERRNO
1418
1419Declare variables needed to save C<errno> and any operating system
1420specific error number, and save them for optional later restoration
1421by C<RESTORE_ERRNO>.
1422
1423=for apidoc mn|void|SAVE_ERRNO
1424
1425Save C<errno> and any operating system specific error number for
1426optional later restoration by C<RESTORE_ERRNO>. Requires
1427C<dSAVEDERRNO> or C<dSAVE_ERRNO> in scope.
1428
1429=for apidoc mn|void|RESTORE_ERRNO
1430
1431Restore C<errno> and any operating system specific error number that
1432was saved by C<dSAVE_ERRNO> or C<RESTORE_ERRNO>.
1433
1434=cut
1435*/
1436
1e743fda
JH
1437#ifdef SETERRNO
1438# undef SETERRNO /* SOCKS might have defined this */
ed6116ce 1439#endif
f86702cc
PP
1440
1441#ifdef VMS
1442# define SETERRNO(errcode,vmserrcode) \
1443 STMT_START { \
1444 set_errno(errcode); \
1445 set_vaxc_errno(vmserrcode); \
1446 } STMT_END
4ee39169
CS
1447# define dSAVEDERRNO int saved_errno; unsigned saved_vms_errno
1448# define dSAVE_ERRNO int saved_errno = errno; unsigned saved_vms_errno = vaxc$errno
1449# define SAVE_ERRNO ( saved_errno = errno, saved_vms_errno = vaxc$errno )
1450# define RESTORE_ERRNO SETERRNO(saved_errno, saved_vms_errno)
1451
93189314
JH
1452# define LIB_INVARG LIB$_INVARG
1453# define RMS_DIR RMS$_DIR
1454# define RMS_FAC RMS$_FAC
1455# define RMS_FEX RMS$_FEX
1456# define RMS_FNF RMS$_FNF
1457# define RMS_IFI RMS$_IFI
1458# define RMS_ISI RMS$_ISI
1459# define RMS_PRV RMS$_PRV
1460# define SS_ACCVIO SS$_ACCVIO
1461# define SS_DEVOFFLINE SS$_DEVOFFLINE
1462# define SS_IVCHAN SS$_IVCHAN
1463# define SS_NORMAL SS$_NORMAL
8a9f18be 1464# define SS_NOPRIV SS$_NOPRIV
4388f261 1465# define SS_BUFFEROVF SS$_BUFFEROVF
748a9306 1466#else
93189314
JH
1467# define LIB_INVARG 0
1468# define RMS_DIR 0
1469# define RMS_FAC 0
1470# define RMS_FEX 0
1471# define RMS_FNF 0
1472# define RMS_IFI 0
1473# define RMS_ISI 0
1474# define RMS_PRV 0
1475# define SS_ACCVIO 0
1476# define SS_DEVOFFLINE 0
1477# define SS_IVCHAN 0
1478# define SS_NORMAL 0
8a9f18be 1479# define SS_NOPRIV 0
4388f261 1480# define SS_BUFFEROVF 0
748a9306 1481#endif
ed6116ce 1482
6ca940a9
TC
1483#ifdef WIN32
1484# define dSAVEDERRNO int saved_errno; DWORD saved_win32_errno
1485# define dSAVE_ERRNO int saved_errno = errno; DWORD saved_win32_errno = GetLastError()
1486# define SAVE_ERRNO ( saved_errno = errno, saved_win32_errno = GetLastError() )
1487# define RESTORE_ERRNO ( errno = saved_errno, SetLastError(saved_win32_errno) )
1488#endif
1489
1490#ifdef OS2
1491# define dSAVEDERRNO int saved_errno; unsigned long saved_os2_errno
1492# define dSAVE_ERRNO int saved_errno = errno; unsigned long saved_os2_errno = Perl_rc
1493# define SAVE_ERRNO ( saved_errno = errno, saved_os2_errno = Perl_rc )
1494# define RESTORE_ERRNO ( errno = saved_errno, Perl_rc = saved_os2_errno )
1495#endif
1496
1497#ifndef SETERRNO
1498# define SETERRNO(errcode,vmserrcode) (errno = (errcode))
1499#endif
1500
1501#ifndef dSAVEDERRNO
1502# define dSAVEDERRNO int saved_errno
1503# define dSAVE_ERRNO int saved_errno = errno
1504# define SAVE_ERRNO (saved_errno = errno)
1505# define RESTORE_ERRNO (errno = saved_errno)
1506#endif
1507
40bec302 1508/*
70b05c7c 1509=for apidoc_section Warning and Dieing
40bec302
TC
1510
1511=for apidoc Amn|SV *|ERRSV
1512
1513Returns the SV for C<$@>, creating it if needed.
1514
1515=for apidoc Am|void|CLEAR_ERRSV
1516
1517Clear the contents of C<$@>, setting it to the empty string.
1518
1519This replaces any read-only SV with a fresh SV and removes any magic.
1520
933e3e63
TC
1521=for apidoc Am|void|SANE_ERRSV
1522
1523Clean up ERRSV so we can safely set it.
1524
1525This replaces any read-only SV with a fresh writable copy and removes
1526any magic.
1527
40bec302
TC
1528=cut
1529*/
1530
f5fa9033 1531#define ERRSV GvSVn(PL_errgv)
dfd167e9 1532
b4f8d149 1533/* contains inlined gv_add_by_type */
dfd167e9 1534#define CLEAR_ERRSV() STMT_START { \
b4f8d149
DD
1535 SV ** const svp = &GvSV(PL_errgv); \
1536 if (!*svp) { \
a1b60c8d 1537 *svp = newSVpvs(""); \
b4f8d149
DD
1538 } else if (SvREADONLY(*svp)) { \
1539 SvREFCNT_dec_NN(*svp); \
b4f8d149 1540 *svp = newSVpvs(""); \
dfd167e9 1541 } else { \
b4f8d149 1542 SV *const errsv = *svp; \
a1b60c8d 1543 SvPVCLEAR(errsv); \
b4f8d149 1544 SvPOK_only(errsv); \
dfd167e9
NC
1545 if (SvMAGICAL(errsv)) { \
1546 mg_free(errsv); \
1547 } \
dfd167e9
NC
1548 } \
1549 } STMT_END
1550
933e3e63
TC
1551/* contains inlined gv_add_by_type */
1552#define SANE_ERRSV() STMT_START { \
1553 SV ** const svp = &GvSV(PL_errgv); \
1554 if (!*svp) { \
1555 *svp = newSVpvs(""); \
1556 } else if (SvREADONLY(*svp)) { \
1557 SV *dupsv = newSVsv(*svp); \
1558 SvREFCNT_dec_NN(*svp); \
1559 *svp = dupsv; \
1560 } else { \
1561 SV *const errsv = *svp; \
1562 if (SvMAGICAL(errsv)) { \
1563 mg_free(errsv); \
1564 } \
1565 } \
1566 } STMT_END
1567
dfd167e9 1568
414bf5ae
MHM
1569#ifdef PERL_CORE
1570# define DEFSV (0 + GvSVn(PL_defgv))
55b5114f
FC
1571# define DEFSV_set(sv) \
1572 (SvREFCNT_dec(GvSV(PL_defgv)), GvSV(PL_defgv) = SvREFCNT_inc(sv))
1573# define SAVE_DEFSV \
1574 ( \
1575 save_gp(PL_defgv, 0), \
1576 GvINTRO_off(PL_defgv), \
1577 SAVEGENERICSV(GvSV(PL_defgv)), \
1578 GvSV(PL_defgv) = NULL \
1579 )
414bf5ae
MHM
1580#else
1581# define DEFSV GvSVn(PL_defgv)
55b5114f
FC
1582# define DEFSV_set(sv) (GvSV(PL_defgv) = (sv))
1583# define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv))
414bf5ae 1584#endif
ed07b037
KW
1585
1586/*
51b56f5c 1587=for apidoc_section SV Handling
ed07b037
KW
1588=for apidoc Amn|SV *|DEFSV
1589Returns the SV associated with C<$_>
1590
1591=for apidoc Am|void|DEFSV_set|SV * sv
1592Associate C<sv> with C<$_>
1593
1594=for apidoc Amn|void|SAVE_DEFSV
1595Localize C<$_>. See L<perlguts/Localizing changes>.
1596
1597=cut
1598*/
38a03e6e 1599
55497cff 1600#ifndef errno
5ff3f7a4
GS
1601 extern int errno; /* ANSI allows errno to be an lvalue expr.
1602 * For example in multithreaded environments
1603 * something like this might happen:
1604 * extern int *_errno(void);
1605 * #define errno (*_errno()) */
d9d8d8de 1606#endif
663a0e37 1607
7e996671
KW
1608#define UNKNOWN_ERRNO_MSG "(unknown)"
1609
d1747a5a 1610#ifdef VMS
b21d8587
AC
1611#define Strerror(e) strerror((e), vaxc$errno)
1612#else
1613#define Strerror(e) strerror(e)
35c8bce7 1614#endif
663a0e37 1615
2304df62 1616#ifdef I_SYS_IOCTL
79072805
LW
1617# ifndef _IOCTL_
1618# include <sys/ioctl.h>
1619# endif
a687059c
LW
1620#endif
1621
ee0007ab 1622#if defined(mc300) || defined(mc500) || defined(mc700) || defined(mc6000)
79072805
LW
1623# ifdef HAS_SOCKETPAIR
1624# undef HAS_SOCKETPAIR
1625# endif
2304df62
AD
1626# ifdef I_NDBM
1627# undef I_NDBM
79072805 1628# endif
a687059c
LW
1629#endif
1630
02fc2eee
NC
1631#ifndef HAS_SOCKETPAIR
1632# ifdef HAS_SOCKET
1633# define socketpair Perl_my_socketpair
1634# endif
1635#endif
1636
a687059c 1637#if INTSIZE == 2
79072805
LW
1638# define htoni htons
1639# define ntohi ntohs
a687059c 1640#else
79072805
LW
1641# define htoni htonl
1642# define ntohi ntohl
a687059c
LW
1643#endif
1644
a0d0e21e 1645/* Configure already sets Direntry_t */
35c8bce7 1646#if defined(I_DIRENT)
da5fdda8
AC
1647# include <dirent.h>
1648#elif defined(I_SYS_NDIR)
1649# include <sys/ndir.h>
1650#elif defined(I_SYS_DIR)
1651# include <sys/dir.h>
4633a7c4 1652#endif
a687059c 1653
c623bd54
LW
1654/*
1655 * The following gobbledygook brought to you on behalf of __STDC__.
1656 * (I could just use #ifndef __STDC__, but this is more bulletproof
1657 * in the face of half-implementations.)
1658 */
1659
21e89b5f 1660#if defined(I_SYSMODE)
ca6e1c26
JH
1661#include <sys/mode.h>
1662#endif
1663
c623bd54
LW
1664#ifndef S_IFMT
1665# ifdef _S_IFMT
1666# define S_IFMT _S_IFMT
1667# else
1668# define S_IFMT 0170000
1669# endif
1670#endif
1671
1672#ifndef S_ISDIR
1673# define S_ISDIR(m) ((m & S_IFMT) == S_IFDIR)
1674#endif
1675
1676#ifndef S_ISCHR
1677# define S_ISCHR(m) ((m & S_IFMT) == S_IFCHR)
1678#endif
1679
1680#ifndef S_ISBLK
fe14fcc3
LW
1681# ifdef S_IFBLK
1682# define S_ISBLK(m) ((m & S_IFMT) == S_IFBLK)
1683# else
1684# define S_ISBLK(m) (0)
1685# endif
c623bd54
LW
1686#endif
1687
1688#ifndef S_ISREG
1689# define S_ISREG(m) ((m & S_IFMT) == S_IFREG)
1690#endif
1691
1692#ifndef S_ISFIFO
fe14fcc3
LW
1693# ifdef S_IFIFO
1694# define S_ISFIFO(m) ((m & S_IFMT) == S_IFIFO)
1695# else
1696# define S_ISFIFO(m) (0)
1697# endif
c623bd54
LW
1698#endif
1699
1700#ifndef S_ISLNK
da5fdda8
AC
1701# ifdef _S_ISLNK
1702# define S_ISLNK(m) _S_ISLNK(m)
1703# elif defined(_S_IFLNK)
1704# define S_ISLNK(m) ((m & S_IFMT) == _S_IFLNK)
1705# elif defined(S_IFLNK)
1706# define S_ISLNK(m) ((m & S_IFMT) == S_IFLNK)
1707# else
1708# define S_ISLNK(m) (0)
1709# endif
c623bd54
LW
1710#endif
1711
1712#ifndef S_ISSOCK
da5fdda8
AC
1713# ifdef _S_ISSOCK
1714# define S_ISSOCK(m) _S_ISSOCK(m)
1715# elif defined(_S_IFSOCK)
1716# define S_ISSOCK(m) ((m & S_IFMT) == _S_IFSOCK)
1717# elif defined(S_IFSOCK)
1718# define S_ISSOCK(m) ((m & S_IFMT) == S_IFSOCK)
1719# else
1720# define S_ISSOCK(m) (0)
1721# endif
c623bd54
LW
1722#endif
1723
1724#ifndef S_IRUSR
1725# ifdef S_IREAD
1726# define S_IRUSR S_IREAD
1727# define S_IWUSR S_IWRITE
1728# define S_IXUSR S_IEXEC
1729# else
1730# define S_IRUSR 0400
1731# define S_IWUSR 0200
1732# define S_IXUSR 0100
1733# endif
fac7cdfc 1734#endif
1735
1736#ifndef S_IRGRP
1737# ifdef S_IRUSR
1738# define S_IRGRP (S_IRUSR>>3)
1739# define S_IWGRP (S_IWUSR>>3)
1740# define S_IXGRP (S_IXUSR>>3)
1741# else
1742# define S_IRGRP 0040
1743# define S_IWGRP 0020
1744# define S_IXGRP 0010
1745# endif
1746#endif
1747
1748#ifndef S_IROTH
1749# ifdef S_IRUSR
1750# define S_IROTH (S_IRUSR>>6)
1751# define S_IWOTH (S_IWUSR>>6)
1752# define S_IXOTH (S_IXUSR>>6)
1753# else
1754# define S_IROTH 0040
1755# define S_IWOTH 0020
1756# define S_IXOTH 0010
1757# endif
c623bd54
LW
1758#endif
1759
1760#ifndef S_ISUID
1761# define S_ISUID 04000
1762#endif
1763
1764#ifndef S_ISGID
1765# define S_ISGID 02000
1766#endif
1767
ca6e1c26
JH
1768#ifndef S_IRWXU
1769# define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR)
d460ef45 1770#endif
ca6e1c26
JH
1771
1772#ifndef S_IRWXG
1773# define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP)
d460ef45 1774#endif
ca6e1c26
JH
1775
1776#ifndef S_IRWXO
1777# define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH)
d460ef45 1778#endif
ca6e1c26 1779
b6c36746 1780/* Haiku R1 seems to define S_IREAD and S_IWRITE in <posix/fcntl.h>
c21fb2b8
JH
1781 * which would get included through <sys/file.h >, but that is 3000
1782 * lines in the future. --jhi */
1783
b6c36746 1784#if !defined(S_IREAD) && !defined(__HAIKU__)
ca6e1c26
JH
1785# define S_IREAD S_IRUSR
1786#endif
1787
b6c36746 1788#if !defined(S_IWRITE) && !defined(__HAIKU__)
ca6e1c26
JH
1789# define S_IWRITE S_IWUSR
1790#endif
1791
1792#ifndef S_IEXEC
1793# define S_IEXEC S_IXUSR
1794#endif
1795
a0d0e21e 1796#if defined(cray) || defined(gould) || defined(i860) || defined(pyr)
45d8adaa
LW
1797# define SLOPPYDIVIDE
1798#endif
1799
748a9306
LW
1800#ifdef UV
1801#undef UV
1802#endif
1803
f1519f70
AC
1804/* This used to be conditionally defined based on whether we had a sprintf()
1805 * that correctly returns the string length (as required by C89), but we no
1806 * longer need that. XS modules can (and do) use this name, so it must remain
558a6899
KW
1807 * a part of the API that's visible to modules.
1808
51b56f5c 1809=for apidoc_section String Handling
558a6899
KW
1810=for apidoc ATmD|int|my_sprintf|NN char *buffer|NN const char *pat|...
1811
1812Do NOT use this due to the possibility of overflowing C<buffer>. Instead use
1813my_snprintf()
1814
1815=cut
1816*/
f1519f70 1817#define my_sprintf sprintf
ce582cee 1818
5b692037
JH
1819/*
1820 * If we have v?snprintf() and the C99 variadic macros, we can just
1821 * use just the v?snprintf(). It is nice to try to trap the buffer
1822 * overflow, however, so if we are DEBUGGING, and we cannot use the
e5afc1ae
DD
1823 * gcc statement expressions, then use the function wrappers which try
1824 * to trap the overflow. If we can use the gcc statement expressions,
1825 * we can try that even with the version that uses the C99 variadic
1826 * macros.
5b692037
JH
1827 */
1828
1208b3dd 1829/* Note that we do not check against snprintf()/vsnprintf() returning
4059ba87
AC
1830 * negative values because that is non-standard behaviour and we use
1831 * snprintf/vsnprintf only iff HAS_VSNPRINTF has been defined, and
1832 * that should be true only if the snprintf()/vsnprintf() are true
1833 * to the standard. */
1208b3dd 1834
571ee10c 1835#define PERL_SNPRINTF_CHECK(len, max, api) STMT_START { if ((max) > 0 && (Size_t)len > (max)) Perl_croak_nocontext("panic: %s buffer overflow", STRINGIFY(api)); } STMT_END
e8549682 1836
a4eca1d4
JH
1837#ifdef USE_QUADMATH
1838# define my_snprintf Perl_my_snprintf
1839# define PERL_MY_SNPRINTF_GUARDED
4059ba87 1840#elif defined(HAS_SNPRINTF) && defined(HAS_C99_VARIADIC_MACROS) && !(defined(DEBUGGING) && !defined(PERL_USE_GCC_BRACE_GROUPS)) && !defined(PERL_GCC_PEDANTIC)
5b692037 1841# ifdef PERL_USE_GCC_BRACE_GROUPS
e8549682 1842# define my_snprintf(buffer, max, ...) ({ int len = snprintf(buffer, max, __VA_ARGS__); PERL_SNPRINTF_CHECK(len, max, snprintf); len; })
1208b3dd 1843# define PERL_MY_SNPRINTF_GUARDED
5b692037 1844# else
e8549682 1845# define my_snprintf(buffer, max, ...) snprintf(buffer, max, __VA_ARGS__)
5b692037
JH
1846# endif
1847#else
1848# define my_snprintf Perl_my_snprintf
1208b3dd 1849# define PERL_MY_SNPRINTF_GUARDED
5b692037
JH
1850#endif
1851
a4eca1d4
JH
1852/* There is no quadmath_vsnprintf, and therefore my_vsnprintf()
1853 * dies if called under USE_QUADMATH. */
4059ba87 1854#if defined(HAS_VSNPRINTF) && defined(HAS_C99_VARIADIC_MACROS) && !(defined(DEBUGGING) && !defined(PERL_USE_GCC_BRACE_GROUPS)) && !defined(PERL_GCC_PEDANTIC)
5b692037 1855# ifdef PERL_USE_GCC_BRACE_GROUPS
e8549682 1856# define my_vsnprintf(buffer, max, ...) ({ int len = vsnprintf(buffer, max, __VA_ARGS__); PERL_SNPRINTF_CHECK(len, max, vsnprintf); len; })
1208b3dd 1857# define PERL_MY_VSNPRINTF_GUARDED
5b692037 1858# else
e8549682 1859# define my_vsnprintf(buffer, max, ...) vsnprintf(buffer, max, __VA_ARGS__)
5b692037
JH
1860# endif
1861#else
1862# define my_vsnprintf Perl_my_vsnprintf
1208b3dd 1863# define PERL_MY_VSNPRINTF_GUARDED
5b692037 1864#endif
d9fad198 1865
e8549682
JH
1866/* You will definitely need to use the PERL_MY_SNPRINTF_POST_GUARD()
1867 * or PERL_MY_VSNPRINTF_POST_GUARD() if you otherwise decide to ignore
1868 * the result of my_snprintf() or my_vsnprintf(). (No, you should not
1869 * completely ignore it: otherwise you cannot know whether your output
1870 * was too long.)
1871 *
1872 * int len = my_sprintf(buf, max, ...);
1873 * PERL_MY_SNPRINTF_POST_GUARD(len, max);
1874 *
1875 * The trick is that in certain platforms [a] the my_sprintf() already
1876 * contains the sanity check, while in certain platforms [b] it needs
1877 * to be done as a separate step. The POST_GUARD is that step-- in [a]
1878 * platforms the POST_GUARD actually does nothing since the check has
1879 * already been done. Watch out for the max being the same in both calls.
1880 *
1881 * If you actually use the snprintf/vsnprintf return value already,
1882 * you assumedly are checking its validity somehow. But you can
1883 * insert the POST_GUARD() also in that case. */
1884
1885#ifndef PERL_MY_SNPRINTF_GUARDED
1886# define PERL_MY_SNPRINTF_POST_GUARD(len, max) PERL_SNPRINTF_CHECK(len, max, snprintf)
1887#else
1888# define PERL_MY_SNPRINTF_POST_GUARD(len, max) PERL_UNUSED_VAR(len)
1889#endif
1890
1891#ifndef PERL_MY_VSNPRINTF_GUARDED
1892# define PERL_MY_VSNPRINTF_POST_GUARD(len, max) PERL_SNPRINTF_CHECK(len, max, vsnprintf)
1893#else
1894# define PERL_MY_VSNPRINTF_POST_GUARD(len, max) PERL_UNUSED_VAR(len)
1895#endif
1896
a6cc4119
SP
1897#ifdef HAS_STRLCAT
1898# define my_strlcat strlcat
a6cc4119
SP
1899#endif
1900
6dba01e2
KW
1901#if defined(PERL_CORE) || defined(PERL_EXT)
1902# ifdef HAS_MEMRCHR
1903# define my_memrchr memrchr
1904# else
1905# define my_memrchr S_my_memrchr
1906# endif
1907#endif
1908
a6cc4119
SP
1909#ifdef HAS_STRLCPY
1910# define my_strlcpy strlcpy
a6cc4119
SP
1911#endif
1912
aefb3fa0
DIM
1913#ifdef HAS_STRNLEN
1914# define my_strnlen strnlen
aefb3fa0
DIM
1915#endif
1916
05f13f53 1917/*
27d4fb96
PP
1918 The IV type is supposed to be long enough to hold any integral
1919 value or a pointer.
1920 --Andy Dougherty August 1996
1921*/
1922
a22e52b9
JH
1923typedef IVTYPE IV;
1924typedef UVTYPE UV;
8175356b 1925
10cc9d2a 1926#if defined(USE_64_BIT_INT) && defined(HAS_QUAD)
6b8eaf93 1927# if QUADKIND == QUAD_IS_INT64_T && defined(INT64_MAX)
bf51a9b9
TC
1928# define IV_MAX ((IV)INT64_MAX)
1929# define IV_MIN ((IV)INT64_MIN)
1930# define UV_MAX ((UV)UINT64_MAX)
cae7ae48
JH
1931# ifndef UINT64_MIN
1932# define UINT64_MIN 0
1933# endif
bf51a9b9 1934# define UV_MIN ((UV)UINT64_MIN)
5ff3f7a4
GS
1935# else
1936# define IV_MAX PERL_QUAD_MAX
1937# define IV_MIN PERL_QUAD_MIN
1938# define UV_MAX PERL_UQUAD_MAX
1939# define UV_MIN PERL_UQUAD_MIN
1940# endif
cf2093f6
JH
1941# define IV_IS_QUAD
1942# define UV_IS_QUAD
79072805 1943#else
8175356b 1944# if defined(INT32_MAX) && IVSIZE == 4
bf51a9b9
TC
1945# define IV_MAX ((IV)INT32_MAX)
1946# define IV_MIN ((IV)INT32_MIN)
716026f9 1947# ifndef UINT32_MAX_BROKEN /* e.g. HP-UX with gcc messes this up */
bf51a9b9 1948# define UV_MAX ((UV)UINT32_MAX)
716026f9 1949# else
bf51a9b9 1950# define UV_MAX ((UV)4294967295U)
716026f9 1951# endif
cae7ae48
JH
1952# ifndef UINT32_MIN
1953# define UINT32_MIN 0
1954# endif
bf51a9b9 1955# define UV_MIN ((UV)UINT32_MIN)
5ff3f7a4
GS
1956# else
1957# define IV_MAX PERL_LONG_MAX
1958# define IV_MIN PERL_LONG_MIN
1959# define UV_MAX PERL_ULONG_MAX
1960# define UV_MIN PERL_ULONG_MIN
1961# endif
8175356b 1962# if IVSIZE == 8
cf2093f6
JH
1963# define IV_IS_QUAD
1964# define UV_IS_QUAD
de1c2614
JH
1965# ifndef HAS_QUAD
1966# define HAS_QUAD
1967# endif
cf2093f6
JH
1968# else
1969# undef IV_IS_QUAD
1970# undef UV_IS_QUAD
7adf2470 1971#if !defined(PERL_CORE)
e25d460c
NC
1972/* We think that removing this decade-old undef this will cause too much
1973 breakage on CPAN for too little gain. (See RT #119753)
7adf2470 1974 However, we do need HAS_QUAD in the core for use by the drand48 code. */
cb4b14d5 1975# undef HAS_QUAD
e25d460c 1976#endif
cf2093f6 1977# endif
79072805 1978#endif
d7d93a81 1979
6313e544
JH
1980#define Size_t_MAX (~(Size_t)0)
1981#define SSize_t_MAX (SSize_t)(~(Size_t)0 >> 1)
9a543cee 1982
cae7ae48 1983#define IV_DIG (BIT_DIGITS(IVSIZE * 8))
22ec83e3 1984#define UV_DIG (BIT_DIGITS(UVSIZE * 8))
56431972 1985
28e5dec8 1986#ifndef NO_PERL_PRESERVE_IVUV
f5c03d33 1987#define PERL_PRESERVE_IVUV /* We like our integers to stay integers. */
28e5dec8
JH
1988#endif
1989
d460ef45 1990/*
26bb67e2
JH
1991 * The macros INT2PTR and NUM2PTR are (despite their names)
1992 * bi-directional: they will convert int/float to or from pointers.
1993 * However the conversion to int/float are named explicitly:
1994 * PTR2IV, PTR2UV, PTR2NV.
1995 *
1996 * For int conversions we do not need two casts if pointers are
1997 * the same size as IV and UV. Otherwise we need an explicit
1998 * cast (PTRV) to avoid compiler warnings.
81065b6d
KW
1999 *
2000 * These are mentioned in perlguts
26bb67e2 2001 */
56431972
RB
2002#if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
2003# define PTRV UV
2004# define INT2PTR(any,d) (any)(d)
da5fdda8
AC
2005#elif PTRSIZE == LONGSIZE
2006# define PTRV unsigned long
2007# define PTR2ul(p) (unsigned long)(p)
56431972 2008#else
da5fdda8 2009# define PTRV unsigned
e91e3b10
RB
2010#endif
2011
2012#ifndef INT2PTR
56431972 2013# define INT2PTR(any,d) (any)(PTRV)(d)
42718184 2014#endif
e91e3b10
RB
2015
2016#ifndef PTR2ul
2017# define PTR2ul(p) INT2PTR(unsigned long,p)
2018#endif
2019
56431972
RB
2020#define NUM2PTR(any,d) (any)(PTRV)(d)
2021#define PTR2IV(p) INT2PTR(IV,p)
2022#define PTR2UV(p) INT2PTR(UV,p)
2023#define PTR2NV(p) NUM2PTR(NV,p)
e91e3b10 2024#define PTR2nat(p) (PTRV)(p) /* pointer to integer of PTRSIZE */
d460ef45 2025
8141890a
JH
2026/* According to strict ANSI C89 one cannot freely cast between
2027 * data pointers and function (code) pointers. There are at least
2028 * two ways around this. One (used below) is to do two casts,
2029 * first the other pointer to an (unsigned) integer, and then
2030 * the integer to the other pointer. The other way would be
2031 * to use unions to "overlay" the pointers. For an example of
2032 * the latter technique, see union dirpu in struct xpvio in sv.h.
2033 * The only feasible use is probably temporarily storing
2034 * function pointers in a data pointer (such as a void pointer). */
2035
e91e3b10
RB
2036#define DPTR2FPTR(t,p) ((t)PTR2nat(p)) /* data pointer to function pointer */
2037#define FPTR2DPTR(t,p) ((t)PTR2nat(p)) /* function pointer to data pointer */
8141890a 2038
65202027 2039#ifdef USE_LONG_DOUBLE
f3654d06
JH
2040# if LONG_DOUBLESIZE == DOUBLESIZE
2041# define LONG_DOUBLE_EQUALS_DOUBLE
2042# undef USE_LONG_DOUBLE /* Ouch! */
65202027
DS
2043# endif
2044#endif
2045
2d4389e4
JH
2046/* The following is all to get LDBL_DIG, in order to pick a nice
2047 default value for printing floating point numbers in Gconvert.
2048 (see config.h)
2049*/
63b481b9 2050#ifndef HAS_LDBL_DIG
68d4903c 2051# if LONG_DOUBLESIZE == 10
63b481b9
AC
2052# define LDBL_DIG 18 /* assume IEEE */
2053# elif LONG_DOUBLESIZE == 12
68d4903c 2054# define LDBL_DIG 18 /* gcc? */
63b481b9
AC
2055# elif LONG_DOUBLESIZE == 16
2056# define LDBL_DIG 33 /* assume IEEE */
2057# elif LONG_DOUBLESIZE == DOUBLESIZE
2058# define LDBL_DIG DBL_DIG /* bummer */
68d4903c 2059# endif
2d4389e4
JH
2060#endif
2061
a22e52b9 2062typedef NVTYPE NV;
8175356b 2063
792d8dab
JH
2064#ifdef I_IEEEFP
2065# include <ieeefp.h>
2066#endif
923fc586 2067
bcd8bfa9
JH
2068#if defined(__DECC) && defined(__osf__)
2069/* Also Tru64 cc has broken NaN comparisons. */
2070# define NAN_COMPARE_BROKEN
c32c3de1 2071#endif
6504068e
JH
2072#if defined(__sgi)
2073# define NAN_COMPARE_BROKEN
2074#endif
c32c3de1 2075
65202027 2076#ifdef USE_LONG_DOUBLE
923fc586
JH
2077# ifdef I_SUNMATH
2078# include <sunmath.h>
2079# endif
84e6cb05 2080# if defined(LDBL_DIG)
05b4a618
JH
2081# define NV_DIG LDBL_DIG
2082# ifdef LDBL_MANT_DIG
2083# define NV_MANT_DIG LDBL_MANT_DIG
2084# endif
2085# ifdef LDBL_MIN
2086# define NV_MIN LDBL_MIN
2087# endif
2088# ifdef LDBL_MAX
2089# define NV_MAX LDBL_MAX
2090# endif
2091# ifdef LDBL_MIN_EXP
2092# define NV_MIN_EXP LDBL_MIN_EXP
2093# endif
2094# ifdef LDBL_MAX_EXP
2095# define NV_MAX_EXP LDBL_MAX_EXP
2096# endif
2097# ifdef LDBL_MIN_10_EXP
2098# define NV_MIN_10_EXP LDBL_MIN_10_EXP
2099# endif
2100# ifdef LDBL_MAX_10_EXP
2101# define NV_MAX_10_EXP LDBL_MAX_10_EXP
2102# endif
2103# ifdef LDBL_EPSILON
2104# define NV_EPSILON LDBL_EPSILON
2105# endif
2106# ifdef LDBL_MAX
2107# define NV_MAX LDBL_MAX
20f6aaab 2108/* Having LDBL_MAX doesn't necessarily mean that we have LDBL_MIN... -Allen */
da5fdda8
AC
2109# elif defined(HUGE_VALL)
2110# define NV_MAX HUGE_VALL
f4a14a62
JH
2111# endif
2112# endif
84e6cb05 2113# if defined(HAS_SQRTL)
8a00eddc
JH
2114# define Perl_acos acosl
2115# define Perl_asin asinl
2116# define Perl_atan atanl
940e3d56
JH
2117# define Perl_atan2 atan2l
2118# define Perl_ceil ceill
2119# define Perl_cos cosl
8a00eddc 2120# define Perl_cosh coshl
940e3d56 2121# define Perl_exp expl
55da5e5b 2122/* no Perl_fabs, but there's PERL_ABS */
940e3d56
JH
2123# define Perl_floor floorl
2124# define Perl_fmod fmodl
2125# define Perl_log logl
8a00eddc 2126# define Perl_log10 log10l
940e3d56
JH
2127# define Perl_pow powl
2128# define Perl_sin sinl
8a00eddc 2129# define Perl_sinh sinhl
940e3d56 2130# define Perl_sqrt sqrtl
8a00eddc
JH
2131# define Perl_tan tanl
2132# define Perl_tanh tanhl
68d4903c 2133# endif
a3540c92 2134/* e.g. libsunmath doesn't have modfl and frexpl as of mid-March 2000 */
05b4a618
JH
2135# ifndef Perl_modf
2136# ifdef HAS_MODFL
2137# define Perl_modf(x,y) modfl(x,y)
51997bc3
NC
2138/* eg glibc 2.2 series seems to provide modfl on ppc and arm, but has no
2139 prototype in <math.h> */
05b4a618 2140# ifndef HAS_MODFL_PROTO
a221a8a5 2141EXTERN_C long double modfl(long double, long double *);
05b4a618
JH
2142# endif
2143# elif (defined(HAS_TRUNCL) || defined(HAS_AINTL)) && defined(HAS_COPYSIGNL)
55954f19 2144 extern long double Perl_my_modfl(long double x, long double *ip);
03476e8e 2145# define Perl_modf(x,y) Perl_my_modfl(x,y)
05b4a618 2146# endif
a3540c92 2147# endif
05b4a618
JH
2148# ifndef Perl_frexp
2149# ifdef HAS_FREXPL
2150# define Perl_frexp(x,y) frexpl(x,y)
da5fdda8 2151# elif defined(HAS_ILOGBL) && defined(HAS_SCALBNL)
05b4a618 2152extern long double Perl_my_frexpl(long double x, int *e);
da5fdda8 2153# define Perl_frexp(x,y) Perl_my_frexpl(x,y)
03476e8e 2154# endif
a3540c92 2155# endif
05b4a618
JH
2156# ifndef Perl_ldexp
2157# ifdef HAS_LDEXPL
2158# define Perl_ldexp(x, y) ldexpl(x,y)
da5fdda8
AC
2159# elif defined(HAS_SCALBNL) && FLT_RADIX == 2
2160# define Perl_ldexp(x,y) scalbnl(x,y)
98181445
JH
2161# endif
2162# endif
38dbb4c5 2163# ifndef Perl_isnan
e4c957f4 2164# if defined(HAS_ISNANL) && !(defined(isnan) && defined(HAS_C99))
758a5d79 2165# define Perl_isnan(x) isnanl(x)
a1115378
JH
2166# elif defined(__sgi) && defined(__c99) /* XXX Configure test needed */
2167# define Perl_isnan(x) isnan(x)
758a5d79
JH
2168# endif
2169# endif
2170# ifndef Perl_isinf
e4c957f4 2171# if defined(HAS_ISINFL) && !(defined(isinf) && defined(HAS_C99))
87190886 2172# define Perl_isinf(x) isinfl(x)
a1115378
JH
2173# elif defined(__sgi) && defined(__c99) /* XXX Configure test needed */
2174# define Perl_isinf(x) isinf(x)
bcd8bfa9 2175# elif defined(LDBL_MAX) && !defined(NAN_COMPARE_BROKEN)
efcbf317 2176# define Perl_isinf(x) ((x) > LDBL_MAX || (x) < -LDBL_MAX)
a3540c92
JH
2177# endif
2178# endif
e38461cc
JH
2179# ifndef Perl_isfinite
2180# define Perl_isfinite(x) Perl_isfinitel(x)
2181# endif
84e6cb05
JH
2182#elif defined(USE_QUADMATH) && defined(I_QUADMATH)
2183# include <quadmath.h>
2184# define NV_DIG FLT128_DIG
2185# define NV_MANT_DIG FLT128_MANT_DIG
2186# define NV_MIN FLT128_MIN
2187# define NV_MAX FLT128_MAX
2188# define NV_MIN_EXP FLT128_MIN_EXP
2189# define NV_MAX_EXP FLT128_MAX_EXP
2190# define NV_EPSILON FLT128_EPSILON
2191# define NV_MIN_10_EXP FLT128_MIN_10_EXP
2192# define NV_MAX_10_EXP FLT128_MAX_10_EXP
84e6cb05
JH
2193# define Perl_acos acosq
2194# define Perl_asin asinq
2195# define Perl_atan atanq
2196# define Perl_atan2 atan2q
2197# define Perl_ceil ceilq
2198# define Perl_cos cosq
2199# define Perl_cosh coshq
2200# define Perl_exp expq
2201/* no Perl_fabs, but there's PERL_ABS */
2202# define Perl_floor floorq
2203# define Perl_fmod fmodq
2204# define Perl_log logq
2205# define Perl_log10 log10q
e6081c0e 2206# define Perl_signbit signbitq
84e6cb05
JH
2207# define Perl_pow powq
2208# define Perl_sin sinq
2209# define Perl_sinh sinhq
2210# define Perl_sqrt sqrtq
2211# define Perl_tan tanq
2212# define Perl_tanh tanhq
2213# define Perl_modf(x,y) modfq(x,y)
2214# define Perl_frexp(x,y) frexpq(x,y)
2215# define Perl_ldexp(x, y) ldexpq(x,y)
2216# define Perl_isinf(x) isinfq(x)
2217# define Perl_isnan(x) isnanq(x)
2218# define Perl_isfinite(x) !(isnanq(x) || isinfq(x))
b28053d1
JH
2219# define Perl_fp_class(x) ((x) == 0.0Q ? 0 : isinfq(x) ? 3 : isnanq(x) ? 4 : PERL_ABS(x) < FLT128_MIN ? 2 : 1)
2220# define Perl_fp_class_inf(x) (Perl_fp_class(x) == 3)
2221# define Perl_fp_class_nan(x) (Perl_fp_class(x) == 4)
2222# define Perl_fp_class_norm(x) (Perl_fp_class(x) == 1)
2223# define Perl_fp_class_denorm(x) (Perl_fp_class(x) == 2)
2224# define Perl_fp_class_zero(x) (Perl_fp_class(x) == 0)
65202027 2225#else
2d4389e4 2226# define NV_DIG DBL_DIG
63b481b9
AC
2227# define NV_MANT_DIG DBL_MANT_DIG
2228# define NV_MIN DBL_MIN
2229# define NV_MAX DBL_MAX
2230# define NV_MIN_EXP DBL_MIN_EXP
2231# define NV_MAX_EXP DBL_MAX_EXP
2232# define NV_MIN_10_EXP DBL_MIN_10_EXP
2233# define NV_MAX_10_EXP DBL_MAX_10_EXP
2234# define NV_EPSILON DBL_EPSILON
2235# define NV_MAX DBL_MAX
2236# define NV_MIN DBL_MIN
940e3d56 2237
55da5e5b 2238/* These math interfaces are C89. */
8a00eddc
JH
2239# define Perl_acos acos
2240# define Perl_asin asin
2241# define Perl_atan atan
940e3d56
JH
2242# define Perl_atan2 atan2
2243# define Perl_ceil ceil
2244# define Perl_cos cos
8a00eddc 2245# define Perl_cosh cosh
940e3d56 2246# define Perl_exp exp
55da5e5b 2247/* no Perl_fabs, but there's PERL_ABS */
940e3d56
JH
2248# define Perl_floor floor
2249# define Perl_fmod fmod
2250# define Perl_log log
8a00eddc 2251# define Perl_log10 log10
940e3d56
JH
2252# define Perl_pow pow
2253# define Perl_sin sin
8a00eddc 2254# define Perl_sinh sinh
940e3d56 2255# define Perl_sqrt sqrt
8a00eddc
JH
2256# define Perl_tan tan
2257# define Perl_tanh tanh
940e3d56
JH
2258
2259# define Perl_modf(x,y) modf(x,y)
2260# define Perl_frexp(x,y) frexp(x,y)
2261# define Perl_ldexp(x,y) ldexp(x,y)
2262
1a322af2
JH
2263# ifndef Perl_isnan
2264# ifdef HAS_ISNAN
2265# define Perl_isnan(x) isnan(x)
2266# endif
2267# endif
2268# ifndef Perl_isinf
2269# if defined(HAS_ISINF)
2270# define Perl_isinf(x) isinf(x)
bcd8bfa9 2271# elif defined(DBL_MAX) && !defined(NAN_COMPARE_BROKEN)
efcbf317 2272# define Perl_isinf(x) ((x) > DBL_MAX || (x) < -DBL_MAX)
1a322af2
JH
2273# endif
2274# endif
2275# ifndef Perl_isfinite
2276# ifdef HAS_ISFINITE
2277# define Perl_isfinite(x) isfinite(x)
2278# elif defined(HAS_FINITE)
2279# define Perl_isfinite(x) finite(x)
2280# endif
2281# endif
758a5d79
JH
2282#endif
2283
30404d48
JH
2284/* fpclassify(): C99. It is supposed to be a macro that switches on
2285* the sizeof() of its argument, so there's no need for e.g. fpclassifyl().*/
2286#if !defined(Perl_fp_class) && defined(HAS_FPCLASSIFY)
2287# include <math.h>
25c46df8
JH
2288# if defined(FP_INFINITE) && defined(FP_NAN)
2289# define Perl_fp_class(x) fpclassify(x)
2290# define Perl_fp_class_inf(x) (Perl_fp_class(x)==FP_INFINITE)
2291# define Perl_fp_class_nan(x) (Perl_fp_class(x)==FP_NAN)
2292# define Perl_fp_class_norm(x) (Perl_fp_class(x)==FP_NORMAL)
2293# define Perl_fp_class_denorm(x) (Perl_fp_class(x)==FP_SUBNORMAL)
2294# define Perl_fp_class_zero(x) (Perl_fp_class(x)==FP_ZERO)
2295# elif defined(FP_PLUS_INF) && defined(FP_QNAN)
2296/* Some versions of HP-UX (10.20) have (only) fpclassify() but which is
2297 * actually not the C99 fpclassify, with its own set of return defines. */
2298# define Perl_fp_class(x) fpclassify(x)
2299# define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_PLUS_INF)
2300# define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_MINUS_INF)
82947af8 2301# define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_SNAN)
25c46df8
JH
2302# define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_QNAN)
2303# define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_PLUS_NORM)
1ae51000 2304# define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_MINUS_NORM)
25c46df8
JH
2305# define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_PLUS_DENORM)
2306# define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_MINUS_DENORM)
2307# define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_PLUS_ZERO)
2308# define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_MINUS_ZERO)
2309# else
2310# undef Perl_fp_class /* Unknown set of defines */
2311# endif
30404d48
JH
2312#endif
2313
25c46df8
JH
2314/* fp_classify(): Legacy: VMS, maybe Unicos? The values, however,
2315 * are identical to the C99 fpclassify(). */
2316#if !defined(Perl_fp_class) && defined(HAS_FP_CLASSIFY)
2317# include <math.h>
558f3e66
CB
2318# ifdef __VMS
2319 /* FP_INFINITE and others are here rather than in math.h as C99 stipulates */
2320# include <fp.h>
56610b8f
CB
2321 /* oh, and the isnormal macro has a typo in it! */
2322# undef isnormal
2323# define isnormal(x) Perl_fp_class_norm(x)
558f3e66 2324# endif
25c46df8
JH
2325# if defined(FP_INFINITE) && defined(FP_NAN)
2326# define Perl_fp_class(x) fp_classify(x)
2327# define Perl_fp_class_inf(x) (Perl_fp_class(x)==FP_INFINITE)
2328# define Perl_fp_class_nan(x) (Perl_fp_class(x)==FP_NAN)
2329# define Perl_fp_class_norm(x) (Perl_fp_class(x)==FP_NORMAL)
2330# define Perl_fp_class_denorm(x) (Perl_fp_class(x)==FP_SUBNORMAL)
2331# define Perl_fp_class_zero(x) (Perl_fp_class(x)==FP_ZERO)
2332# else
2333# undef Perl_fp_class /* Unknown set of defines */
2334# endif
f279e099 2335#endif
205f51d8 2336
30404d48
JH
2337/* Feel free to check with me for the SGI manpages, SGI testing,
2338 * etcetera, if you want to try getting this to work with IRIX.
2339 *
2340 * - Allen <allens@cpan.org> */
2341
2342/* fpclass(): SysV, at least Solaris and some versions of IRIX. */
758a5d79 2343#if !defined(Perl_fp_class) && (defined(HAS_FPCLASS)||defined(HAS_FPCLASSL))
25c46df8
JH
2344/* Solaris and IRIX have fpclass/fpclassl, but they are using
2345 * an enum typedef, not cpp symbols, and Configure doesn't detect that.
2346 * Define some symbols also as cpp symbols so we can detect them. */
033a6f7a 2347# if defined(__sun) || defined(__sgi) /* XXX Configure test instead */
25c46df8
JH
2348# define FP_PINF FP_PINF
2349# define FP_QNAN FP_QNAN
2350# endif
f279e099 2351# include <math.h>
758a5d79
JH
2352# ifdef I_IEEFP
2353# include <ieeefp.h>
2354# endif
2355# ifdef I_FP
2356# include <fp.h>
2357# endif
2358# if defined(USE_LONG_DOUBLE) && defined(HAS_FPCLASSL)
f279e099 2359# define Perl_fp_class(x) fpclassl(x)
758a5d79 2360# else
f279e099
JH
2361# define Perl_fp_class(x) fpclass(x)
2362# endif
25c46df8 2363# if defined(FP_CLASS_PINF) && defined(FP_CLASS_SNAN)
f279e099
JH
2364# define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_CLASS_SNAN)
2365# define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_CLASS_QNAN)
2366# define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_CLASS_NINF)
2367# define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_CLASS_PINF)
2368# define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_CLASS_NNORM)
2369# define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_CLASS_PNORM)
2370# define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_CLASS_NDENORM)
2371# define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_CLASS_PDENORM)
2372# define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_CLASS_NZERO)
2373# define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_CLASS_PZERO)
25c46df8 2374# elif defined(FP_PINF) && defined(FP_QNAN)
f279e099
JH
2375# define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_SNAN)
2376# define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_QNAN)
2377# define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_NINF)
2378# define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_PINF)
2379# define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_NNORM)
2380# define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_PNORM)
2381# define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_NDENORM)
2382# define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_PDENORM)
2383# define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_NZERO)
2384# define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_PZERO)
25c46df8
JH
2385# else
2386# undef Perl_fp_class /* Unknown set of defines */
758a5d79 2387# endif
758a5d79
JH
2388#endif
2389
30404d48
JH
2390/* fp_class(): Legacy: at least Tru64, some versions of IRIX. */
2391#if !defined(Perl_fp_class) && (defined(HAS_FP_CLASS)||defined(HAS_FP_CLASSL))
758a5d79
JH
2392# include <math.h>
2393# if !defined(FP_SNAN) && defined(I_FP_CLASS)
2394# include <fp_class.h>
2395# endif
25c46df8 2396# if defined(FP_POS_INF) && defined(FP_QNAN)
033a6f7a 2397# ifdef __sgi /* XXX Configure test instead */
25c46df8
JH
2398# ifdef USE_LONG_DOUBLE
2399# define Perl_fp_class(x) fp_class_l(x)
2400# else
2401# define Perl_fp_class(x) fp_class_d(x)
2402# endif
f279e099 2403# else
25c46df8
JH
2404# if defined(USE_LONG_DOUBLE) && defined(HAS_FP_CLASSL)
2405# define Perl_fp_class(x) fp_classl(x)
2406# else
2407# define Perl_fp_class(x) fp_class(x)
2408# endif
f279e099 2409# endif
25c46df8
JH
2410# if defined(FP_POS_INF) && defined(FP_QNAN)
2411# define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_SNAN)
2412# define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_QNAN)
2413# define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_NEG_INF)
2414# define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_POS_INF)
2415# define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_NEG_NORM)
2416# define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_POS_NORM)
2417# define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_NEG_DENORM)
2418# define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_POS_DENORM)
2419# define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_NEG_ZERO)
2420# define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_POS_ZERO)
30404d48 2421# else
25c46df8 2422# undef Perl_fp_class /* Unknown set of defines */
30404d48 2423# endif
f279e099 2424# endif
30404d48
JH
2425#endif
2426
052758ae 2427/* class(), _class(): Legacy: AIX. */
758a5d79
JH
2428#if !defined(Perl_fp_class) && defined(HAS_CLASS)
2429# include <math.h>
25c46df8
JH
2430# if defined(FP_PLUS_NORM) && defined(FP_PLUS_INF)
2431# ifndef _cplusplus
2432# define Perl_fp_class(x) class(x)
2433# else
2434# define Perl_fp_class(x) _class(x)
2435# endif
2436# if defined(FP_PLUS_INF) && defined(FP_NANQ)
2437# define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_NANS)
2438# define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_NANQ)
2439# define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_MINUS_INF)
2440# define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_PLUS_INF)
2441# define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_MINUS_NORM)
2442# define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_PLUS_NORM)
2443# define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_MINUS_DENORM)
2444# define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_PLUS_DENORM)
2445# define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_MINUS_ZERO)
2446# define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_PLUS_ZERO)
2447# else
2448# undef Perl_fp_class /* Unknown set of defines */
2449# endif
758a5d79 2450# endif
30404d48
JH
2451#endif
2452
2453/* Win32: _fpclass(), _isnan(), _finite(). */
90f54b14 2454#ifdef _MSC_VER
796ea9ea
JH
2455# ifndef Perl_isnan
2456# define Perl_isnan(x) _isnan(x)
2457# endif
2458# ifndef Perl_isfinite
2459# define Perl_isfinite(x) _finite(x)
2460# endif
2461# ifndef Perl_fp_class_snan
25c46df8
JH
2462/* No simple way to #define Perl_fp_class because _fpclass()
2463 * returns a set of bits. */
796ea9ea
JH
2464# define Perl_fp_class_snan(x) (_fpclass(x) & _FPCLASS_SNAN)
2465# define Perl_fp_class_qnan(x) (_fpclass(x) & _FPCLASS_QNAN)
82947af8 2466# define Perl_fp_class_nan(x) (_fpclass(x) & (_FPCLASS_SNAN|_FPCLASS_QNAN))
796ea9ea
JH
2467# define Perl_fp_class_ninf(x) (_fpclass(x) & _FPCLASS_NINF))
2468# define Perl_fp_class_pinf(x) (_fpclass(x) & _FPCLASS_PINF))
2469# define Perl_fp_class_inf(x) (_fpclass(x) & (_FPCLASS_NINF|_FPCLASS_PINF))
2470# define Perl_fp_class_nnorm(x) (_fpclass(x) & _FPCLASS_NN)
2471# define Perl_fp_class_pnorm(x) (_fpclass(x) & _FPCLASS_PN)
2472# define Perl_fp_class_norm(x) (_fpclass(x) & (_FPCLASS_NN|_FPCLASS_PN))
2473# define Perl_fp_class_ndenorm(x) (_fpclass(x) & _FPCLASS_ND)
2474# define Perl_fp_class_pdenorm(x) (_fpclass(x) & _FPCLASS_PD)
2475# define Perl_fp_class_denorm(x) (_fpclass(x) & (_FPCLASS_ND|_FPCLASS_PD))
2476# define Perl_fp_class_nzero(x) (_fpclass(x) & _FPCLASS_NZ)
2477# define Perl_fp_class_pzero(x) (_fpclass(x) & _FPCLASS_PZ)
2478# define Perl_fp_class_zero(x) (_fpclass(x) & (_FPCLASS_NZ|_FPCLASS_PZ))
2479# endif
f279e099
JH
2480#endif
2481
2482#if !defined(Perl_fp_class_inf) && \
2483 defined(Perl_fp_class_pinf) && defined(Perl_fp_class_ninf)
2484# define Perl_fp_class_inf(x) \
2485 (Perl_fp_class_pinf(x) || Perl_fp_class_ninf(x))
2486#endif
2487
2488#if !defined(Perl_fp_class_nan) && \
2489 defined(Perl_fp_class_snan) && defined(Perl_fp_class_qnan)
2490# define Perl_fp_class_nan(x) \
2491 (Perl_fp_class_snan(x) || Perl_fp_class_qnan(x))
2492#endif
2493
2494#if !defined(Perl_fp_class_zero) && \
2495 defined(Perl_fp_class_pzero) && defined(Perl_fp_class_nzero)
2496# define Perl_fp_class_zero(x) \
2497 (Perl_fp_class_pzero(x) || Perl_fp_class_nzero(x))
2498#endif
2499
2500#if !defined(Perl_fp_class_norm) && \
2501 defined(Perl_fp_class_pnorm) && defined(Perl_fp_class_nnorm)
2502# define Perl_fp_class_norm(x) \
2503 (Perl_fp_class_pnorm(x) || Perl_fp_class_nnorm(x))
2504#endif
2505
2506#if !defined(Perl_fp_class_denorm) && \
2507 defined(Perl_fp_class_pdenorm) && defined(Perl_fp_class_ndenorm)
2508# define Perl_fp_class_denorm(x) \
2509 (Perl_fp_class_pdenorm(x) || Perl_fp_class_ndenorm(x))
796ea9ea 2510#endif
758a5d79
JH
2511
2512#ifndef Perl_isnan
1a322af2
JH
2513# ifdef Perl_fp_class_nan
2514# define Perl_isnan(x) Perl_fp_class_nan(x)
da5fdda8
AC
2515# elif defined(HAS_UNORDERED)
2516# define Perl_isnan(x) unordered((x), 0.0)
758a5d79 2517# else
da5fdda8 2518# define Perl_isnan(x) ((x)!=(x))
758a5d79
JH
2519# endif
2520#endif
2521
1a322af2
JH
2522#ifndef Perl_isinf
2523# ifdef Perl_fp_class_inf
2524# define Perl_isinf(x) Perl_fp_class_inf(x)
2525# endif
ca6c63e1
JH
2526#endif
2527
758a5d79 2528#ifndef Perl_isfinite
25c46df8 2529# if defined(HAS_ISFINITE) && !defined(isfinite)
c496ca58 2530# define Perl_isfinite(x) isfinite((double)(x))
4efd38a4 2531# elif defined(HAS_FINITE)
c496ca58 2532# define Perl_isfinite(x) finite((double)(x))
4efd38a4
JH
2533# elif defined(Perl_fp_class_finite)
2534# define Perl_isfinite(x) Perl_fp_class_finite(x)
758a5d79 2535# else
c496ca58
JH
2536/* For the infinities the multiplication returns nan,
2537 * for the nan the multiplication also returns nan,
2538 * for everything else (that is, finite) zero should be returned. */
4efd38a4 2539# define Perl_isfinite(x) (((x) * 0) == 0)
a3540c92 2540# endif
65202027
DS
2541#endif
2542
25c46df8
JH
2543#ifndef Perl_isinf
2544# if defined(Perl_isfinite) && defined(Perl_isnan)
2545# define Perl_isinf(x) !(Perl_isfinite(x)||Perl_isnan(x))
2546# endif
2547#endif
2548
d3685250
JH
2549/* We need Perl_isfinitel (ends with ell) (if available) even when
2550 * not USE_LONG_DOUBLE because the printf code (sv_catpvfn_flags)
2551 * needs that. */
2552#if defined(HAS_LONG_DOUBLE) && !defined(Perl_isfinitel)
2553/* If isfinite() is a macro and looks like we have C99,
2554 * we assume it's the type-aware C99 isfinite(). */
c06e9e3e 2555# if defined(HAS_ISFINITE) && defined(isfinite) && defined(HAS_C99)
d3685250
JH
2556# define Perl_isfinitel(x) isfinite(x)
2557# elif defined(HAS_ISFINITEL)
2558# define Perl_isfinitel(x) isfinitel(x)
2559# elif defined(HAS_FINITEL)
2560# define Perl_isfinitel(x) finitel(x)
2561# elif defined(HAS_INFL) && defined(HAS_NANL)
2562# define Perl_isfinitel(x) !(isinfl(x)||isnanl(x))
16334e6e 2563# else
99bf9e32 2564# define Perl_isfinitel(x) ((x) * 0 == 0) /* See Perl_isfinite. */
d3685250
JH
2565# endif
2566#endif
2567
a36244b7
JH
2568/* The default is to use Perl's own atof() implementation (in numeric.c).
2569 * Usually that is the one to use but for some platforms (e.g. UNICOS)
2570 * it is however best to use the native implementation of atof.
2571 * You can experiment with using your native one by -DUSE_PERL_ATOF=0.
2572 * Some good tests to try out with either setting are t/base/num.t,
205f51d8
AS
2573 * t/op/numconvert.t, and t/op/pack.t. Note that if using long doubles
2574 * you may need to be using a different function than atof! */
a36244b7
JH
2575
2576#ifndef USE_PERL_ATOF
2577# ifndef _UNICOS
2578# define USE_PERL_ATOF
2579# endif
2580#else
2581# if USE_PERL_ATOF == 0
2582# undef USE_PERL_ATOF
2583# endif
2584#endif
2585
2586#ifdef USE_PERL_ATOF
2587# define Perl_atof(s) Perl_my_atof(s)
6928bedc 2588# define Perl_atof2(s, n) Perl_my_atof3(aTHX_ (s), &(n), 0)
a36244b7
JH
2589#else
2590# define Perl_atof(s) (NV)atof(s)
2591# define Perl_atof2(s, n) ((n) = atof(s))
2592#endif
6928bedc 2593#define my_atof2(a,b) my_atof3(a,b,0)
cf2093f6 2594
99abf803
PP
2595/*
2596 * CHAR_MIN and CHAR_MAX are not included here, as the (char) type may be
2597 * ambiguous. It may be equivalent to (signed char) or (unsigned char)
2598 * depending on local options. Until Configure detects this (or at least
2599 * detects whether the "signed" keyword is available) the CHAR ranges
2600 * will not be included. UCHAR functions normally.
2601 * - kja
2602 */
27d4fb96 2603
6ec488b3
AC
2604#define PERL_UCHAR_MIN ((unsigned char)0)
2605#define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
27d4fb96 2606
6ec488b3
AC
2607#define PERL_USHORT_MIN ((unsigned short)0)
2608#define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
27d4fb96 2609
6ec488b3
AC
2610#define PERL_SHORT_MAX ((short)SHRT_MAX)
2611#define PERL_SHORT_MIN ((short)SHRT_MIN)
27d4fb96 2612
6ec488b3 2613#define PERL_UINT_MAX ((unsigned int)UINT_MAX)
99abf803 2614#define PERL_UINT_MIN ((unsigned int)0)
27d4fb96 2615
6ec488b3
AC
2616#define PERL_INT_MAX ((int)INT_MAX)
2617#define PERL_INT_MIN ((int)INT_MIN)
27d4fb96 2618
6ec488b3 2619#define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
99abf803 2620#define PERL_ULONG_MIN ((unsigned long)0L)
27d4fb96 2621
6ec488b3
AC
2622#define PERL_LONG_MAX ((long)LONG_MAX)
2623#define PERL_LONG_MIN ((long)LONG_MIN)
760ac839 2624
d7d93a81 2625#ifdef UV_IS_QUAD
99abf803 2626# define PERL_UQUAD_MAX (~(UV)0)
f1c3b19a 2627# define PERL_UQUAD_MIN ((UV)0)
99abf803 2628# define PERL_QUAD_MAX ((IV) (PERL_UQUAD_MAX >> 1))
a6e633de 2629# define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
79072805
LW
2630#endif
2631
d78a5caa 2632/*
51b56f5c 2633=for apidoc_section Integer configuration values
d78a5caa
KW
2634
2635=for apidoc AmnUh||PERL_INT_MIN
2636=for apidoc AmnUh||PERL_LONG_MAX
2637=for apidoc AmnUh||PERL_LONG_MIN
2638=for apidoc AmnUh||PERL_QUAD_MAX
2639=for apidoc AmnUh||PERL_SHORT_MAX
2640=for apidoc AmnUh||PERL_SHORT_MIN
2641=for apidoc AmnUh||PERL_UCHAR_MAX
2642=for apidoc AmnUh||PERL_UCHAR_MIN
2643=for apidoc AmnUh||PERL_UINT_MAX
91da38c9 2644=for apidoc AmnUh||PERL_UINT_MIN
d78a5caa
KW
2645=for apidoc AmnUh||PERL_ULONG_MAX
2646=for apidoc AmnUh||PERL_ULONG_MIN
2647=for apidoc AmnUh||PERL_UQUAD_MAX
2648=for apidoc AmnUh||PERL_UQUAD_MIN
2649=for apidoc AmnUh||PERL_USHORT_MAX
2650=for apidoc AmnUh||PERL_USHORT_MIN
2651=for apidoc AmnUh||PERL_QUAD_MIN
51b56f5c
KW
2652=for apidoc_section Floating point configuration values
2653
d78a5caa
KW
2654=for apidoc AmnU||PERL_INT_MAX
2655This and
2656C<PERL_INT_MIN>,
2657C<PERL_LONG_MAX>,
2658C<PERL_LONG_MIN>,
2659C<PERL_QUAD_MAX>,
2660C<PERL_SHORT_MAX>,
2661C<PERL_SHORT_MIN>,
2662C<PERL_UCHAR_MAX>,
2663C<PERL_UCHAR_MIN>,
2664C<PERL_UINT_MAX>,
91da38c9 2665C<PERL_UINT_MIN>,
d78a5caa
KW
2666C<PERL_ULONG_MAX>,
2667C<PERL_ULONG_MIN>,
2668C<PERL_UQUAD_MAX>,
2669C<PERL_UQUAD_MIN>,
2670C<PERL_USHORT_MAX>,
2671C<PERL_USHORT_MIN>,
2672C<PERL_QUAD_MIN>
2673give the largest and smallest number representable in the current
2674platform in variables of the corresponding types.
2675
2676For signed types, the smallest representable number is the most negative
2677number, the one furthest away from zero.
2678
2679For C99 and later compilers, these correspond to things like C<INT_MAX>, which
2680are available to the C code. But these constants, furnished by Perl,
2681allow code compiled on earlier compilers to portably have access to the same
2682constants.
2683
2684=cut
2685
2686*/
2687
ee0007ab 2688typedef MEM_SIZE STRLEN;
450a55e4 2689
79072805
LW
2690typedef struct op OP;
2691typedef struct cop COP;
2692typedef struct unop UNOP;
2f7c6295 2693typedef struct unop_aux UNOP_AUX;
79072805
LW
2694typedef struct binop BINOP;
2695typedef struct listop LISTOP;
2696typedef struct logop LOGOP;
79072805
LW
2697typedef struct pmop PMOP;
2698typedef struct svop SVOP;
7934575e 2699typedef struct padop PADOP;
79072805 2700typedef struct pvop PVOP;
79072805 2701typedef struct loop LOOP;
b46e009d 2702typedef struct methop METHOP;
79072805 2703
7aef8e5b 2704#ifdef PERL_CORE
8be227ab
FC
2705typedef struct opslab OPSLAB;
2706typedef struct opslot OPSLOT;
2707#endif
2708
52db365a 2709typedef struct block_hooks BHK;
1830b3d9 2710typedef struct custom_op XOP;
52db365a 2711
cd1541b2
NC
2712typedef struct interpreter PerlInterpreter;
2713
d2b3f365 2714/* SGI's <sys/sema.h> has struct sv */
cc3315ba 2715#if defined(__sgi)
d2b3f365 2716# define STRUCT_SV perl_sv
b8d3c5db
JH
2717#else
2718# define STRUCT_SV sv
2719#endif
2720typedef struct STRUCT_SV SV;
79072805
LW
2721typedef struct av AV;
2722typedef struct hv HV;
2723typedef struct cv CV;
d2f13c59 2724typedef struct p5rx REGEXP;
79072805 2725typedef struct gp GP;
0c30d9ec 2726typedef struct gv GV;
8990e307 2727typedef struct io IO;
c09156bb 2728typedef struct context PERL_CONTEXT;
79072805
LW
2729typedef struct block BLOCK;
2730
2731typedef struct magic MAGIC;
2732typedef struct xpv XPV;
2733typedef struct xpviv XPVIV;
ff68c719 2734typedef struct xpvuv XPVUV;
79072805
LW
2735typedef struct xpvnv XPVNV;
2736typedef struct xpvmg XPVMG;
2737typedef struct xpvlv XPVLV;
d361b004 2738typedef struct xpvinvlist XINVLIST;
79072805
LW
2739typedef struct xpvav XPVAV;
2740typedef struct xpvhv XPVHV;
2741typedef struct xpvgv XPVGV;
2742typedef struct xpvcv XPVCV;
2743typedef struct xpvbm XPVBM;
2744typedef struct xpvfm XPVFM;
8990e307 2745typedef struct xpvio XPVIO;
79072805
LW
2746typedef struct mgvtbl MGVTBL;
2747typedef union any ANY;
5f7fde29
GS
2748typedef struct ptr_tbl_ent PTR_TBL_ENT_t;
2749typedef struct ptr_tbl PTR_TBL_t;
8cf8f3d1
NIS
2750typedef struct clone_params CLONE_PARAMS;
2751
0f94cb1f 2752/* a pad is currently just an AV; but that might change,
7261499d
FC
2753 * so hide the type. */
2754typedef struct padlist PADLIST;
67634234 2755typedef AV PAD;
9b7476d7 2756typedef struct padnamelist PADNAMELIST;
0f94cb1f 2757typedef struct padname PADNAME;
67634234 2758
5a736967
DM
2759/* always enable PERL_OP_PARENT */
2760#if !defined(PERL_OP_PARENT)
5d32d268
DM
2761# define PERL_OP_PARENT
2762#endif
2763
93c10d60
FC
2764/* enable PERL_COPY_ON_WRITE by default */
2765#if !defined(PERL_COPY_ON_WRITE) && !defined(PERL_NO_COW)
2766# define PERL_COPY_ON_WRITE
13b0f67d 2767#endif
07d01d6e 2768
93c10d60 2769#ifdef PERL_COPY_ON_WRITE
db2c6cb3 2770# define PERL_ANY_COW
9f351b45
DM
2771#else
2772# define PERL_SAWAMPERSAND
db2c6cb3
FC
2773#endif
2774
40653c20
FC
2775#if defined(PERL_DEBUG_READONLY_OPS) && !defined(USE_ITHREADS)
2776# error PERL_DEBUG_READONLY_OPS only works with ithreads
2777#endif
2778
378cc40b 2779#include "handy.h"
64935bc6 2780#include "charclass_invlists.h"
a0d0e21e 2781
6b8eaf93 2782#if defined(USE_LARGE_FILES) && !defined(NO_64_BIT_RAWIO)
6b8eaf93
JH
2783# if LSEEKSIZE == 8 && !defined(USE_64_BIT_RAWIO)
2784# define USE_64_BIT_RAWIO /* implicit */
2785# endif
4564133c
JH
2786#endif
2787
6b8eaf93
JH
2788/* Notice the use of HAS_FSEEKO: now we are obligated to always use
2789 * fseeko/ftello if possible. Don't go #defining ftell to ftello yourself,
2790 * however, because operating systems like to do that themself. */
2791#ifndef FSEEKSIZE
2792# ifdef HAS_FSEEKO
2793# define FSEEKSIZE LSEEKSIZE
2794# else
2795# define FSEEKSIZE LONGSIZE
d460ef45 2796# endif
6b8eaf93
JH
2797#endif
2798
2799#if defined(USE_LARGE_FILES) && !defined(NO_64_BIT_STDIO)
6b8eaf93
JH
2800# if FSEEKSIZE == 8 && !defined(USE_64_BIT_STDIO)
2801# define USE_64_BIT_STDIO /* implicit */
2802# endif
2803#endif
4564133c 2804
09458382 2805#ifdef USE_64_BIT_RAWIO
d9b3e12d
JH
2806# ifdef HAS_OFF64_T
2807# undef Off_t
2808# define Off_t off64_t
2809# undef LSEEKSIZE
2810# define LSEEKSIZE 8
5ff3f7a4 2811# endif
d9b3e12d
JH
2812/* Most 64-bit environments have defines like _LARGEFILE_SOURCE that
2813 * will trigger defines like the ones below. Some 64-bit environments,
09458382 2814 * however, do not. Therefore we have to explicitly mix and match. */
d9b3e12d
JH
2815# if defined(USE_OPEN64)
2816# define open open64
5ff3f7a4 2817# endif
d9b3e12d
JH
2818# if defined(USE_LSEEK64)
2819# define lseek lseek64
6b8eaf93
JH
2820# else
2821# if defined(USE_LLSEEK)
2822# define lseek llseek
2823# endif
d9b3e12d
JH
2824# endif
2825# if defined(USE_STAT64)
2826# define stat stat64
2827# endif
2828# if defined(USE_FSTAT64)
2829# define fstat fstat64
2830# endif
2831# if defined(USE_LSTAT64)
2832# define lstat lstat64
2833# endif
2834# if defined(USE_FLOCK64)
2835# define flock flock64
2836# endif
2837# if defined(USE_LOCKF64)
2838# define lockf lockf64
2839# endif
2840# if defined(USE_FCNTL64)
2841# define fcntl fcntl64
2842# endif
2843# if defined(USE_TRUNCATE64)
2844# define truncate truncate64
2845# endif
2846# if defined(USE_FTRUNCATE64)
2847# define ftruncate ftruncate64
2848# endif
2849#endif
2850
2851#ifdef USE_64_BIT_STDIO
2852# ifdef HAS_FPOS64_T
2853# undef Fpos_t
2854# define Fpos_t fpos64_t
2855# endif
2856/* Most 64-bit environments have defines like _LARGEFILE_SOURCE that
2857 * will trigger defines like the ones below. Some 64-bit environments,
2858 * however, do not. */
2859# if defined(USE_FOPEN64)
2860# define fopen fopen64
2861# endif
2862# if defined(USE_FSEEK64)
6b8eaf93 2863# define fseek fseek64 /* don't do fseeko here, see perlio.c */
d9b3e12d
JH
2864# endif
2865# if defined(USE_FTELL64)
6b8eaf93 2866# define ftell ftell64 /* don't do ftello here, see perlio.c */
d9b3e12d
JH
2867# endif
2868# if defined(USE_FSETPOS64)
2869# define fsetpos fsetpos64
2870# endif
2871# if defined(USE_FGETPOS64)
2872# define fgetpos fgetpos64
2873# endif
2874# if defined(USE_TMPFILE64)
2875# define tmpfile tmpfile64
2876# endif
2877# if defined(USE_FREOPEN64)
2878# define freopen freopen64
5ff3f7a4
GS
2879# endif
2880#endif
2881
e37778c2 2882#if defined(OS2)
2c2d71f5
JH
2883# include "iperlsys.h"
2884#endif
2885
748a9306 2886#ifdef DOSISH
19848b3f
JH
2887# if defined(OS2)
2888# include "os2ish.h"
2889# else
2890# include "dosish.h"
2891# endif
009819bb 2892#elif defined(VMS)
748a9306 2893# include "vmsish.h"
009819bb 2894#elif defined(PLAN9)
19848b3f 2895# include "./plan9/plan9ish.h"
009819bb 2896#elif defined(__VOS__)
196918b0
PG
2897# ifdef __GNUC__
2898# include "./vos/vosish.h"
2899# else
2900# include "vos/vosish.h"
2901# endif
009819bb 2902#elif defined(__HAIKU__)
df00ff3b 2903# include "haiku/haikuish.h"
009819bb 2904#else
19848b3f 2905# include "unixish.h"
13b6e58c
JH
2906#endif
2907
ea34f6bd 2908#ifdef __amigaos4__
3c0208ad
AB
2909# include "amigaos.h"
2910# undef FD_CLOEXEC /* a lie in AmigaOS */
2911#endif
2912
2946a158 2913/* NSIG logic from Configure --> */
2946a158
JH
2914#ifndef NSIG
2915# ifdef _NSIG
2916# define NSIG (_NSIG)
da5fdda8 2917# elif defined(SIGMAX)
2946a158 2918# define NSIG (SIGMAX+1)
da5fdda8 2919# elif defined(SIG_MAX)
2946a158 2920# define NSIG (SIG_MAX+1)
da5fdda8 2921# elif defined(_SIG_MAX)
2946a158 2922# define NSIG (_SIG_MAX+1)
da5fdda8 2923# elif defined(MAXSIG)
2946a158 2924# define NSIG (MAXSIG+1)
da5fdda8 2925# elif defined(MAX_SIG)
2946a158 2926# define NSIG (MAX_SIG+1)
da5fdda8 2927# elif defined(SIGARRAYSIZE)
2946a158 2928# define NSIG SIGARRAYSIZE /* Assume ary[SIGARRAYSIZE] */
da5fdda8 2929# elif defined(_sys_nsig)
2946a158 2930# define NSIG (_sys_nsig) /* Solaris 2.5 */
da5fdda8
AC
2931# else
2932 /* Default to some arbitrary number that's big enough to get most
2933 * of the common signals. */
2946a158 2934# define NSIG 50
da5fdda8 2935# endif
2946a158
JH
2936#endif
2937/* <-- NSIG logic from Configure */
2938
13b6e58c
JH
2939#ifndef NO_ENVIRON_ARRAY
2940# define USE_ENVIRON_ARRAY
2941#endif
32f822de 2942
2bc5f86a
KW
2943#ifdef USE_ITHREADS
2944 /* On some platforms it would be safe to use a read/write mutex with many
2945 * readers possible at the same time. On other platforms, notably IBM ones,
2946 * subsequent getenv calls destroy earlier ones. Those platforms would not
2947 * be able to handle simultaneous getenv calls */
2948# define ENV_LOCK MUTEX_LOCK(&PL_env_mutex)
2949# define ENV_UNLOCK MUTEX_UNLOCK(&PL_env_mutex)
2950# define ENV_INIT MUTEX_INIT(&PL_env_mutex);
2951# define ENV_TERM MUTEX_DESTROY(&PL_env_mutex);
2952#else
2953# define ENV_LOCK NOOP;
2954# define ENV_UNLOCK NOOP;
2955# define ENV_INIT NOOP;
2956# define ENV_TERM NOOP;
2957#endif
e7124897 2958
80c27f77
KW
2959/* Some critical sections need to lock both the locale and the environment.
2960 * XXX khw intends to change this to lock both mutexes, but that brings up
2961 * issues of potential deadlock, so should be done at the beginning of a
2962 * development cycle. So for now, it just locks the environment. Note that
2963 * many modern platforms are locale-thread-safe anyway, so locking the locale
2964 * mutex is a no-op anyway */
2965#define ENV_LOCALE_LOCK ENV_LOCK
2966#define ENV_LOCALE_UNLOCK ENV_UNLOCK
2967
2968/* And some critical sections care only that no one else is writing either the
2969 * locale nor the environment. XXX Again this is for the future. This can be
2970 * simulated with using COND_WAIT in thread.h */
2971#define ENV_LOCALE_READ_LOCK ENV_LOCALE_LOCK
2972#define ENV_LOCALE_READ_UNLOCK ENV_LOCALE_UNLOCK
2973
5e7940ce 2974#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
c99d8cd6
DM
2975 /* having sigaction(2) means that the OS supports both 1-arg and 3-arg
2976 * signal handlers. But the perl core itself only fully supports 1-arg
2977 * handlers, so don't enable for now.
2978 * NB: POSIX::sigaction() supports both.
2979 *
2980 * # define PERL_USE_3ARG_SIGHANDLER
2981 */
5e7940ce
DM
2982#endif
2983
e7124897
DM
2984/* Siginfo_t:
2985 * This is an alias for the OS's siginfo_t, except that where the OS
2986 * doesn't support it, declare a dummy version instead. This allows us to
2987 * have signal handler functions which always have a Siginfo_t parameter
2988 * regardless of platform, (and which will just be passed a NULL value
2989 * where the OS doesn't support HAS_SIGACTION).
2990 */
2991
2992#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2993 typedef siginfo_t Siginfo_t;
2994#else
3555a05c
LT
2995#ifdef si_signo /* minix */
2996#undef si_signo
2997#endif
e7124897
DM
2998 typedef struct {
2999 int si_signo;
3000 } Siginfo_t;
3001#endif
3002
3003
c77b533b
JH
3004/*
3005 * initialise to avoid floating-point exceptions from overflow, etc
3006 */
3007#ifndef PERL_FPU_INIT
3008# ifdef HAS_FPSETMASK
3009# if HAS_FLOATINGPOINT_H
3010# include <floatingpoint.h>
3011# endif
ad3a8c67
NC
3012/* Some operating systems have this as a macro, which in turn expands to a comma
3013 expression, and the last sub-expression is something that gets calculated,
3014 and then they have the gall to warn that a value computed is not used. Hence
3015 cast to void. */
3016# define PERL_FPU_INIT (void)fpsetmask(0)
da5fdda8
AC
3017# elif defined(SIGFPE) && defined(SIG_IGN) && !defined(PERL_MICRO)
3018# define PERL_FPU_INIT PL_sigfpe_saved = (Sighandler_t) signal(SIGFPE, SIG_IGN)
3019# define PERL_FPU_PRE_EXEC { Sigsave_t xfpe; rsignal_save(SIGFPE, PL_sigfpe_saved, &xfpe);
3020# define PERL_FPU_POST_EXEC rsignal_restore(SIGFPE, &xfpe); }
c77b533b 3021# else
da5fdda8 3022# define PERL_FPU_INIT
c77b533b
JH
3023# endif
3024#endif
b35112e7
CS
3025#ifndef PERL_FPU_PRE_EXEC
3026# define PERL_FPU_PRE_EXEC {
3027# define PERL_FPU_POST_EXEC }
3028#endif
c77b533b 3029
a308b05a
JH
3030/* In Tru64 the cc -ieee enables the IEEE math but disables traps.
3031 * We need to reenable the "invalid" trap because otherwise generation
3032 * of NaN values leaves the IEEE fp flags in bad state, leaving any further
3033 * fp ops behaving strangely (Inf + 1 resulting in zero, for example). */
3034#ifdef __osf__
3035# include <machine/fpu.h>
3036# define PERL_SYS_FPU_INIT \
3037 STMT_START { \
3038 ieee_set_fp_control(IEEE_TRAP_ENABLE_INV); \
3039 signal(SIGFPE, SIG_IGN); \
3040 } STMT_END
3041#endif
94a08944
JH
3042/* In IRIX the default for Flush to Zero bit is true,
3043 * which means that results going below the minimum of normal
3044 * floating points go to zero, instead of going denormal/subnormal.
3045 * This is unlike almost any other system running Perl, so let's clear it.
3046 * [perl #123767] IRIX64 blead (ddce084a) opbasic/arith.t failure, originally
3047 * [perl #120426] small numbers shouldn't round to zero if they have extra floating digits
3048 *
3049 * XXX The flush-to-zero behaviour should be a Configure scan.
3050 * To change the behaviour usually requires some system-specific
3051 * incantation, though, like the below. */
3052#ifdef __sgi
3053# include <sys/fpu.h>
3054# define PERL_SYS_FPU_INIT \
3055 STMT_START { \
3056 union fpc_csr csr; \
3057 csr.fc_word = get_fpc_csr(); \
3058 csr.fc_struct.flush = 0; \
3059 set_fpc_csr(csr.fc_word); \
3060 } STMT_END
3061#endif
a308b05a
JH
3062
3063#ifndef PERL_SYS_FPU_INIT
3064# define PERL_SYS_FPU_INIT NOOP
3065#endif
3066
cbec8ebe
DM
3067#ifndef PERL_SYS_INIT3_BODY
3068# define PERL_SYS_INIT3_BODY(argvp,argcp,envp) PERL_SYS_INIT_BODY(argvp,argcp)
ed344e4f
IZ
3069#endif
3070
eb533572 3071/*
51b56f5c 3072=for apidoc_section Embedding and Interpreter Cloning
dcccc8ff 3073
4ad9e498 3074=for apidoc Am|void|PERL_SYS_INIT|int *argc|char*** argv
eb533572 3075Provides system-specific tune up of the C runtime environment necessary to
72d33970 3076run Perl interpreters. This should be called only once, before creating
eb533572
DM
3077any Perl interpreters.
3078
4ad9e498 3079=for apidoc Am|void|PERL_SYS_INIT3|int *argc|char*** argv|char*** env
eb533572 3080Provides system-specific tune up of the C runtime environment necessary to
72d33970 3081run Perl interpreters. This should be called only once, before creating
eb533572
DM
3082any Perl interpreters.
3083
3084=for apidoc Am|void|PERL_SYS_TERM|
3085Provides system-specific clean up of the C runtime environment after
72d33970 3086running Perl interpreters. This should be called only once, after
eb533572
DM
3087freeing any remaining Perl interpreters.
3088
3089=cut
3090 */
3091
cbec8ebe
DM
3092#define PERL_SYS_INIT(argc, argv) Perl_sys_init(argc, argv)
3093#define PERL_SYS_INIT3(argc, argv, env) Perl_sys_init3(argc, argv, env)
d0820ef1 3094#define PERL_SYS_TERM() Perl_sys_term()
cbec8ebe 3095
be708cc0
JH
3096#ifndef PERL_WRITE_MSG_TO_CONSOLE
3097# define PERL_WRITE_MSG_TO_CONSOLE(io, msg, len) PerlIO_write(io, msg, len)
3098#endif
3099
0f31cffe
GS
3100#ifndef MAXPATHLEN
3101# ifdef PATH_MAX
b990c8b2
JH
3102# ifdef _POSIX_PATH_MAX
3103# if PATH_MAX > _POSIX_PATH_MAX
09448d78
JH
3104/* POSIX 1990 (and pre) was ambiguous about whether PATH_MAX
3105 * included the null byte or not. Later amendments of POSIX,
3106 * XPG4, the Austin Group, and the Single UNIX Specification
3107 * all explicitly include the null byte in the PATH_MAX.
3108 * Ditto for _POSIX_PATH_MAX. */
3109# define MAXPATHLEN PATH_MAX
b990c8b2 3110# else
09448d78 3111# define MAXPATHLEN _POSIX_PATH_MAX
b990c8b2
JH
3112# endif
3113# else
3114# define MAXPATHLEN (PATH_MAX+1)
3115# endif
0f31cffe 3116# else
d552bce8 3117# define MAXPATHLEN 1024 /* Err on the large side. */
0f31cffe
GS
3118# endif
3119#endif
3120
3baee7cc
JH
3121/* clang Thread Safety Analysis/Annotations/Attributes
3122 * http://clang.llvm.org/docs/ThreadSafetyAnalysis.html
3123 *
bdc795f4 3124 * Available since clang 3.6-ish (appeared in 3.4, but shaky still in 3.5).
3baee7cc 3125 * Apple XCode hijacks __clang_major__ and __clang_minor__
bdc795f4
JH
3126 * (6.1 means really clang 3.6), so needs extra hijinks
3127 * (could probably also test the contents of __apple_build_version__).
3baee7cc
JH
3128 */
3129#if defined(USE_ITHREADS) && defined(I_PTHREAD) && \
3130 defined(__clang__) && \
3131 !defined(SWIG) && \
3132 ((!defined(__apple_build_version__) && \
bdc795f4 3133 ((__clang_major__ == 3 && __clang_minor__ >= 6) || \
8412ccf9 3134 (__clang_major__ >= 4))) || \
3baee7cc 3135 (defined(__apple_build_version__) && \
bdc795f4
JH
3136 ((__clang_major__ == 6 && __clang_minor__ >= 1) || \
3137 (__clang_major__ >= 7))))
3baee7cc
JH
3138# define PERL_TSA__(x) __attribute__((x))
3139# define PERL_TSA_ACTIVE
3140#else
3141# define PERL_TSA__(x) /* No TSA, make TSA attributes no-ops. */
3142# undef PERL_TSA_ACTIVE
3143#endif
3144
3145/* PERL_TSA_CAPABILITY() is used to annotate typedefs.
3146 * typedef old_type PERL_TSA_CAPABILITY("mutex") new_type;
3147 */
3148#define PERL_TSA_CAPABILITY(x) \
3149 PERL_TSA__(capability(x))
3150
3151/* In the below examples the mutex must be lexically visible, usually
3152 * either as global variables, or as function arguments. */
3153
3154/* PERL_TSA_GUARDED_BY() is used to annotate global variables.
3155 *
3156 * Foo foo PERL_TSA_GUARDED_BY(mutex);
3157 */
3158#define PERL_TSA_GUARDED_BY(x) \
3159 PERL_TSA__(guarded_by(x))
3160
3161/* PERL_TSA_PT_GUARDED_BY() is used to annotate global pointers.
3162 * The data _behind_ the pointer is guarded.
3163 *
3164 * Foo* ptr PERL_TSA_PT_GUARDED_BY(mutex);
3165 */
3166#define PERL_TSA_PT_GUARDED_BY(x) \
3167 PERL_TSA__(pt_guarded_by(x))
3168
3169/* PERL_TSA_REQUIRES() is used to annotate functions.
3170 * The caller MUST hold the resource when calling the function.
3171 *
3172 * void Foo() PERL_TSA_REQUIRES(mutex);
3173 */
3174#define PERL_TSA_REQUIRES(x) \
3175 PERL_TSA__(requires_capability(x))
3176
3177/* PERL_TSA_EXCLUDES() is used to annotate functions.
3178 * The caller MUST NOT hold resource when calling the function.
3179 *
3180 * EXCLUDES should be used when the function first acquires
3181 * the resource and then releases it. Use to avoid deadlock.
3182 *
3183 * void Foo() PERL_TSA_EXCLUDES(mutex);
3184 */
3185#define PERL_TSA_EXCLUDES(x) \
3186 PERL_TSA__(locks_excluded(x))
3187
3188/* PERL_TSA_ACQUIRE() is used to annotate functions.
3189 * The caller MUST NOT hold the resource when calling the function,
3190 * and the function will acquire the resource.
3191 *
3192 * void Foo() PERL_TSA_ACQUIRE(mutex);
3193 */
3194#define PERL_TSA_ACQUIRE(x) \
3195 PERL_TSA__(acquire_capability(x))
3196
3197/* PERL_TSA_RELEASE() is used to annotate functions.
3198 * The caller MUST hold the resource when calling the function,
3199 * and the function will release the resource.
3200 *
3201 * void Foo() PERL_TSA_RELEASE(mutex);
3202 */
3203#define PERL_TSA_RELEASE(x) \
3204 PERL_TSA__(release_capability(x))
3205
3206/* PERL_TSA_NO_TSA is used to annotate functions.
3207 * Used when being intentionally unsafe, or when the code is too
3208 * complicated for the analysis. Use sparingly.
3209 *
3210 * void Foo() PERL_TSA_NO_TSA;
3211 */
3212#define PERL_TSA_NO_TSA \
3213 PERL_TSA__(no_thread_safety_analysis)
3214
3215/* There are more annotations/attributes available, see the clang
3216 * documentation for details. */
3217
3db8f154 3218#if defined(USE_ITHREADS)
2986a63f 3219# ifdef NETWARE
da5fdda8
AC
3220# include <nw5thread.h>
3221# elif defined(WIN32)
3222# include <win32thread.h>
3223# elif defined(OS2)
3224# include "os2thread.h"
3225# elif defined(I_MACH_CTHREADS)
3226# include <mach/cthreads.h>
7f3d1cf1
BH
3227typedef cthread_t perl_os_thread;
3228typedef mutex_t perl_mutex;
3229typedef condition_t perl_cond;
3230typedef void * perl_key;
da5fdda8
AC
3231# elif defined(I_PTHREAD) /* Posix threads */
3232# include <pthread.h>
7f3d1cf1 3233typedef pthread_t perl_os_thread;
3baee7cc 3234typedef pthread_mutex_t PERL_TSA_CAPABILITY("mutex") perl_mutex;
7f3d1cf1
BH
3235typedef pthread_cond_t perl_cond;
3236typedef pthread_key_t perl_key;
da5fdda8 3237# endif
3db8f154 3238#endif /* USE_ITHREADS */
c5be433b 3239
3baee7cc
JH
3240#ifdef PERL_TSA_ACTIVE
3241/* Since most pthread mutex interfaces have not been annotated, we
3242 * need to have these wrappers. The NO_TSA annotation is quite ugly
3243 * but it cannot be avoided in plain C, unlike in C++, where one could
3244 * e.g. use ACQUIRE() with no arg on a mutex lock method.
3245 *
3246 * The bodies of these wrappers are in util.c
3247 *
3248 * TODO: however, some platforms are starting to get these clang
3249 * thread safety annotations for pthreads, for example FreeBSD.
3250 * Do we need a way to a bypass these wrappers? */
67083b7b 3251EXTERN_C int perl_tsa_mutex_lock(perl_mutex* mutex)
3baee7cc
JH
3252 PERL_TSA_ACQUIRE(*mutex)
3253 PERL_TSA_NO_TSA;
67083b7b 3254EXTERN_C int perl_tsa_mutex_unlock(perl_mutex* mutex)
3baee7cc
JH
3255 PERL_TSA_RELEASE(*mutex)
3256 PERL_TSA_NO_TSA;
3257#endif
3258
66a93824 3259#if defined(WIN32)
1feb2720 3260# include "win32.h"
c5be433b
GS
3261#endif
3262
2986a63f
JH
3263#ifdef NETWARE
3264# include "netware.h"
3265#endif
3266
e5218da5 3267#define STATUS_UNIX PL_statusvalue
68dc0745 3268#ifdef VMS
6b88bc9c 3269# define STATUS_NATIVE PL_statusvalue_vms
7a7fd8e0
JM
3270/*
3271 * vaxc$errno is only guaranteed to be valid if errno == EVMSERR, otherwise
ff7298cb 3272 * its contents can not be trusted. Unfortunately, Perl seems to check
7a7fd8e0
JM
3273 * it on exit, so it when PL_statusvalue_vms is updated, vaxc$errno should
3274 * be updated also.
3275 */
3276# include <stsdef.h>
3277# include <ssdef.h>
3278/* Presume this because if VMS changes it, it will require a new
3279 * set of APIs for waiting on children for binary compatibility.
3280 */
3281# define child_offset_bits (8)
3282# ifndef C_FAC_POSIX
3283# define C_FAC_POSIX 0x35A000
3284# endif
3285
3286/* STATUS_EXIT - validates and returns a NATIVE exit status code for the
3287 * platform from the existing UNIX or Native status values.
3288 */
3289
37038d91 3290# define STATUS_EXIT \
7a7fd8e0
JM
3291 (((I32)PL_statusvalue_vms == -1 ? SS$_ABORT : PL_statusvalue_vms) | \
3292 (VMSISH_HUSHED ? STS$M_INHIB_MSG : 0))
3293
7a7fd8e0 3294
fb38d079
JM
3295/* STATUS_NATIVE_CHILD_SET - Calculate UNIX status that matches the child
3296 * exit code and shifts the UNIX value over the correct number of bits to
3297 * be a child status. Usually the number of bits is 8, but that could be
3298 * platform dependent. The NATIVE status code is presumed to have either
3299 * from a child process.
7a7fd8e0
JM
3300 */
3301
fb38d079
JM
3302/* This is complicated. The child processes return a true native VMS
3303 status which must be saved. But there is an assumption in Perl that
3304 the UNIX child status has some relationship to errno values, so
00f254e2 3305 Perl tries to translate it to text in some of the tests.
fb38d079
JM
3306 In order to get the string translation correct, for the error, errno
3307 must be EVMSERR, but that generates a different text message
3308 than what the test programs are expecting. So an errno value must
3309 be derived from the native status value when an error occurs.
3310 That will hide the true native status message. With this version of
3311 perl, the true native child status can always be retrieved so that
3312 is not a problem. But in this case, Pl_statusvalue and errno may
3313 have different values in them.
3314 */
7a7fd8e0 3315
fb38d079 3316# define STATUS_NATIVE_CHILD_SET(n) \
68dc0745 3317 STMT_START { \
2fbb330f
JM
3318 I32 evalue = (I32)n; \
3319 if (evalue == EVMSERR) { \
3320 PL_statusvalue_vms = vaxc$errno; \
3321 PL_statusvalue = evalue; \
7a7fd8e0 3322 } else { \
2fbb330f 3323 PL_statusvalue_vms = evalue; \
fb38d079 3324 if (evalue == -1) { \
3280af22 3325 PL_statusvalue = -1; \
7a7fd8e0
JM
3326 PL_statusvalue_vms = SS$_ABORT; /* Should not happen */ \
3327 } else \
fb38d079 3328 PL_statusvalue = Perl_vms_status_to_unix(evalue, 1); \
2fbb330f 3329 set_vaxc_errno(evalue); \
fb38d079
JM
3330 if ((PL_statusvalue_vms & C_FAC_POSIX) == C_FAC_POSIX) \
3331 set_errno(EVMSERR); \
3332 else set_errno(Perl_vms_status_to_unix(evalue, 0)); \
3333 PL_statusvalue = PL_statusvalue << child_offset_bits; \
2fbb330f 3334 } \
68dc0745 3335 } STMT_END
7a7fd8e0 3336
68dc0745 3337# ifdef VMSISH_STATUS
e5218da5 3338# define STATUS_CURRENT (VMSISH_STATUS ? STATUS_NATIVE : STATUS_UNIX)
68dc0745 3339# else
e5218da5 3340# define STATUS_CURRENT STATUS_UNIX
68dc0745 3341# endif
7a7fd8e0
JM
3342
3343 /* STATUS_UNIX_SET - takes a UNIX/POSIX errno value and attempts to update
3344 * the NATIVE status to an equivalent value. Can not be used to translate
3345 * exit code values as exit code values are not guaranteed to have any
3346 * relationship at all to errno values.
3347 * This is used when Perl is forcing errno to have a specific value.
3348 */
e5218da5 3349# define STATUS_UNIX_SET(n) \
68dc0745 3350 STMT_START { \
7a7fd8e0 3351 I32 evalue = (I32)n; \
0968cdad 3352 PL_statusvalue = evalue; \
3280af22 3353 if (PL_statusvalue != -1) { \
0968cdad
JM
3354 if (PL_statusvalue != EVMSERR) { \
3355 PL_statusvalue &= 0xFFFF; \
3356 if (MY_POSIX_EXIT) \
3357 PL_statusvalue_vms=PL_statusvalue ? SS$_ABORT : SS$_NORMAL;\
3358 else PL_statusvalue_vms = Perl_unix_status_to_vms(evalue); \
3359 } \
3360 else { \
3361 PL_statusvalue_vms = vaxc$errno; \
3362 } \
68dc0745 3363 } \
0968cdad
JM
3364 else PL_statusvalue_vms = SS$_ABORT; \
3365 set_vaxc_errno(PL_statusvalue_vms); \
7a7fd8e0
JM
3366 } STMT_END
3367
3368 /* STATUS_UNIX_EXIT_SET - Takes a UNIX/POSIX exit code and sets
e08e1e1d
JM
3369 * the NATIVE error status based on it.
3370 *
3371 * When in the default mode to comply with the Perl VMS documentation,
3372 * 0 is a success and any other code sets the NATIVE status to a failure
3373 * code of SS$_ABORT.
fb38d079
JM
3374 *
3375 * In the new POSIX EXIT mode, native status will be set so that the
3376 * actual exit code will can be retrieved by the calling program or
3377 * shell.
3378 *
3379 * If the exit code is not clearly a UNIX parent or child exit status,
3380 * it will be passed through as a VMS status.
7a7fd8e0
JM
3381 */
3382
fb38d079 3383# define STATUS_UNIX_EXIT_SET(n) \
7a7fd8e0
JM
3384 STMT_START { \
3385 I32 evalue = (I32)n; \
3386 PL_statusvalue = evalue; \
e08e1e1d
JM
3387 if (MY_POSIX_EXIT) { \
3388 if (evalue <= 0xFF00) { \
3389 if (evalue > 0xFF) \
3390 evalue = (evalue >> child_offset_bits) & 0xFF; \
3391 PL_statusvalue_vms = \
3392 (C_FAC_POSIX | (evalue << 3 ) | \
3393 ((evalue == 1) ? (STS$K_ERROR | STS$M_INHIB_MSG) : 1)); \
3394 } else /* forgive them Perl, for they have sinned */ \
3395 PL_statusvalue_vms = evalue; \
3396 } else { \
3397 if (evalue == 0) \
3398 PL_statusvalue_vms = SS$_NORMAL; \
3399 else if (evalue <= 0xFF00) \
3400 PL_statusvalue_vms = SS$_ABORT; \
3401 else { /* forgive them Perl, for they have sinned */ \
3402 if (evalue != EVMSERR) PL_statusvalue_vms = evalue; \
3403 else PL_statusvalue_vms = vaxc$errno; \
3404 /* And obviously used a VMS status value instead of UNIX */ \
3405 PL_statusvalue = EVMSERR; \
3406 } \
3407 set_vaxc_errno(PL_statusvalue_vms); \
3408 } \
68dc0745 3409 } STMT_END
fb38d079 3410
e08e1e1d 3411
6ac6a52b
JM
3412 /* STATUS_EXIT_SET - Takes a NATIVE/UNIX/POSIX exit code
3413 * and sets the NATIVE error status based on it. This special case
3414 * is needed to maintain compatibility with past VMS behavior.
3415 *
3416 * In the default mode on VMS, this number is passed through as
3417 * both the NATIVE and UNIX status. Which makes it different
3418 * that the STATUS_UNIX_EXIT_SET.
3419 *
3420 * In the new POSIX EXIT mode, native status will be set so that the
3421 * actual exit code will can be retrieved by the calling program or
3422 * shell.
3423 *
1a3aec58
JM
3424 * A POSIX exit code is from 0 to 255. If the exit code is higher
3425 * than this, it needs to be assumed that it is a VMS exit code and
3426 * passed through.
6ac6a52b
JM
3427 */
3428
3429# define STATUS_EXIT_SET(n) \
3430 STMT_START { \
3431 I32 evalue = (I32)n; \
3432 PL_statusvalue = evalue; \
3433 if (MY_POSIX_EXIT) \
1a3aec58
JM
3434 if (evalue > 255) PL_statusvalue_vms = evalue; else { \
3435 PL_statusvalue_vms = \
3436 (C_FAC_POSIX | (evalue << 3 ) | \
3437 ((evalue == 1) ? (STS$K_ERROR | STS$M_INHIB_MSG) : 1));} \
6ac6a52b
JM
3438 else \
3439 PL_statusvalue_vms = evalue ? evalue : SS$_NORMAL; \
3440 set_vaxc_errno(PL_statusvalue_vms); \
3441 } STMT_END
3442
fb38d079
JM
3443
3444 /* This macro forces a success status */
7a7fd8e0
JM
3445# define STATUS_ALL_SUCCESS \
3446 (PL_statusvalue = 0, PL_statusvalue_vms = SS$_NORMAL)
fb38d079
JM
3447
3448 /* This macro forces a failure status */
7a7fd8e0
JM
3449# define STATUS_ALL_FAILURE (PL_statusvalue = 1, \
3450 vaxc$errno = PL_statusvalue_vms = MY_POSIX_EXIT ? \
3451 (C_FAC_POSIX | (1 << 3) | STS$K_ERROR | STS$M_INHIB_MSG) : SS$_ABORT)
fb38d079 3452
738ab09f
AB
3453#elif defined(__amigaos4__)
3454 /* A somewhat experimental attempt to simulate posix return code values */
3455# define STATUS_NATIVE PL_statusvalue_posix
3456# define STATUS_NATIVE_CHILD_SET(n) \
3457 STMT_START { \
3458 PL_statusvalue_posix = (n); \
3459 if (PL_statusvalue_posix < 0) { \
3460 PL_statusvalue = -1; \
3461 } \
3462 else { \
3463 PL_statusvalue = n << 8; \
3464 } \
3465 } STMT_END
3466# define STATUS_UNIX_SET(n) \
3467 STMT_START { \
3468 PL_statusvalue = (n); \
3469 if (PL_statusvalue != -1) \
3470 PL_statusvalue &= 0xFFFF; \
3471 } STMT_END
3472# define STATUS_UNIX_EXIT_SET(n) STATUS_UNIX_SET(n)
3473# define STATUS_EXIT_SET(n) STATUS_UNIX_SET(n)
3474# define STATUS_CURRENT STATUS_UNIX
3475# define STATUS_EXIT STATUS_UNIX
3476# define STATUS_ALL_SUCCESS (PL_statusvalue = 0, PL_statusvalue_posix = 0)
3477# define STATUS_ALL_FAILURE (PL_statusvalue = 1, PL_statusvalue_posix = 1)
3478
68dc0745 3479#else
e5218da5 3480# define STATUS_NATIVE PL_statusvalue_posix
e5218da5 3481# if defined(WCOREDUMP)
37038d91 3482# define STATUS_NATIVE_CHILD_SET(n) \
e5218da5
GA
3483 STMT_START { \
3484 PL_statusvalue_posix = (n); \
3485 if (PL_statusvalue_posix == -1) \
3486 PL_statusvalue = -1; \
3487 else { \
3488 PL_statusvalue = \
3489 (WIFEXITED(PL_statusvalue_posix) ? (WEXITSTATUS(PL_statusvalue_posix) << 8) : 0) | \
3490 (WIFSIGNALED(PL_statusvalue_posix) ? (WTERMSIG(PL_statusvalue_posix) & 0x7F) : 0) | \
3491 (WIFSIGNALED(PL_statusvalue_posix) && WCOREDUMP(PL_statusvalue_posix) ? 0x80 : 0); \
3492 } \
3493 } STMT_END
3494# elif defined(WIFEXITED)
37038d91 3495# define STATUS_NATIVE_CHILD_SET(n) \
e5218da5
GA
3496 STMT_START { \
3497 PL_statusvalue_posix = (n); \
3498 if (PL_statusvalue_posix == -1) \
3499 PL_statusvalue = -1; \
3500 else { \
3501 PL_statusvalue = \
3502 (WIFEXITED(PL_statusvalue_posix) ? (WEXITSTATUS(PL_statusvalue_posix) << 8) : 0) | \
3503 (WIFSIGNALED(PL_statusvalue_posix) ? (WTERMSIG(PL_statusvalue_posix) & 0x7F) : 0); \
3504 } \
3505 } STMT_END
3506# else
37038d91 3507# define STATUS_NATIVE_CHILD_SET(n) \
e5218da5
GA
3508 STMT_START { \
3509 PL_statusvalue_posix = (n); \
3510 if (PL_statusvalue_posix == -1) \
3511 PL_statusvalue = -1; \
3512 else { \
3513 PL_statusvalue = \
3514 PL_statusvalue_posix & 0xFFFF; \
3515 } \
3516 } STMT_END
3517# endif
3518# define STATUS_UNIX_SET(n) \
68dc0745 3519 STMT_START { \
3280af22
NIS
3520 PL_statusvalue = (n); \
3521 if (PL_statusvalue != -1) \
3522 PL_statusvalue &= 0xFFFF; \
68dc0745 3523 } STMT_END
7a7fd8e0 3524# define STATUS_UNIX_EXIT_SET(n) STATUS_UNIX_SET(n)
6ac6a52b 3525# define STATUS_EXIT_SET(n) STATUS_UNIX_SET(n)
e5218da5 3526# define STATUS_CURRENT STATUS_UNIX
37038d91 3527# define STATUS_EXIT STATUS_UNIX
e5218da5
GA
3528# define STATUS_ALL_SUCCESS (PL_statusvalue = 0, PL_statusvalue_posix = 0)
3529# define STATUS_ALL_FAILURE (PL_statusvalue = 1, PL_statusvalue_posix = 1)
68dc0745
PP
3530#endif
3531
cc3604b1
GS
3532/* flags in PL_exit_flags for nature of exit() */
3533#define PERL_EXIT_EXPECTED 0x01
31d77e54 3534#define PERL_EXIT_DESTRUCT_END 0x02 /* Run END in perl_destruct */
6136213b
JGM
3535#define PERL_EXIT_WARN 0x04 /* Warn if Perl_my_exit() or Perl_my_failure_exit() called */
3536#define PERL_EXIT_ABORT 0x08 /* Call abort() if Perl_my_exit() or Perl_my_failure_exit() called */
cc3604b1 3537
b79b76e0 3538#ifndef PERL_CORE
a7cb1f99 3539/* format to use for version numbers in file/directory names */
273cf8d1 3540/* XXX move to Configure? */
b79b76e0
NC
3541/* This was only ever used for the current version, and that can be done at
3542 compile time, as PERL_FS_VERSION, so should we just delete it? */
3543# ifndef PERL_FS_VER_FMT
3544# define PERL_FS_VER_FMT "%d.%d.%d"
3545# endif
3546#endif
3547
3548#ifndef PERL_FS_VERSION
3549# define PERL_FS_VERSION PERL_VERSION_STRING
0b94c7bb
GS
3550#endif
3551
45bc9206 3552/* This defines a way to flush all output buffers. This may be a
76549fef
JH
3553 * performance issue, so we allow people to disable it. Also, if
3554 * we are using stdio, there are broken implementations of fflush(NULL)
3555 * out there, Solaris being the most prominent.
45bc9206
GS
3556 */
3557#ifndef PERL_FLUSHALL_FOR_CHILD
97cb92d6 3558# if defined(USE_PERLIO) || defined(FFLUSH_NULL)
66fe083f 3559# define PERL_FLUSHALL_FOR_CHILD PerlIO_flush((PerlIO*)NULL)
da5fdda8
AC
3560# elif defined(FFLUSH_ALL)
3561# define PERL_FLUSHALL_FOR_CHILD my_fflush_all()
767df6a1 3562# else
da5fdda8 3563# define PERL_FLUSHALL_FOR_CHILD NOOP
66fe083f 3564# endif
45bc9206
GS
3565#endif
3566
7766f137
GS
3567#ifndef PERL_WAIT_FOR_CHILDREN
3568# define PERL_WAIT_FOR_CHILDREN NOOP
3569#endif
3570
ba869deb 3571/* the traditional thread-unsafe notion of "current interpreter". */
c5be433b
GS
3572#ifndef PERL_SET_INTERP
3573# define PERL_SET_INTERP(i) (PL_curinterp = (PerlInterpreter*)(i))
3574#endif
3575
3576#ifndef PERL_GET_INTERP
3577# define PERL_GET_INTERP (PL_curinterp)
3578#endif
3579
54aff467 3580#if defined(PERL_IMPLICIT_CONTEXT) && !defined(PERL_GET_THX)
54aff467 3581# ifdef MULTIPLICITY
ba869deb 3582# define PERL_GET_THX ((PerlInterpreter *)PERL_GET_CONTEXT)
54aff467 3583# endif
ba869deb
GS
3584# define PERL_SET_THX(t) PERL_SET_CONTEXT(t)
3585#endif
3586
00f254e2 3587/*
8896765a 3588 This replaces the previous %_ "hack" by the "%p" hacks.
0dbb1585 3589 All that is required is that the perl source does not
00f254e2
KW
3590 use "%-p" or "%-<number>p" or "%<number>p" formats.
3591 These formats will still work in perl code.
486ec47a 3592 See comments in sv.c for further details.
8896765a 3593
8896765a 3594 Robin Barker 2005-07-14
f46d31f2 3595
00f254e2 3596 No longer use %1p for VDf = %vd. RMB 2007-10-19
0dbb1585 3597*/
8896765a
RB
3598
3599#ifndef SVf_
63ce7bf0 3600# define SVf_(n) "-" STRINGIFY(n) "p"
894356b3
GS
3601#endif
3602
8896765a 3603#ifndef SVf
104abab4 3604# define SVf "-p"
d2560b70
RB
3605#endif
3606
014ead4b 3607#ifndef SVf32
8896765a 3608# define SVf32 SVf_(32)
014ead4b
RB
3609#endif
3610
3611#ifndef SVf256
8896765a
RB
3612# define SVf256 SVf_(256)
3613#endif
3614
be2597df
MHM
3615#define SVfARG(p) ((void*)(p))
3616
20023040
FC
3617#ifndef HEKf
3618# define HEKf "2p"
3619#endif
3620
b8fa5213
FC
3621/* Not ideal, but we cannot easily include a number in an already-numeric
3622 * format sequence. */
3623#ifndef HEKf256
3624# define HEKf256 "3p"
3625#endif
3626
20023040
FC
3627#define HEKfARG(p) ((void*)(p))
3628
eafff229
KW
3629/*
3630=for apidoc Amnh||UTF8f
3631=for apidoc Amh||UTF8fARG|bool is_utf8|Size_t byte_len|char *str
3632
3633=cut
3634 * %4p is a custom format
3635 */
b17a0679 3636#ifndef UTF8f
61608bb7 3637# define UTF8f "d%" UVuf "%4p"
b17a0679
FC
3638#endif
3639#define UTF8fARG(u,l,p) (int)cBOOL(u), (UV)(l), (void*)(p)
3640
0f94cb1f
FC
3641#define PNf UTF8f
3642#define PNfARG(pn) (int)1, (UV)PadnameLEN(pn), (void *)PadnamePV(pn)
0d1e9135 3643
f46d31f2 3644#ifdef PERL_CORE
486ec47a 3645/* not used; but needed for backward compatibility with XS code? - RMB */
7776bb98 3646# undef UVf
da5fdda8
AC
3647#elif !defined(UVf)
3648# define UVf UVuf
d2560b70
RB
3649#endif
3650
6ff2ec7d
AC
3651#if !defined(DEBUGGING) && !defined(NDEBUG)
3652# define NDEBUG 1
cd13e623 3653#endif
6ff2ec7d 3654#include <assert.h>
cd13e623 3655
0dbb1585
AL
3656/* For functions that are marked as __attribute__noreturn__, it's not
3657 appropriate to call return. In either case, include the lint directive.
3658 */
3659#ifdef HASATTRIBUTE_NORETURN
bc3d2941 3660# define NORETURN_FUNCTION_END NOT_REACHED;
0dbb1585 3661#else
bc3d2941 3662# define NORETURN_FUNCTION_END NOT_REACHED; return 0
abb2c242
JH
3663#endif
3664
635aebb7 3665#ifdef HAS_BUILTIN_EXPECT
b37c2d43
AL
3666# define EXPECT(expr,val) __builtin_expect(expr,val)
3667#else
3668# define EXPECT(expr,val) (expr)
3669#endif
c515c80f
KW
3670
3671/*
51b56f5c 3672=for apidoc_section Compiler directives
c515c80f
KW
3673
3674=for apidoc AmU|bool|LIKELY|const bool expr
3675
3676Returns the input unchanged, but at the same time it gives a branch prediction
3677hint to the compiler that this condition is likely to be true.
3678
3679=for apidoc AmU|bool|UNLIKELY|const bool expr
3680
3681Returns the input unchanged, but at the same time it gives a branch prediction
3682hint to the compiler that this condition is likely to be false.
3683
3684=cut
3685*/
6d5abc62
NC
3686#define LIKELY(cond) EXPECT(cBOOL(cond),TRUE)
3687#define UNLIKELY(cond) EXPECT(cBOOL(cond),FALSE)
c515c80f 3688
635aebb7
AL
3689#ifdef HAS_BUILTIN_CHOOSE_EXPR
3690/* placeholder */
3691#endif
b37c2d43 3692
a36ca6de 3693/* STATIC_ASSERT_DECL/STATIC_ASSERT_STMT are like assert(), but for compile
5074d4c5
LM
3694 time invariants. That is, their argument must be a constant expression that
3695 can be verified by the compiler. This expression can contain anything that's
3696 known to the compiler, e.g. #define constants, enums, or sizeof (...). If
3697 the expression evaluates to 0, compilation fails.
3698 Because they generate no runtime code (i.e. their use is "free"), they're
3699 always active, even under non-DEBUGGING builds.
a36ca6de 3700 STATIC_ASSERT_DECL expands to a declaration and is suitable for use at
5074d4c5
LM
3701 file scope (outside of any function).
3702 STATIC_ASSERT_STMT expands to a statement and is suitable for use inside a
3703 function.
3704*/
f223d81e
KW
3705#if (! defined(__IBMC__) || __IBMC__ >= 1210) \
3706 && (( defined(static_assert) && ( defined(_ISOC11_SOURCE) \
3707 || (__STDC_VERSION__ - 0) >= 201101L)) \
3708 || (defined(__cplusplus) && __cplusplus >= 201103L))
3709/* XXX static_assert is a macro defined in <assert.h> in C11 or a compiler
a36ca6de
LM
3710 builtin in C++11. But IBM XL C V11 does not support _Static_assert, no
3711 matter what <assert.h> says.
6d59e610 3712*/
a36ca6de 3713# define STATIC_ASSERT_DECL(COND) static_assert(COND, #COND)
6d59e610
LM
3714#else
3715/* We use a bit-field instead of an array because gcc accepts
3716 'typedef char x[n]' where n is not a compile-time constant.
3717 We want to enforce constantness.
3718*/
3719# define STATIC_ASSERT_2(COND, SUFFIX) \
3720 typedef struct { \
3721 unsigned int _static_assertion_failed_##SUFFIX : (COND) ? 1 : -1; \
3722 } _static_assertion_failed_##SUFFIX PERL_UNUSED_DECL
3723# define STATIC_ASSERT_1(COND, SUFFIX) STATIC_ASSERT_2(COND, SUFFIX)
a36ca6de 3724# define STATIC_ASSERT_DECL(COND) STATIC_ASSERT_1(COND, __LINE__)
6d59e610
LM
3725#endif
3726/* We need this wrapper even in C11 because 'case X: static_assert(...);' is an
3727 error (static_assert is a declaration, and only statements can have labels).
3728*/
21aae866 3729#define STATIC_ASSERT_STMT(COND) STMT_START { STATIC_ASSERT_DECL(COND); } STMT_END
ae103e09
DD
3730
3731#ifndef __has_builtin
3732# define __has_builtin(x) 0 /* not a clang style compiler */
3733#endif
3734
3735/* ASSUME is like assert(), but it has a benefit in a release build. It is a
3736 hint to a compiler about a statement of fact in a function call free
3737 expression, which allows the compiler to generate better machine code.
3738 In a debug build, ASSUME(x) is a synonym for assert(x). ASSUME(0) means
3739 the control path is unreachable. In a for loop, ASSUME can be used to hint
b8fda935 3740 that a loop will run at least X times. ASSUME is based off MSVC's __assume
ae103e09
DD
3741 intrinsic function, see its documents for more details.
3742*/
3743
3744#ifndef DEBUGGING
3745# if __has_builtin(__builtin_unreachable) \
d1020b40 3746 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5 || __GNUC__ > 4) /* 4.5 -> */
ae103e09
DD
3747# define ASSUME(x) ((x) ? (void) 0 : __builtin_unreachable())
3748# elif defined(_MSC_VER)
3749# define ASSUME(x) __assume(x)
3750# elif defined(__ARMCC_VERSION) /* untested */
3751# define ASSUME(x) __promise(x)
3752# else
3753/* a random compiler might define assert to its own special optimization token
3754 so pass it through to C lib as a last resort */
3755# define ASSUME(x) assert(x)
3756# endif
3757#else
3758# define ASSUME(x) assert(x)
3759#endif
3760
dbc47c6f
KW
3761#if defined(__sun) /* ASSUME() generates warnings on Solaris */
3762# define NOT_REACHED
2145f4b6
LM
3763#elif defined(DEBUGGING) && (__has_builtin(__builtin_unreachable) \
3764 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5 || __GNUC__ > 4)) /* 4.5 -> */
41bd5b11 3765# define NOT_REACHED STMT_START { ASSUME(!"UNREACHABLE"); __builtin_unreachable(); } STMT_END
dbc47c6f 3766#else
41bd5b11 3767# define NOT_REACHED ASSUME(!"UNREACHABLE")
dbc47c6f 3768#endif
ae103e09 3769