This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
SOCKS has its own USE_THREADS, based on
[perl5.git] / handy.h
CommitLineData
a0d0e21e 1/* handy.h
a687059c 2 *
3818b22b 3 * Copyright (c) 1991-2000, Larry Wall
a687059c 4 *
6e21c824
LW
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
8d063cd8 7 *
8d063cd8
LW
8 */
9
85e6fe83 10#if !defined(__STDC__)
378cc40b
LW
11#ifdef NULL
12#undef NULL
13#endif
a687059c
LW
14#ifndef I286
15# define NULL 0
16#else
17# define NULL 0L
18#endif
85e6fe83
LW
19#endif
20
378cc40b 21#define Null(type) ((type)NULL)
954c1994
GS
22
23/*
24=for apidoc AmU||Nullch
25Null character pointer.
26
27=for apidoc AmU||Nullsv
28Null SV pointer.
29
30=cut
31*/
32
8d063cd8 33#define Nullch Null(char*)
760ac839 34#define Nullfp Null(PerlIO*)
79072805 35#define Nullsv Null(SV*)
8d063cd8 36
641d3f0b
PP
37#ifdef TRUE
38#undef TRUE
39#endif
40#ifdef FALSE
41#undef FALSE
42#endif
43#define TRUE (1)
44#define FALSE (0)
45
27d4fb96
PP
46
47/* XXX Configure ought to have a test for a boolean type, if I can
48 just figure out all the headers such a test needs.
49 Andy Dougherty August 1996
50*/
8e84507e 51/* bool is built-in for g++-2.6.3 and later, which might be used
c1d22f6b
GS
52 for extensions. <_G_config.h> defines _G_HAVE_BOOL, but we can't
53 be sure _G_config.h will be included before this file. _G_config.h
8e84507e 54 also defines _G_HAVE_BOOL for both gcc and g++, but only g++
c1d22f6b
GS
55 actually has bool. Hence, _G_HAVE_BOOL is pretty useless for us.
56 g++ can be identified by __GNUG__.
57 Andy Dougherty February 2000
5d94fbed 58*/
c1d22f6b 59#ifdef __GNUG__ /* GNU g++ has bool built-in */
5d94fbed 60# ifndef HAS_BOOL
c1d22f6b 61# define HAS_BOOL 1
5d94fbed 62# endif
5d94fbed
AD
63#endif
64
641d3f0b
PP
65/* The NeXT dynamic loader headers will not build with the bool macro
66 So declare them now to clear confusion.
67*/
8f1f23e8 68#if defined(NeXT) || defined(__NeXT__)
641d3f0b
PP
69# undef FALSE
70# undef TRUE
71 typedef enum bool { FALSE = 0, TRUE = 1 } bool;
72# define ENUM_BOOL 1
73# ifndef HAS_BOOL
74# define HAS_BOOL 1
75# endif /* !HAS_BOOL */
8f1f23e8 76#endif /* NeXT || __NeXT__ */
641d3f0b 77
5d94fbed 78#ifndef HAS_BOOL
61bb5906 79# if defined(UTS) || defined(VMS)
5d94fbed
AD
80# define bool int
81# else
82# define bool char
83# endif
c1d22f6b 84# define HAS_BOOL 1
a687059c 85#endif
0d3e774c 86
27d4fb96
PP
87/* XXX A note on the perl source internal type system. The
88 original intent was that I32 be *exactly* 32 bits.
89
90 Currently, we only guarantee that I32 is *at least* 32 bits.
91 Specifically, if int is 64 bits, then so is I32. (This is the case
92 for the Cray.) This has the advantage of meshing nicely with
93 standard library calls (where we pass an I32 and the library is
94 expecting an int), but the disadvantage that an I32 is not 32 bits.
95 Andy Dougherty August 1996
24fef2a7 96
dc45a647
MB
97 There is no guarantee that there is *any* integral type with
98 exactly 32 bits. It is perfectly legal for a system to have
99 sizeof(short) == sizeof(int) == sizeof(long) == 8.
693762b4 100
dc45a647
MB
101 Similarly, there is no guarantee that I16 and U16 have exactly 16
102 bits.
693762b4 103
8e84507e
NIS
104 For dealing with issues that may arise from various 32/64-bit
105 systems, we will ask Configure to check out
8175356b 106
dc45a647
MB
107 SHORTSIZE == sizeof(short)
108 INTSIZE == sizeof(int)
109 LONGSIZE == sizeof(long)
110 LONGLONGSIZE == sizeof(long long) (if HAS_LONG_LONG)
111 PTRSIZE == sizeof(void *)
112 DOUBLESIZE == sizeof(double)
113 LONG_DOUBLESIZE == sizeof(long double) (if HAS_LONG_DOUBLE).
8175356b 114
27d4fb96
PP
115*/
116
8175356b
JH
117typedef I8TYPE I8;
118typedef U8TYPE U8;
119typedef I16TYPE I16;
120typedef U16TYPE U16;
121typedef I32TYPE I32;
122typedef U32TYPE U32;
6b8eaf93
JH
123#ifdef PERL_CORE
124# ifdef HAS_QUAD
125# if QUADKIND == QUAD_IS_INT64_T
126# include <sys/types.h>
127# ifdef I_INTTYPES /* e.g. Linux has int64_t without <inttypes.h> */
128# include <inttypes.h>
129# endif
130# endif
8175356b
JH
131typedef I64TYPE I64;
132typedef U64TYPE U64;
6b8eaf93
JH
133# endif
134#endif /* PERL_CORE */
8175356b 135
e8c95190
JH
136#ifndef UINT64_C /* usually from <inttypes.h> */
137# ifdef HAS_LONG_LONG
138# define INT64_C(c) CAT2(c,LL)
139# define UINT64_C(c) CAT2(c,ULL)
140# else
141# define INT64_C(c) ((I64TYPE)(c))
142# define UINT64_C(c) ((U64TYPE)(c))
143# endif
144#endif
145
a22e52b9
JH
146/* Mention I8SIZE, U8SIZE, I16SIZE, U16SIZE, I32SIZE, U32SIZE,
147 I64SIZE, and U64SIZE here so that metaconfig pulls them in. */
148
d8668976 149#if defined(UINT8_MAX) && defined(INT16_MAX) && defined(INT32_MAX)
5ff3f7a4 150
5ff3f7a4
GS
151/* I8_MAX and I8_MIN constants are not defined, as I8 is an ambiguous type.
152 Please search CHAR_MAX in perl.h for further details. */
153#define U8_MAX UINT8_MAX
154#define U8_MIN UINT8_MIN
155
5ff3f7a4
GS
156#define I16_MAX INT16_MAX
157#define I16_MIN INT16_MIN
158#define U16_MAX UINT16_MAX
159#define U16_MIN UINT16_MIN
160
5ff3f7a4
GS
161#define I32_MAX INT32_MAX
162#define I32_MIN INT32_MIN
163#define U32_MAX UINT32_MAX
164#define U32_MIN UINT32_MIN
165
166#else
167
5c9fa16e
KA
168/* I8_MAX and I8_MIN constants are not defined, as I8 is an ambiguous type.
169 Please search CHAR_MAX in perl.h for further details. */
27d4fb96
PP
170#define U8_MAX PERL_UCHAR_MAX
171#define U8_MIN PERL_UCHAR_MIN
79072805 172
27d4fb96
PP
173#define I16_MAX PERL_SHORT_MAX
174#define I16_MIN PERL_SHORT_MIN
175#define U16_MAX PERL_USHORT_MAX
176#define U16_MIN PERL_USHORT_MIN
79072805 177
c4f23d77 178#if LONGSIZE > 4
27d4fb96
PP
179# define I32_MAX PERL_INT_MAX
180# define I32_MIN PERL_INT_MIN
181# define U32_MAX PERL_UINT_MAX
182# define U32_MIN PERL_UINT_MIN
79072805 183#else
27d4fb96
PP
184# define I32_MAX PERL_LONG_MAX
185# define I32_MIN PERL_LONG_MIN
186# define U32_MAX PERL_ULONG_MAX
187# define U32_MIN PERL_ULONG_MIN
79072805
LW
188#endif
189
5ff3f7a4
GS
190#endif
191
fc36a67e
PP
192#define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */
193#define TYPE_DIGITS(T) BIT_DIGITS(sizeof(T) * 8)
194#define TYPE_CHARS(T) (TYPE_DIGITS(T) + 2) /* sign, NUL */
195
ff68c719 196#define Ctl(ch) ((ch) & 037)
8d063cd8 197
954c1994
GS
198/*
199=for apidoc Am|bool|strNE|char* s1|char* s2
200Test two strings to see if they are different. Returns true or
201false.
202
203=for apidoc Am|bool|strEQ|char* s1|char* s2
204Test two strings to see if they are equal. Returns true or false.
205
206=for apidoc Am|bool|strLT|char* s1|char* s2
207Test two strings to see if the first, C<s1>, is less than the second,
208C<s2>. Returns true or false.
209
210=for apidoc Am|bool|strLE|char* s1|char* s2
211Test two strings to see if the first, C<s1>, is less than or equal to the
212second, C<s2>. Returns true or false.
213
214=for apidoc Am|bool|strGT|char* s1|char* s2
215Test two strings to see if the first, C<s1>, is greater than the second,
216C<s2>. Returns true or false.
217
218=for apidoc Am|bool|strGE|char* s1|char* s2
219Test two strings to see if the first, C<s1>, is greater than or equal to
220the second, C<s2>. Returns true or false.
221
222=for apidoc Am|bool|strnNE|char* s1|char* s2|STRLEN len
223Test two strings to see if they are different. The C<len> parameter
224indicates the number of bytes to compare. Returns true or false. (A
225wrapper for C<strncmp>).
226
227=for apidoc Am|bool|strnEQ|char* s1|char* s2|STRLEN len
228Test two strings to see if they are equal. The C<len> parameter indicates
229the number of bytes to compare. Returns true or false. (A wrapper for
230C<strncmp>).
231
232=cut
233*/
234
8d063cd8
LW
235#define strNE(s1,s2) (strcmp(s1,s2))
236#define strEQ(s1,s2) (!strcmp(s1,s2))
237#define strLT(s1,s2) (strcmp(s1,s2) < 0)
238#define strLE(s1,s2) (strcmp(s1,s2) <= 0)
239#define strGT(s1,s2) (strcmp(s1,s2) > 0)
240#define strGE(s1,s2) (strcmp(s1,s2) >= 0)
241#define strnNE(s1,s2,l) (strncmp(s1,s2,l))
242#define strnEQ(s1,s2,l) (!strncmp(s1,s2,l))
378cc40b 243
36477c24
PP
244#ifdef HAS_MEMCMP
245# define memNE(s1,s2,l) (memcmp(s1,s2,l))
246# define memEQ(s1,s2,l) (!memcmp(s1,s2,l))
247#else
248# define memNE(s1,s2,l) (bcmp(s1,s2,l))
249# define memEQ(s1,s2,l) (!bcmp(s1,s2,l))
250#endif
251
bbce6d69
PP
252/*
253 * Character classes.
254 *
255 * Unfortunately, the introduction of locales means that we
256 * can't trust isupper(), etc. to tell the truth. And when
257 * it comes to /\w+/ with tainting enabled, we *must* be able
258 * to trust our character classes.
259 *
260 * Therefore, the default tests in the text of Perl will be
261 * independent of locale. Any code that wants to depend on
262 * the current locale will use the tests that begin with "lc".
263 */
264
2304df62
AD
265#ifdef HAS_SETLOCALE /* XXX Is there a better test for this? */
266# ifndef CTYPE256
267# define CTYPE256
268# endif
269#endif
270
954c1994
GS
271/*
272=for apidoc Am|bool|isALNUM|char ch
4375e838 273Returns a boolean indicating whether the C C<char> is an ASCII alphanumeric
f1cbbd6e 274character (including underscore) or digit.
954c1994
GS
275
276=for apidoc Am|bool|isALPHA|char ch
4375e838 277Returns a boolean indicating whether the C C<char> is an ASCII alphabetic
954c1994
GS
278character.
279
280=for apidoc Am|bool|isSPACE|char ch
281Returns a boolean indicating whether the C C<char> is whitespace.
282
283=for apidoc Am|bool|isDIGIT|char ch
4375e838 284Returns a boolean indicating whether the C C<char> is an ASCII
954c1994
GS
285digit.
286
287=for apidoc Am|bool|isUPPER|char ch
288Returns a boolean indicating whether the C C<char> is an uppercase
289character.
290
291=for apidoc Am|bool|isLOWER|char ch
292Returns a boolean indicating whether the C C<char> is a lowercase
293character.
294
295=for apidoc Am|char|toUPPER|char ch
296Converts the specified character to uppercase.
297
298=for apidoc Am|char|toLOWER|char ch
299Converts the specified character to lowercase.
300
301=cut
302*/
303
bbce6d69
PP
304#define isALNUM(c) (isALPHA(c) || isDIGIT(c) || (c) == '_')
305#define isIDFIRST(c) (isALPHA(c) || (c) == '_')
306#define isALPHA(c) (isUPPER(c) || isLOWER(c))
307#define isSPACE(c) \
308 ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) =='\r' || (c) == '\f')
aaa51d5e
JF
309#define isPSXSPC(c) (isSPACE(c) || (c) == '\v')
310#define isBLANK(c) ((c) == ' ' || (c) == '\t')
bbce6d69 311#define isDIGIT(c) ((c) >= '0' && (c) <= '9')
9d116dd7
JH
312#ifdef EBCDIC
313 /* In EBCDIC we do not do locales: therefore() isupper() is fine. */
314# define isUPPER(c) isupper(c)
315# define isLOWER(c) islower(c)
b8c5462f
JH
316# define isALNUMC(c) isalnum(c)
317# define isASCII(c) isascii(c)
318# define isCNTRL(c) iscntrl(c)
319# define isGRAPH(c) isgraph(c)
9d116dd7 320# define isPRINT(c) isprint(c)
b8c5462f
JH
321# define isPUNCT(c) ispunct(c)
322# define isXDIGIT(c) isxdigit(c)
9d116dd7
JH
323# define toUPPER(c) toupper(c)
324# define toLOWER(c) tolower(c)
325#else
326# define isUPPER(c) ((c) >= 'A' && (c) <= 'Z')
327# define isLOWER(c) ((c) >= 'a' && (c) <= 'z')
b8c5462f
JH
328# define isALNUMC(c) (isALPHA(c) || isDIGIT(c))
329# define isASCII(c) ((c) <= 127)
330# define isCNTRL(c) ((c) < ' ')
331# define isGRAPH(c) (isALNUM(c) || isPUNCT(c))
9d116dd7 332# define isPRINT(c) (((c) > 32 && (c) < 127) || isSPACE(c))
b8c5462f
JH
333# define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
334# define isXDIGIT(c) (isdigit(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
9d116dd7
JH
335# define toUPPER(c) (isLOWER(c) ? (c) - ('a' - 'A') : (c))
336# define toLOWER(c) (isUPPER(c) ? (c) + ('a' - 'A') : (c))
337#endif
bbce6d69
PP
338
339#ifdef USE_NEXT_CTYPE
340
341# define isALNUM_LC(c) \
37bd1396 342 (NXIsAlNum((unsigned int)(c)) || (char)(c) == '_')
ff68c719
PP
343# define isIDFIRST_LC(c) \
344 (NXIsAlpha((unsigned int)(c)) || (char)(c) == '_')
345# define isALPHA_LC(c) NXIsAlpha((unsigned int)(c))
346# define isSPACE_LC(c) NXIsSpace((unsigned int)(c))
347# define isDIGIT_LC(c) NXIsDigit((unsigned int)(c))
348# define isUPPER_LC(c) NXIsUpper((unsigned int)(c))
349# define isLOWER_LC(c) NXIsLower((unsigned int)(c))
37bd1396 350# define isALNUMC_LC(c) NXIsAlNum((unsigned int)(c))
b8c5462f
JH
351# define isCNTRL_LC(c) NXIsCntrl((unsigned int)(c))
352# define isGRAPH_LC(c) NXIsGraph((unsigned int)(c))
ff68c719 353# define isPRINT_LC(c) NXIsPrint((unsigned int)(c))
b8c5462f 354# define isPUNCT_LC(c) NXIsPunct((unsigned int)(c))
ff68c719
PP
355# define toUPPER_LC(c) NXToUpper((unsigned int)(c))
356# define toLOWER_LC(c) NXToLower((unsigned int)(c))
bbce6d69
PP
357
358#else /* !USE_NEXT_CTYPE */
b8c5462f 359
bbce6d69
PP
360# if defined(CTYPE256) || (!defined(isascii) && !defined(HAS_ISASCII))
361
b8c5462f 362# define isALNUM_LC(c) (isalnum((unsigned char)(c)) || (char)(c) == '_')
ff68c719 363# define isIDFIRST_LC(c) (isalpha((unsigned char)(c)) || (char)(c) == '_')
bbce6d69
PP
364# define isALPHA_LC(c) isalpha((unsigned char)(c))
365# define isSPACE_LC(c) isspace((unsigned char)(c))
366# define isDIGIT_LC(c) isdigit((unsigned char)(c))
367# define isUPPER_LC(c) isupper((unsigned char)(c))
368# define isLOWER_LC(c) islower((unsigned char)(c))
b8c5462f
JH
369# define isALNUMC_LC(c) isalnum((unsigned char)(c))
370# define isCNTRL_LC(c) iscntrl((unsigned char)(c))
371# define isGRAPH_LC(c) isgraph((unsigned char)(c))
bbce6d69 372# define isPRINT_LC(c) isprint((unsigned char)(c))
b8c5462f 373# define isPUNCT_LC(c) ispunct((unsigned char)(c))
bbce6d69
PP
374# define toUPPER_LC(c) toupper((unsigned char)(c))
375# define toLOWER_LC(c) tolower((unsigned char)(c))
376
377# else
378
b8c5462f 379# define isALNUM_LC(c) (isascii(c) && (isalnum(c) || (c) == '_'))
bbce6d69
PP
380# define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_'))
381# define isALPHA_LC(c) (isascii(c) && isalpha(c))
382# define isSPACE_LC(c) (isascii(c) && isspace(c))
383# define isDIGIT_LC(c) (isascii(c) && isdigit(c))
384# define isUPPER_LC(c) (isascii(c) && isupper(c))
385# define isLOWER_LC(c) (isascii(c) && islower(c))
b8c5462f
JH
386# define isALNUMC_LC(c) (isascii(c) && isalnum(c))
387# define isCNTRL_LC(c) (isascii(c) && iscntrl(c))
388# define isGRAPH_LC(c) (isascii(c) && isgraph(c))
bbce6d69 389# define isPRINT_LC(c) (isascii(c) && isprint(c))
b8c5462f 390# define isPUNCT_LC(c) (isascii(c) && ispunct(c))
bbce6d69
PP
391# define toUPPER_LC(c) toupper(c)
392# define toLOWER_LC(c) tolower(c)
393
394# endif
a0d0e21e 395#endif /* USE_NEXT_CTYPE */
55204971 396
aaa51d5e
JF
397#define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v')
398#define isBLANK_LC(c) isBLANK(c) /* could be wrong */
399
a0ed51b3
LW
400#define isALNUM_uni(c) is_uni_alnum(c)
401#define isIDFIRST_uni(c) is_uni_idfirst(c)
402#define isALPHA_uni(c) is_uni_alpha(c)
403#define isSPACE_uni(c) is_uni_space(c)
404#define isDIGIT_uni(c) is_uni_digit(c)
405#define isUPPER_uni(c) is_uni_upper(c)
406#define isLOWER_uni(c) is_uni_lower(c)
b8c5462f
JH
407#define isALNUMC_uni(c) is_uni_alnumc(c)
408#define isASCII_uni(c) is_uni_ascii(c)
409#define isCNTRL_uni(c) is_uni_cntrl(c)
410#define isGRAPH_uni(c) is_uni_graph(c)
a0ed51b3 411#define isPRINT_uni(c) is_uni_print(c)
b8c5462f
JH
412#define isPUNCT_uni(c) is_uni_punct(c)
413#define isXDIGIT_uni(c) is_uni_xdigit(c)
a0ed51b3
LW
414#define toUPPER_uni(c) to_uni_upper(c)
415#define toTITLE_uni(c) to_uni_title(c)
416#define toLOWER_uni(c) to_uni_lower(c)
417
aaa51d5e
JF
418#define isPSXSPC_uni(c) (isSPACE_uni(c) ||(c) == '\f')
419#define isBLANK_uni(c) isBLANK(c) /* could be wrong */
420
a0ed51b3
LW
421#define isALNUM_LC_uni(c) (c < 256 ? isALNUM_LC(c) : is_uni_alnum_lc(c))
422#define isIDFIRST_LC_uni(c) (c < 256 ? isIDFIRST_LC(c) : is_uni_idfirst_lc(c))
423#define isALPHA_LC_uni(c) (c < 256 ? isALPHA_LC(c) : is_uni_alpha_lc(c))
424#define isSPACE_LC_uni(c) (c < 256 ? isSPACE_LC(c) : is_uni_space_lc(c))
425#define isDIGIT_LC_uni(c) (c < 256 ? isDIGIT_LC(c) : is_uni_digit_lc(c))
426#define isUPPER_LC_uni(c) (c < 256 ? isUPPER_LC(c) : is_uni_upper_lc(c))
427#define isLOWER_LC_uni(c) (c < 256 ? isLOWER_LC(c) : is_uni_lower_lc(c))
b8c5462f
JH
428#define isALNUMC_LC_uni(c) (c < 256 ? isALNUMC_LC(c) : is_uni_alnumc_lc(c))
429#define isCNTRL_LC_uni(c) (c < 256 ? isCNTRL_LC(c) : is_uni_cntrl_lc(c))
430#define isGRAPH_LC_uni(c) (c < 256 ? isGRAPH_LC(c) : is_uni_graph_lc(c))
a0ed51b3 431#define isPRINT_LC_uni(c) (c < 256 ? isPRINT_LC(c) : is_uni_print_lc(c))
b8c5462f 432#define isPUNCT_LC_uni(c) (c < 256 ? isPUNCT_LC(c) : is_uni_punct_lc(c))
a0ed51b3
LW
433#define toUPPER_LC_uni(c) (c < 256 ? toUPPER_LC(c) : to_uni_upper_lc(c))
434#define toTITLE_LC_uni(c) (c < 256 ? toUPPER_LC(c) : to_uni_title_lc(c))
435#define toLOWER_LC_uni(c) (c < 256 ? toLOWER_LC(c) : to_uni_lower_lc(c))
436
aaa51d5e
JF
437#define isPSXSPC_LC_uni(c) (isSPACE_LC_uni(c) ||(c) == '\f')
438#define isBLANK_LC_uni(c) isBLANK(c) /* could be wrong */
439
a0ed51b3
LW
440#define isALNUM_utf8(p) is_utf8_alnum(p)
441#define isIDFIRST_utf8(p) is_utf8_idfirst(p)
442#define isALPHA_utf8(p) is_utf8_alpha(p)
443#define isSPACE_utf8(p) is_utf8_space(p)
444#define isDIGIT_utf8(p) is_utf8_digit(p)
445#define isUPPER_utf8(p) is_utf8_upper(p)
446#define isLOWER_utf8(p) is_utf8_lower(p)
b8c5462f
JH
447#define isALNUMC_utf8(p) is_utf8_alnumc(p)
448#define isASCII_utf8(p) is_utf8_ascii(p)
449#define isCNTRL_utf8(p) is_utf8_cntrl(p)
450#define isGRAPH_utf8(p) is_utf8_graph(p)
a0ed51b3 451#define isPRINT_utf8(p) is_utf8_print(p)
b8c5462f
JH
452#define isPUNCT_utf8(p) is_utf8_punct(p)
453#define isXDIGIT_utf8(p) is_utf8_xdigit(p)
a0ed51b3
LW
454#define toUPPER_utf8(p) to_utf8_upper(p)
455#define toTITLE_utf8(p) to_utf8_title(p)
456#define toLOWER_utf8(p) to_utf8_lower(p)
457
aaa51d5e
JF
458#define isPSXSPC_utf8(c) (isSPACE_utf8(c) ||(c) == '\f')
459#define isBLANK_utf8(c) isBLANK(c) /* could be wrong */
460
ba210ebe
JH
461#define STRLEN_MAX ((STRLEN)-1)
462
06aa31c8
JH
463#define isALNUM_LC_utf8(p) isALNUM_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
464#define isIDFIRST_LC_utf8(p) isIDFIRST_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
465#define isALPHA_LC_utf8(p) isALPHA_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
466#define isSPACE_LC_utf8(p) isSPACE_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
467#define isDIGIT_LC_utf8(p) isDIGIT_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
468#define isUPPER_LC_utf8(p) isUPPER_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
469#define isLOWER_LC_utf8(p) isLOWER_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
470#define isALNUMC_LC_utf8(p) isALNUMC_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
471#define isCNTRL_LC_utf8(p) isCNTRL_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
472#define isGRAPH_LC_utf8(p) isGRAPH_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
473#define isPRINT_LC_utf8(p) isPRINT_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
474#define isPUNCT_LC_utf8(p) isPUNCT_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
475#define toUPPER_LC_utf8(p) toUPPER_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
476#define toTITLE_LC_utf8(p) toTITLE_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
477#define toLOWER_LC_utf8(p) toLOWER_LC_uni(utf8_to_uv(p, STRLEN_MAX, 0, 0))
a0ed51b3 478
aaa51d5e
JF
479#define isPSXSPC_LC_utf8(c) (isSPACE_LC_utf8(c) ||(c) == '\f')
480#define isBLANK_LC_utf8(c) isBLANK(c) /* could be wrong */
481
9d116dd7 482#ifdef EBCDIC
20ce7b12 483EXT int ebcdic_control (int);
9d116dd7
JH
484# define toCTRL(c) ebcdic_control(c)
485#else
486 /* This conversion works both ways, strangely enough. */
487# define toCTRL(c) (toUPPER(c) ^ 64)
488#endif
bbce6d69 489
378cc40b 490/* Line numbers are unsigned, 16 bits. */
79072805 491typedef U16 line_t;
378cc40b
LW
492#ifdef lint
493#define NOLINE ((line_t)0)
494#else
495#define NOLINE ((line_t) 65535)
496#endif
497
8c52afec 498
8e84507e 499/*
8c52afec 500 XXX LEAKTEST doesn't really work in perl5. There are direct calls to
27d4fb96 501 safemalloc() in the source, so LEAKTEST won't pick them up.
c1d22f6b 502 (The main "offenders" are extensions.)
27d4fb96
PP
503 Further, if you try LEAKTEST, you'll also end up calling
504 Safefree, which might call safexfree() on some things that weren't
505 malloced with safexmalloc. The correct "fix" to this, if anyone
506 is interested, is to ensure that all calls go through the New and
507 Renew macros.
508 --Andy Dougherty August 1996
509*/
55497cff 510
954c1994
GS
511/*
512=for apidoc Am|SV*|NEWSV|int id|STRLEN len
513Creates a new SV. A non-zero C<len> parameter indicates the number of
514bytes of preallocated string space the SV should have. An extra byte for a
515tailing NUL is also reserved. (SvPOK is not set for the SV even if string
8e84507e 516space is allocated.) The reference count for the new SV is set to 1.
954c1994
GS
517C<id> is an integer id between 0 and 1299 (used to identify leaks).
518
519=for apidoc Am|void|New|int id|void* ptr|int nitems|type
520The XSUB-writer's interface to the C C<malloc> function.
521
522=for apidoc Am|void|Newc|int id|void* ptr|int nitems|type|cast
523The XSUB-writer's interface to the C C<malloc> function, with
524cast.
525
526=for apidoc Am|void|Newz|int id|void* ptr|int nitems|type
527The XSUB-writer's interface to the C C<malloc> function. The allocated
528memory is zeroed with C<memzero>.
529
530=for apidoc Am|void|Renew|void* ptr|int nitems|type
531The XSUB-writer's interface to the C C<realloc> function.
532
533=for apidoc Am|void|Renewc|void* ptr|int nitems|type|cast
534The XSUB-writer's interface to the C C<realloc> function, with
535cast.
536
49b8b560 537=for apidoc Am|void|Safefree|void* ptr
954c1994
GS
538The XSUB-writer's interface to the C C<free> function.
539
540=for apidoc Am|void|Move|void* src|void* dest|int nitems|type
541The XSUB-writer's interface to the C C<memmove> function. The C<src> is the
542source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is
543the type. Can do overlapping moves. See also C<Copy>.
544
545=for apidoc Am|void|Copy|void* src|void* dest|int nitems|type
546The XSUB-writer's interface to the C C<memcpy> function. The C<src> is the
547source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is
548the type. May fail on overlapping copies. See also C<Move>.
549
550=for apidoc Am|void|Zero|void* dest|int nitems|type
551
552The XSUB-writer's interface to the C C<memzero> function. The C<dest> is the
553destination, C<nitems> is the number of items, and C<type> is the type.
554
555=for apidoc Am|void|StructCopy|type src|type dest|type
4375e838 556This is an architecture-independent macro to copy one structure to another.
954c1994
GS
557
558=cut
559*/
560
a687059c 561#ifndef lint
ff06c60c
IZ
562
563#define NEWSV(x,len) newSV(len)
564
a687059c 565#ifndef LEAKTEST
598a3d64 566
ff68c719
PP
567#define New(x,v,n,t) (v = (t*)safemalloc((MEM_SIZE)((n)*sizeof(t))))
568#define Newc(x,v,n,t,c) (v = (c*)safemalloc((MEM_SIZE)((n)*sizeof(t))))
569#define Newz(x,v,n,t) (v = (t*)safemalloc((MEM_SIZE)((n)*sizeof(t)))), \
570 memzero((char*)(v), (n)*sizeof(t))
571#define Renew(v,n,t) \
572 (v = (t*)saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t))))
573#define Renewc(v,n,t,c) \
574 (v = (c*)saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t))))
575#define Safefree(d) safefree((Malloc_t)(d))
55497cff 576
a687059c 577#else /* LEAKTEST */
55497cff 578
ff68c719
PP
579#define New(x,v,n,t) (v = (t*)safexmalloc((x),(MEM_SIZE)((n)*sizeof(t))))
580#define Newc(x,v,n,t,c) (v = (c*)safexmalloc((x),(MEM_SIZE)((n)*sizeof(t))))
581#define Newz(x,v,n,t) (v = (t*)safexmalloc((x),(MEM_SIZE)((n)*sizeof(t)))), \
582 memzero((char*)(v), (n)*sizeof(t))
583#define Renew(v,n,t) \
584 (v = (t*)safexrealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t))))
585#define Renewc(v,n,t,c) \
586 (v = (c*)safexrealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t))))
8c52afec 587#define Safefree(d) safexfree((Malloc_t)(d))
ff68c719 588
fc36a67e 589#define MAXXCOUNT 1400
8c52afec
IZ
590#define MAXY_SIZE 80
591#define MAXYCOUNT 16 /* (MAXY_SIZE/4 + 1) */
592extern long xcount[MAXXCOUNT];
593extern long lastxcount[MAXXCOUNT];
594extern long xycount[MAXXCOUNT][MAXYCOUNT];
595extern long lastxycount[MAXXCOUNT][MAXYCOUNT];
55497cff 596
a687059c 597#endif /* LEAKTEST */
55497cff 598
ff68c719
PP
599#define Move(s,d,n,t) (void)memmove((char*)(d),(char*)(s), (n) * sizeof(t))
600#define Copy(s,d,n,t) (void)memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
601#define Zero(d,n,t) (void)memzero((char*)(d), (n) * sizeof(t))
55497cff 602
a687059c 603#else /* lint */
55497cff 604
ff68c719
PP
605#define New(x,v,n,s) (v = Null(s *))
606#define Newc(x,v,n,s,c) (v = Null(s *))
607#define Newz(x,v,n,s) (v = Null(s *))
608#define Renew(v,n,s) (v = Null(s *))
bee1dbe2 609#define Move(s,d,n,t)
a687059c
LW
610#define Copy(s,d,n,t)
611#define Zero(d,n,t)
ff68c719 612#define Safefree(d) (d) = (d)
55497cff 613
a687059c 614#endif /* lint */
bee1dbe2 615
2304df62 616#ifdef USE_STRUCT_COPY
ff68c719 617#define StructCopy(s,d,t) (*((t*)(d)) = *((t*)(s)))
bee1dbe2
LW
618#else
619#define StructCopy(s,d,t) Copy(s,d,1,t)
620#endif