1 |
/* handy.h |
2 |
* |
3 |
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, |
4 |
* 2000, 2001, 2002, 2004, 2005 by Larry Wall and others |
5 |
* |
6 |
* You may distribute under the terms of either the GNU General Public |
7 |
* License or the Artistic License, as specified in the README file. |
8 |
* |
9 |
*/ |
10 |
|
11 |
#if !defined(__STDC__) |
12 |
#ifdef NULL |
13 |
#undef NULL |
14 |
#endif |
15 |
#ifndef I286 |
16 |
# define NULL 0 |
17 |
#else |
18 |
# define NULL 0L |
19 |
#endif |
20 |
#endif |
21 |
|
22 |
#define Null(type) ((type)NULL) |
23 |
|
24 |
/* |
25 |
=head1 Handy Values |
26 |
|
27 |
=for apidoc AmU||Nullch |
28 |
Null character pointer. |
29 |
|
30 |
=for apidoc AmU||Nullsv |
31 |
Null SV pointer. |
32 |
|
33 |
=cut |
34 |
*/ |
35 |
|
36 |
#define Nullch Null(char*) |
37 |
#define Nullfp Null(PerlIO*) |
38 |
#define Nullsv Null(SV*) |
39 |
|
40 |
#ifdef TRUE |
41 |
#undef TRUE |
42 |
#endif |
43 |
#ifdef FALSE |
44 |
#undef FALSE |
45 |
#endif |
46 |
#define TRUE (1) |
47 |
#define FALSE (0) |
48 |
|
49 |
|
50 |
/* XXX Configure ought to have a test for a boolean type, if I can |
51 |
just figure out all the headers such a test needs. |
52 |
Andy Dougherty August 1996 |
53 |
*/ |
54 |
/* bool is built-in for g++-2.6.3 and later, which might be used |
55 |
for extensions. <_G_config.h> defines _G_HAVE_BOOL, but we can't |
56 |
be sure _G_config.h will be included before this file. _G_config.h |
57 |
also defines _G_HAVE_BOOL for both gcc and g++, but only g++ |
58 |
actually has bool. Hence, _G_HAVE_BOOL is pretty useless for us. |
59 |
g++ can be identified by __GNUG__. |
60 |
Andy Dougherty February 2000 |
61 |
*/ |
62 |
#ifdef __GNUG__ /* GNU g++ has bool built-in */ |
63 |
# ifndef HAS_BOOL |
64 |
# define HAS_BOOL 1 |
65 |
# endif |
66 |
#endif |
67 |
|
68 |
/* The NeXT dynamic loader headers will not build with the bool macro |
69 |
So declare them now to clear confusion. |
70 |
*/ |
71 |
#if defined(NeXT) || defined(__NeXT__) |
72 |
# undef FALSE |
73 |
# undef TRUE |
74 |
typedef enum bool { FALSE = 0, TRUE = 1 } bool; |
75 |
# define ENUM_BOOL 1 |
76 |
# ifndef HAS_BOOL |
77 |
# define HAS_BOOL 1 |
78 |
# endif /* !HAS_BOOL */ |
79 |
#endif /* NeXT || __NeXT__ */ |
80 |
|
81 |
#ifndef HAS_BOOL |
82 |
# if defined(UTS) || defined(VMS) |
83 |
# define bool int |
84 |
# else |
85 |
# define bool char |
86 |
# endif |
87 |
# define HAS_BOOL 1 |
88 |
#endif |
89 |
|
90 |
/* XXX A note on the perl source internal type system. The |
91 |
original intent was that I32 be *exactly* 32 bits. |
92 |
|
93 |
Currently, we only guarantee that I32 is *at least* 32 bits. |
94 |
Specifically, if int is 64 bits, then so is I32. (This is the case |
95 |
for the Cray.) This has the advantage of meshing nicely with |
96 |
standard library calls (where we pass an I32 and the library is |
97 |
expecting an int), but the disadvantage that an I32 is not 32 bits. |
98 |
Andy Dougherty August 1996 |
99 |
|
100 |
There is no guarantee that there is *any* integral type with |
101 |
exactly 32 bits. It is perfectly legal for a system to have |
102 |
sizeof(short) == sizeof(int) == sizeof(long) == 8. |
103 |
|
104 |
Similarly, there is no guarantee that I16 and U16 have exactly 16 |
105 |
bits. |
106 |
|
107 |
For dealing with issues that may arise from various 32/64-bit |
108 |
systems, we will ask Configure to check out |
109 |
|
110 |
SHORTSIZE == sizeof(short) |
111 |
INTSIZE == sizeof(int) |
112 |
LONGSIZE == sizeof(long) |
113 |
LONGLONGSIZE == sizeof(long long) (if HAS_LONG_LONG) |
114 |
PTRSIZE == sizeof(void *) |
115 |
DOUBLESIZE == sizeof(double) |
116 |
LONG_DOUBLESIZE == sizeof(long double) (if HAS_LONG_DOUBLE). |
117 |
|
118 |
*/ |
119 |
|
120 |
#ifdef I_INTTYPES /* e.g. Linux has int64_t without <inttypes.h> */ |
121 |
# include <inttypes.h> |
122 |
# ifdef INT32_MIN_BROKEN |
123 |
# undef INT32_MIN |
124 |
# define INT32_MIN (-2147483647-1) |
125 |
# endif |
126 |
# ifdef INT64_MIN_BROKEN |
127 |
# undef INT64_MIN |
128 |
# define INT64_MIN (-9223372036854775807LL-1) |
129 |
# endif |
130 |
#endif |
131 |
|
132 |
typedef I8TYPE I8; |
133 |
typedef U8TYPE U8; |
134 |
typedef I16TYPE I16; |
135 |
typedef U16TYPE U16; |
136 |
typedef I32TYPE I32; |
137 |
typedef U32TYPE U32; |
138 |
#ifdef PERL_CORE |
139 |
# ifdef HAS_QUAD |
140 |
typedef I64TYPE I64; |
141 |
typedef U64TYPE U64; |
142 |
# endif |
143 |
#endif /* PERL_CORE */ |
144 |
|
145 |
#if defined(HAS_QUAD) && defined(USE_64_BIT_INT) |
146 |
# ifndef UINT64_C /* usually from <inttypes.h> */ |
147 |
# if defined(HAS_LONG_LONG) && QUADKIND == QUAD_IS_LONG_LONG |
148 |
# define INT64_C(c) CAT2(c,LL) |
149 |
# define UINT64_C(c) CAT2(c,ULL) |
150 |
# else |
151 |
# if LONGSIZE == 8 && QUADKIND == QUAD_IS_LONG |
152 |
# define INT64_C(c) CAT2(c,L) |
153 |
# define UINT64_C(c) CAT2(c,UL) |
154 |
# else |
155 |
# define INT64_C(c) ((I64TYPE)(c)) |
156 |
# define UINT64_C(c) ((U64TYPE)(c)) |
157 |
# endif |
158 |
# endif |
159 |
# endif |
160 |
#endif |
161 |
|
162 |
/* HMB H.Merijn Brand - a placeholder for preparing Configure patches */ |
163 |
#if defined(LIBM_LIB_VERSION) |
164 |
/* Not (yet) used at top level, but mention them for metaconfig */ |
165 |
#endif |
166 |
|
167 |
/* Mention I8SIZE, U8SIZE, I16SIZE, U16SIZE, I32SIZE, U32SIZE, |
168 |
I64SIZE, and U64SIZE here so that metaconfig pulls them in. */ |
169 |
|
170 |
#if defined(UINT8_MAX) && defined(INT16_MAX) && defined(INT32_MAX) |
171 |
|
172 |
/* I8_MAX and I8_MIN constants are not defined, as I8 is an ambiguous type. |
173 |
Please search CHAR_MAX in perl.h for further details. */ |
174 |
#define U8_MAX UINT8_MAX |
175 |
#define U8_MIN UINT8_MIN |
176 |
|
177 |
#define I16_MAX INT16_MAX |
178 |
#define I16_MIN INT16_MIN |
179 |
#define U16_MAX UINT16_MAX |
180 |
#define U16_MIN UINT16_MIN |
181 |
|
182 |
#define I32_MAX INT32_MAX |
183 |
#define I32_MIN INT32_MIN |
184 |
#ifndef UINT32_MAX_BROKEN /* e.g. HP-UX with gcc messes this up */ |
185 |
# define U32_MAX UINT32_MAX |
186 |
#else |
187 |
# define U32_MAX 4294967295U |
188 |
#endif |
189 |
#define U32_MIN UINT32_MIN |
190 |
|
191 |
#else |
192 |
|
193 |
/* I8_MAX and I8_MIN constants are not defined, as I8 is an ambiguous type. |
194 |
Please search CHAR_MAX in perl.h for further details. */ |
195 |
#define U8_MAX PERL_UCHAR_MAX |
196 |
#define U8_MIN PERL_UCHAR_MIN |
197 |
|
198 |
#define I16_MAX PERL_SHORT_MAX |
199 |
#define I16_MIN PERL_SHORT_MIN |
200 |
#define U16_MAX PERL_USHORT_MAX |
201 |
#define U16_MIN PERL_USHORT_MIN |
202 |
|
203 |
#if LONGSIZE > 4 |
204 |
# define I32_MAX PERL_INT_MAX |
205 |
# define I32_MIN PERL_INT_MIN |
206 |
# define U32_MAX PERL_UINT_MAX |
207 |
# define U32_MIN PERL_UINT_MIN |
208 |
#else |
209 |
# define I32_MAX PERL_LONG_MAX |
210 |
# define I32_MIN PERL_LONG_MIN |
211 |
# define U32_MAX PERL_ULONG_MAX |
212 |
# define U32_MIN PERL_ULONG_MIN |
213 |
#endif |
214 |
|
215 |
#endif |
216 |
|
217 |
/* log(2) is pretty close to 0.30103, just in case anyone is grepping for it */ |
218 |
#define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */ |
219 |
#define TYPE_DIGITS(T) BIT_DIGITS(sizeof(T) * 8) |
220 |
#define TYPE_CHARS(T) (TYPE_DIGITS(T) + 2) /* sign, NUL */ |
221 |
|
222 |
#define Ctl(ch) ((ch) & 037) |
223 |
|
224 |
/* |
225 |
=head1 Miscellaneous Functions |
226 |
|
227 |
=for apidoc Am|bool|strNE|char* s1|char* s2 |
228 |
Test two strings to see if they are different. Returns true or |
229 |
false. |
230 |
|
231 |
=for apidoc Am|bool|strEQ|char* s1|char* s2 |
232 |
Test two strings to see if they are equal. Returns true or false. |
233 |
|
234 |
=for apidoc Am|bool|strLT|char* s1|char* s2 |
235 |
Test two strings to see if the first, C<s1>, is less than the second, |
236 |
C<s2>. Returns true or false. |
237 |
|
238 |
=for apidoc Am|bool|strLE|char* s1|char* s2 |
239 |
Test two strings to see if the first, C<s1>, is less than or equal to the |
240 |
second, C<s2>. Returns true or false. |
241 |
|
242 |
=for apidoc Am|bool|strGT|char* s1|char* s2 |
243 |
Test two strings to see if the first, C<s1>, is greater than the second, |
244 |
C<s2>. Returns true or false. |
245 |
|
246 |
=for apidoc Am|bool|strGE|char* s1|char* s2 |
247 |
Test two strings to see if the first, C<s1>, is greater than or equal to |
248 |
the second, C<s2>. Returns true or false. |
249 |
|
250 |
=for apidoc Am|bool|strnNE|char* s1|char* s2|STRLEN len |
251 |
Test two strings to see if they are different. The C<len> parameter |
252 |
indicates the number of bytes to compare. Returns true or false. (A |
253 |
wrapper for C<strncmp>). |
254 |
|
255 |
=for apidoc Am|bool|strnEQ|char* s1|char* s2|STRLEN len |
256 |
Test two strings to see if they are equal. The C<len> parameter indicates |
257 |
the number of bytes to compare. Returns true or false. (A wrapper for |
258 |
C<strncmp>). |
259 |
|
260 |
=cut |
261 |
*/ |
262 |
|
263 |
#define strNE(s1,s2) (strcmp(s1,s2)) |
264 |
#define strEQ(s1,s2) (!strcmp(s1,s2)) |
265 |
#define strLT(s1,s2) (strcmp(s1,s2) < 0) |
266 |
#define strLE(s1,s2) (strcmp(s1,s2) <= 0) |
267 |
#define strGT(s1,s2) (strcmp(s1,s2) > 0) |
268 |
#define strGE(s1,s2) (strcmp(s1,s2) >= 0) |
269 |
#define strnNE(s1,s2,l) (strncmp(s1,s2,l)) |
270 |
#define strnEQ(s1,s2,l) (!strncmp(s1,s2,l)) |
271 |
|
272 |
#ifdef HAS_MEMCMP |
273 |
# define memNE(s1,s2,l) (memcmp(s1,s2,l)) |
274 |
# define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) |
275 |
#else |
276 |
# define memNE(s1,s2,l) (bcmp(s1,s2,l)) |
277 |
# define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) |
278 |
#endif |
279 |
|
280 |
/* |
281 |
* Character classes. |
282 |
* |
283 |
* Unfortunately, the introduction of locales means that we |
284 |
* can't trust isupper(), etc. to tell the truth. And when |
285 |
* it comes to /\w+/ with tainting enabled, we *must* be able |
286 |
* to trust our character classes. |
287 |
* |
288 |
* Therefore, the default tests in the text of Perl will be |
289 |
* independent of locale. Any code that wants to depend on |
290 |
* the current locale will use the tests that begin with "lc". |
291 |
*/ |
292 |
|
293 |
#ifdef HAS_SETLOCALE /* XXX Is there a better test for this? */ |
294 |
# ifndef CTYPE256 |
295 |
# define CTYPE256 |
296 |
# endif |
297 |
#endif |
298 |
|
299 |
/* |
300 |
|
301 |
=head1 Character classes |
302 |
|
303 |
=for apidoc Am|bool|isALNUM|char ch |
304 |
Returns a boolean indicating whether the C C<char> is an ASCII alphanumeric |
305 |
character (including underscore) or digit. |
306 |
|
307 |
=for apidoc Am|bool|isALPHA|char ch |
308 |
Returns a boolean indicating whether the C C<char> is an ASCII alphabetic |
309 |
character. |
310 |
|
311 |
=for apidoc Am|bool|isSPACE|char ch |
312 |
Returns a boolean indicating whether the C C<char> is whitespace. |
313 |
|
314 |
=for apidoc Am|bool|isDIGIT|char ch |
315 |
Returns a boolean indicating whether the C C<char> is an ASCII |
316 |
digit. |
317 |
|
318 |
=for apidoc Am|bool|isUPPER|char ch |
319 |
Returns a boolean indicating whether the C C<char> is an uppercase |
320 |
character. |
321 |
|
322 |
=for apidoc Am|bool|isLOWER|char ch |
323 |
Returns a boolean indicating whether the C C<char> is a lowercase |
324 |
character. |
325 |
|
326 |
=for apidoc Am|char|toUPPER|char ch |
327 |
Converts the specified character to uppercase. |
328 |
|
329 |
=for apidoc Am|char|toLOWER|char ch |
330 |
Converts the specified character to lowercase. |
331 |
|
332 |
=cut |
333 |
*/ |
334 |
|
335 |
#define isALNUM(c) (isALPHA(c) || isDIGIT(c) || (c) == '_') |
336 |
#define isIDFIRST(c) (isALPHA(c) || (c) == '_') |
337 |
#define isALPHA(c) (isUPPER(c) || isLOWER(c)) |
338 |
#define isSPACE(c) \ |
339 |
((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) =='\r' || (c) == '\f') |
340 |
#define isPSXSPC(c) (isSPACE(c) || (c) == '\v') |
341 |
#define isBLANK(c) ((c) == ' ' || (c) == '\t') |
342 |
#define isDIGIT(c) ((c) >= '0' && (c) <= '9') |
343 |
#ifdef EBCDIC |
344 |
/* In EBCDIC we do not do locales: therefore() isupper() is fine. */ |
345 |
# define isUPPER(c) isupper(c) |
346 |
# define isLOWER(c) islower(c) |
347 |
# define isALNUMC(c) isalnum(c) |
348 |
# define isASCII(c) isascii(c) |
349 |
# define isCNTRL(c) iscntrl(c) |
350 |
# define isGRAPH(c) isgraph(c) |
351 |
# define isPRINT(c) isprint(c) |
352 |
# define isPUNCT(c) ispunct(c) |
353 |
# define isXDIGIT(c) isxdigit(c) |
354 |
# define toUPPER(c) toupper(c) |
355 |
# define toLOWER(c) tolower(c) |
356 |
#else |
357 |
# define isUPPER(c) ((c) >= 'A' && (c) <= 'Z') |
358 |
# define isLOWER(c) ((c) >= 'a' && (c) <= 'z') |
359 |
# define isALNUMC(c) (isALPHA(c) || isDIGIT(c)) |
360 |
# define isASCII(c) ((c) <= 127) |
361 |
# define isCNTRL(c) ((c) < ' ' || (c) == 127) |
362 |
# define isGRAPH(c) (isALNUM(c) || isPUNCT(c)) |
363 |
# define isPRINT(c) (((c) > 32 && (c) < 127) || (c) == ' ') |
364 |
# define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) |
365 |
# define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F')) |
366 |
# define toUPPER(c) (isLOWER(c) ? (c) - ('a' - 'A') : (c)) |
367 |
# define toLOWER(c) (isUPPER(c) ? (c) + ('a' - 'A') : (c)) |
368 |
#endif |
369 |
|
370 |
#ifdef USE_NEXT_CTYPE |
371 |
|
372 |
# define isALNUM_LC(c) \ |
373 |
(NXIsAlNum((unsigned int)(c)) || (char)(c) == '_') |
374 |
# define isIDFIRST_LC(c) \ |
375 |
(NXIsAlpha((unsigned int)(c)) || (char)(c) == '_') |
376 |
# define isALPHA_LC(c) NXIsAlpha((unsigned int)(c)) |
377 |
# define isSPACE_LC(c) NXIsSpace((unsigned int)(c)) |
378 |
# define isDIGIT_LC(c) NXIsDigit((unsigned int)(c)) |
379 |
# define isUPPER_LC(c) NXIsUpper((unsigned int)(c)) |
380 |
# define isLOWER_LC(c) NXIsLower((unsigned int)(c)) |
381 |
# define isALNUMC_LC(c) NXIsAlNum((unsigned int)(c)) |
382 |
# define isCNTRL_LC(c) NXIsCntrl((unsigned int)(c)) |
383 |
# define isGRAPH_LC(c) NXIsGraph((unsigned int)(c)) |
384 |
# define isPRINT_LC(c) NXIsPrint((unsigned int)(c)) |
385 |
# define isPUNCT_LC(c) NXIsPunct((unsigned int)(c)) |
386 |
# define toUPPER_LC(c) NXToUpper((unsigned int)(c)) |
387 |
# define toLOWER_LC(c) NXToLower((unsigned int)(c)) |
388 |
|
389 |
#else /* !USE_NEXT_CTYPE */ |
390 |
|
391 |
# if defined(CTYPE256) || (!defined(isascii) && !defined(HAS_ISASCII)) |
392 |
|
393 |
# define isALNUM_LC(c) (isalnum((unsigned char)(c)) || (char)(c) == '_') |
394 |
# define isIDFIRST_LC(c) (isalpha((unsigned char)(c)) || (char)(c) == '_') |
395 |
# define isALPHA_LC(c) isalpha((unsigned char)(c)) |
396 |
# define isSPACE_LC(c) isspace((unsigned char)(c)) |
397 |
# define isDIGIT_LC(c) isdigit((unsigned char)(c)) |
398 |
# define isUPPER_LC(c) isupper((unsigned char)(c)) |
399 |
# define isLOWER_LC(c) islower((unsigned char)(c)) |
400 |
# define isALNUMC_LC(c) isalnum((unsigned char)(c)) |
401 |
# define isCNTRL_LC(c) iscntrl((unsigned char)(c)) |
402 |
# define isGRAPH_LC(c) isgraph((unsigned char)(c)) |
403 |
# define isPRINT_LC(c) isprint((unsigned char)(c)) |
404 |
# define isPUNCT_LC(c) ispunct((unsigned char)(c)) |
405 |
# define toUPPER_LC(c) toupper((unsigned char)(c)) |
406 |
# define toLOWER_LC(c) tolower((unsigned char)(c)) |
407 |
|
408 |
# else |
409 |
|
410 |
# define isALNUM_LC(c) (isascii(c) && (isalnum(c) || (c) == '_')) |
411 |
# define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_')) |
412 |
# define isALPHA_LC(c) (isascii(c) && isalpha(c)) |
413 |
# define isSPACE_LC(c) (isascii(c) && isspace(c)) |
414 |
# define isDIGIT_LC(c) (isascii(c) && isdigit(c)) |
415 |
# define isUPPER_LC(c) (isascii(c) && isupper(c)) |
416 |
# define isLOWER_LC(c) (isascii(c) && islower(c)) |
417 |
# define isALNUMC_LC(c) (isascii(c) && isalnum(c)) |
418 |
# define isCNTRL_LC(c) (isascii(c) && iscntrl(c)) |
419 |
# define isGRAPH_LC(c) (isascii(c) && isgraph(c)) |
420 |
# define isPRINT_LC(c) (isascii(c) && isprint(c)) |
421 |
# define isPUNCT_LC(c) (isascii(c) && ispunct(c)) |
422 |
# define toUPPER_LC(c) toupper(c) |
423 |
# define toLOWER_LC(c) tolower(c) |
424 |
|
425 |
# endif |
426 |
#endif /* USE_NEXT_CTYPE */ |
427 |
|
428 |
#define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v') |
429 |
#define isBLANK_LC(c) isBLANK(c) /* could be wrong */ |
430 |
|
431 |
#define isALNUM_uni(c) is_uni_alnum(c) |
432 |
#define isIDFIRST_uni(c) is_uni_idfirst(c) |
433 |
#define isALPHA_uni(c) is_uni_alpha(c) |
434 |
#define isSPACE_uni(c) is_uni_space(c) |
435 |
#define isDIGIT_uni(c) is_uni_digit(c) |
436 |
#define isUPPER_uni(c) is_uni_upper(c) |
437 |
#define isLOWER_uni(c) is_uni_lower(c) |
438 |
#define isALNUMC_uni(c) is_uni_alnumc(c) |
439 |
#define isASCII_uni(c) is_uni_ascii(c) |
440 |
#define isCNTRL_uni(c) is_uni_cntrl(c) |
441 |
#define isGRAPH_uni(c) is_uni_graph(c) |
442 |
#define isPRINT_uni(c) is_uni_print(c) |
443 |
#define isPUNCT_uni(c) is_uni_punct(c) |
444 |
#define isXDIGIT_uni(c) is_uni_xdigit(c) |
445 |
#define toUPPER_uni(c,s,l) to_uni_upper(c,s,l) |
446 |
#define toTITLE_uni(c,s,l) to_uni_title(c,s,l) |
447 |
#define toLOWER_uni(c,s,l) to_uni_lower(c,s,l) |
448 |
#define toFOLD_uni(c,s,l) to_uni_fold(c,s,l) |
449 |
|
450 |
#define isPSXSPC_uni(c) (isSPACE_uni(c) ||(c) == '\f') |
451 |
#define isBLANK_uni(c) isBLANK(c) /* could be wrong */ |
452 |
|
453 |
#define isALNUM_LC_uvchr(c) (c < 256 ? isALNUM_LC(c) : is_uni_alnum_lc(c)) |
454 |
#define isIDFIRST_LC_uvchr(c) (c < 256 ? isIDFIRST_LC(c) : is_uni_idfirst_lc(c)) |
455 |
#define isALPHA_LC_uvchr(c) (c < 256 ? isALPHA_LC(c) : is_uni_alpha_lc(c)) |
456 |
#define isSPACE_LC_uvchr(c) (c < 256 ? isSPACE_LC(c) : is_uni_space_lc(c)) |
457 |
#define isDIGIT_LC_uvchr(c) (c < 256 ? isDIGIT_LC(c) : is_uni_digit_lc(c)) |
458 |
#define isUPPER_LC_uvchr(c) (c < 256 ? isUPPER_LC(c) : is_uni_upper_lc(c)) |
459 |
#define isLOWER_LC_uvchr(c) (c < 256 ? isLOWER_LC(c) : is_uni_lower_lc(c)) |
460 |
#define isALNUMC_LC_uvchr(c) (c < 256 ? isALNUMC_LC(c) : is_uni_alnumc_lc(c)) |
461 |
#define isCNTRL_LC_uvchr(c) (c < 256 ? isCNTRL_LC(c) : is_uni_cntrl_lc(c)) |
462 |
#define isGRAPH_LC_uvchr(c) (c < 256 ? isGRAPH_LC(c) : is_uni_graph_lc(c)) |
463 |
#define isPRINT_LC_uvchr(c) (c < 256 ? isPRINT_LC(c) : is_uni_print_lc(c)) |
464 |
#define isPUNCT_LC_uvchr(c) (c < 256 ? isPUNCT_LC(c) : is_uni_punct_lc(c)) |
465 |
|
466 |
#define isPSXSPC_LC_uni(c) (isSPACE_LC_uni(c) ||(c) == '\f') |
467 |
#define isBLANK_LC_uni(c) isBLANK(c) /* could be wrong */ |
468 |
|
469 |
#define isALNUM_utf8(p) is_utf8_alnum(p) |
470 |
/* The ID_Start of Unicode is quite limiting: it assumes a L-class |
471 |
* character (meaning that you cannot have, say, a CJK character). |
472 |
* Instead, let's allow ID_Continue but not digits. */ |
473 |
#define isIDFIRST_utf8(p) (is_utf8_idcont(p) && !is_utf8_digit(p)) |
474 |
#define isALPHA_utf8(p) is_utf8_alpha(p) |
475 |
#define isSPACE_utf8(p) is_utf8_space(p) |
476 |
#define isDIGIT_utf8(p) is_utf8_digit(p) |
477 |
#define isUPPER_utf8(p) is_utf8_upper(p) |
478 |
#define isLOWER_utf8(p) is_utf8_lower(p) |
479 |
#define isALNUMC_utf8(p) is_utf8_alnumc(p) |
480 |
#define isASCII_utf8(p) is_utf8_ascii(p) |
481 |
#define isCNTRL_utf8(p) is_utf8_cntrl(p) |
482 |
#define isGRAPH_utf8(p) is_utf8_graph(p) |
483 |
#define isPRINT_utf8(p) is_utf8_print(p) |
484 |
#define isPUNCT_utf8(p) is_utf8_punct(p) |
485 |
#define isXDIGIT_utf8(p) is_utf8_xdigit(p) |
486 |
#define toUPPER_utf8(p,s,l) to_utf8_upper(p,s,l) |
487 |
#define toTITLE_utf8(p,s,l) to_utf8_title(p,s,l) |
488 |
#define toLOWER_utf8(p,s,l) to_utf8_lower(p,s,l) |
489 |
|
490 |
#define isPSXSPC_utf8(c) (isSPACE_utf8(c) ||(c) == '\f') |
491 |
#define isBLANK_utf8(c) isBLANK(c) /* could be wrong */ |
492 |
|
493 |
#define isALNUM_LC_utf8(p) isALNUM_LC_uvchr(utf8_to_uvchr(p, 0)) |
494 |
#define isIDFIRST_LC_utf8(p) isIDFIRST_LC_uvchr(utf8_to_uvchr(p, 0)) |
495 |
#define isALPHA_LC_utf8(p) isALPHA_LC_uvchr(utf8_to_uvchr(p, 0)) |
496 |
#define isSPACE_LC_utf8(p) isSPACE_LC_uvchr(utf8_to_uvchr(p, 0)) |
497 |
#define isDIGIT_LC_utf8(p) isDIGIT_LC_uvchr(utf8_to_uvchr(p, 0)) |
498 |
#define isUPPER_LC_utf8(p) isUPPER_LC_uvchr(utf8_to_uvchr(p, 0)) |
499 |
#define isLOWER_LC_utf8(p) isLOWER_LC_uvchr(utf8_to_uvchr(p, 0)) |
500 |
#define isALNUMC_LC_utf8(p) isALNUMC_LC_uvchr(utf8_to_uvchr(p, 0)) |
501 |
#define isCNTRL_LC_utf8(p) isCNTRL_LC_uvchr(utf8_to_uvchr(p, 0)) |
502 |
#define isGRAPH_LC_utf8(p) isGRAPH_LC_uvchr(utf8_to_uvchr(p, 0)) |
503 |
#define isPRINT_LC_utf8(p) isPRINT_LC_uvchr(utf8_to_uvchr(p, 0)) |
504 |
#define isPUNCT_LC_utf8(p) isPUNCT_LC_uvchr(utf8_to_uvchr(p, 0)) |
505 |
|
506 |
#define isPSXSPC_LC_utf8(c) (isSPACE_LC_utf8(c) ||(c) == '\f') |
507 |
#define isBLANK_LC_utf8(c) isBLANK(c) /* could be wrong */ |
508 |
|
509 |
#ifdef EBCDIC |
510 |
# ifdef PERL_IMPLICIT_CONTEXT |
511 |
# define toCTRL(c) Perl_ebcdic_control(aTHX_ c) |
512 |
# else |
513 |
# define toCTRL Perl_ebcdic_control |
514 |
# endif |
515 |
#else |
516 |
/* This conversion works both ways, strangely enough. */ |
517 |
# define toCTRL(c) (toUPPER(c) ^ 64) |
518 |
#endif |
519 |
|
520 |
/* Line numbers are unsigned, 32 bits. */ |
521 |
typedef U32 line_t; |
522 |
#ifdef lint |
523 |
#define NOLINE ((line_t)0) |
524 |
#else |
525 |
#define NOLINE ((line_t) 4294967295UL) |
526 |
#endif |
527 |
|
528 |
|
529 |
/* |
530 |
=head1 SV Manipulation Functions |
531 |
|
532 |
=for apidoc Am|SV*|NEWSV|int id|STRLEN len |
533 |
Creates a new SV. A non-zero C<len> parameter indicates the number of |
534 |
bytes of preallocated string space the SV should have. An extra byte for a |
535 |
tailing NUL is also reserved. (SvPOK is not set for the SV even if string |
536 |
space is allocated.) The reference count for the new SV is set to 1. |
537 |
C<id> is an integer id between 0 and 1299 (used to identify leaks). |
538 |
|
539 |
=head1 Memory Management |
540 |
|
541 |
=for apidoc Am|void|New|int id|void* ptr|int nitems|type |
542 |
The XSUB-writer's interface to the C C<malloc> function. |
543 |
|
544 |
=for apidoc Am|void|Newc|int id|void* ptr|int nitems|type|cast |
545 |
The XSUB-writer's interface to the C C<malloc> function, with |
546 |
cast. |
547 |
|
548 |
=for apidoc Am|void|Newz|int id|void* ptr|int nitems|type |
549 |
The XSUB-writer's interface to the C C<malloc> function. The allocated |
550 |
memory is zeroed with C<memzero>. |
551 |
|
552 |
=for apidoc Am|void|Renew|void* ptr|int nitems|type |
553 |
The XSUB-writer's interface to the C C<realloc> function. |
554 |
|
555 |
=for apidoc Am|void|Renewc|void* ptr|int nitems|type|cast |
556 |
The XSUB-writer's interface to the C C<realloc> function, with |
557 |
cast. |
558 |
|
559 |
=for apidoc Am|void|Safefree|void* ptr |
560 |
The XSUB-writer's interface to the C C<free> function. |
561 |
|
562 |
=for apidoc Am|void|Move|void* src|void* dest|int nitems|type |
563 |
The XSUB-writer's interface to the C C<memmove> function. The C<src> is the |
564 |
source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is |
565 |
the type. Can do overlapping moves. See also C<Copy>. |
566 |
|
567 |
=for apidoc Am|void *|MoveD|void* src|void* dest|int nitems|type |
568 |
Like C<Move> but returns dest. Useful for encouraging compilers to tail-call |
569 |
optimise. |
570 |
|
571 |
=for apidoc Am|void|Copy|void* src|void* dest|int nitems|type |
572 |
The XSUB-writer's interface to the C C<memcpy> function. The C<src> is the |
573 |
source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is |
574 |
the type. May fail on overlapping copies. See also C<Move>. |
575 |
|
576 |
=for apidoc Am|void *|CopyD|void* src|void* dest|int nitems|type |
577 |
|
578 |
Like C<Copy> but returns dest. Useful for encouraging compilers to tail-call |
579 |
optimise. |
580 |
|
581 |
=for apidoc Am|void|Zero|void* dest|int nitems|type |
582 |
|
583 |
The XSUB-writer's interface to the C C<memzero> function. The C<dest> is the |
584 |
destination, C<nitems> is the number of items, and C<type> is the type. |
585 |
|
586 |
=for apidoc Am|void *|ZeroD|void* dest|int nitems|type |
587 |
|
588 |
Like C<Zero> but returns dest. Useful for encouraging compilers to tail-call |
589 |
optimise. |
590 |
|
591 |
=for apidoc Am|void|StructCopy|type src|type dest|type |
592 |
This is an architecture-independent macro to copy one structure to another. |
593 |
|
594 |
=for apidoc Am|void|Poison|void* dest|int nitems|type |
595 |
|
596 |
Fill up memory with a pattern (byte 0xAB over and over again) that |
597 |
hopefully catches attempts to access uninitialized memory. |
598 |
|
599 |
=cut */ |
600 |
|
601 |
#ifndef lint |
602 |
|
603 |
#define NEWSV(x,len) newSV(len) |
604 |
|
605 |
#ifdef PERL_MALLOC_WRAP |
606 |
#define MEM_WRAP_CHECK(n,t) \ |
607 |
(void)((n)>((MEM_SIZE)~0)/sizeof(t)?(Perl_croak_nocontext(PL_memory_wrap),0):0) |
608 |
#define MEM_WRAP_CHECK_1(n,t,a) \ |
609 |
(void)((n)>((MEM_SIZE)~0)/sizeof(t)?(Perl_croak_nocontext(a),0):0) |
610 |
#define MEM_WRAP_CHECK_2(n,t,a,b) \ |
611 |
(void)((n)>((MEM_SIZE)~0)/sizeof(t)?(Perl_croak_nocontext(a,b),0):0) |
612 |
|
613 |
#define New(x,v,n,t) (v = (MEM_WRAP_CHECK(n,t), (t*)safemalloc((MEM_SIZE)((n)*sizeof(t))))) |
614 |
#define Newc(x,v,n,t,c) (v = (MEM_WRAP_CHECK(n,t), (c*)safemalloc((MEM_SIZE)((n)*sizeof(t))))) |
615 |
#define Newz(x,v,n,t) (v = (MEM_WRAP_CHECK(n,t), (t*)safemalloc((MEM_SIZE)((n)*sizeof(t))))), \ |
616 |
memzero((char*)(v), (n)*sizeof(t)) |
617 |
#define Renew(v,n,t) \ |
618 |
(v = (MEM_WRAP_CHECK(n,t), (t*)saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t))))) |
619 |
#define Renewc(v,n,t,c) \ |
620 |
(v = (MEM_WRAP_CHECK(n,t), (c*)saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t))))) |
621 |
#define Safefree(d) safefree((Malloc_t)(d)) |
622 |
|
623 |
#define Move(s,d,n,t) (MEM_WRAP_CHECK(n,t), (void)memmove((char*)(d),(char*)(s), (n) * sizeof(t))) |
624 |
#define Copy(s,d,n,t) (MEM_WRAP_CHECK(n,t), (void)memcpy((char*)(d),(char*)(s), (n) * sizeof(t))) |
625 |
#define Zero(d,n,t) (MEM_WRAP_CHECK(n,t), (void)memzero((char*)(d), (n) * sizeof(t))) |
626 |
|
627 |
#define MoveD(s,d,n,t) (MEM_WRAP_CHECK(n,t), memmove((char*)(d),(char*)(s), (n) * sizeof(t))) |
628 |
#define CopyD(s,d,n,t) (MEM_WRAP_CHECK(n,t), memcpy((char*)(d),(char*)(s), (n) * sizeof(t))) |
629 |
#ifdef HAS_MEMSET |
630 |
#define ZeroD(d,n,t) (MEM_WRAP_CHECK(n,t), memzero((char*)(d), (n) * sizeof(t))) |
631 |
#else |
632 |
/* Using bzero(), which returns void. */ |
633 |
#define ZeroD(d,n,t) (MEM_WRAP_CHECK(n,t), memzero((char*)(d), (n) * sizeof(t)),d) |
634 |
#endif |
635 |
|
636 |
#define Poison(d,n,t) (MEM_WRAP_CHECK(n,t), (void)memset((char*)(d), 0xAB, (n) * sizeof(t))) |
637 |
|
638 |
#else |
639 |
|
640 |
#define MEM_WRAP_CHECK(n,t) |
641 |
#define MEM_WRAP_CHECK_1(n,t,a) |
642 |
#define MEM_WRAP_CHECK_2(n,t,a,b) |
643 |
|
644 |
#define New(x,v,n,t) (v = (t*)safemalloc((MEM_SIZE)((n)*sizeof(t)))) |
645 |
#define Newc(x,v,n,t,c) (v = (c*)safemalloc((MEM_SIZE)((n)*sizeof(t)))) |
646 |
#define Newz(x,v,n,t) (v = (t*)safemalloc((MEM_SIZE)((n)*sizeof(t)))), \ |
647 |
memzero((char*)(v), (n)*sizeof(t)) |
648 |
#define Renew(v,n,t) \ |
649 |
(v = (t*)saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t)))) |
650 |
#define Renewc(v,n,t,c) \ |
651 |
(v = (c*)saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t)))) |
652 |
#define Safefree(d) safefree((Malloc_t)(d)) |
653 |
|
654 |
#define Move(s,d,n,t) (void)memmove((char*)(d),(char*)(s), (n) * sizeof(t)) |
655 |
#define Copy(s,d,n,t) (void)memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) |
656 |
#define Zero(d,n,t) (void)memzero((char*)(d), (n) * sizeof(t)) |
657 |
|
658 |
#define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t)) |
659 |
#define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) |
660 |
#ifdef HAS_MEMSET |
661 |
#define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) |
662 |
#else |
663 |
#define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)),d) |
664 |
#endif |
665 |
|
666 |
#define Poison(d,n,t) (void)memset((char*)(d), 0xAB, (n) * sizeof(t)) |
667 |
|
668 |
#endif |
669 |
|
670 |
#else /* lint */ |
671 |
|
672 |
#define New(x,v,n,s) (v = Null(s *)) |
673 |
#define Newc(x,v,n,s,c) (v = Null(s *)) |
674 |
#define Newz(x,v,n,s) (v = Null(s *)) |
675 |
#define Renew(v,n,s) (v = Null(s *)) |
676 |
#define Move(s,d,n,t) |
677 |
#define Copy(s,d,n,t) |
678 |
#define Zero(d,n,t) |
679 |
#define MoveD(s,d,n,t) d |
680 |
#define CopyD(s,d,n,t) d |
681 |
#define ZeroD(d,n,t) d |
682 |
#define Poison(d,n,t) |
683 |
#define Safefree(d) (d) = (d) |
684 |
|
685 |
#endif /* lint */ |
686 |
|
687 |
#ifdef USE_STRUCT_COPY |
688 |
#define StructCopy(s,d,t) (*((t*)(d)) = *((t*)(s))) |
689 |
#else |
690 |
#define StructCopy(s,d,t) Copy(s,d,1,t) |
691 |
#endif |
692 |
|
693 |
#define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) |
694 |
|
695 |
#ifdef NEED_VA_COPY |
696 |
# ifdef va_copy |
697 |
# define Perl_va_copy(s, d) va_copy(d, s) |
698 |
# else |
699 |
# if defined(__va_copy) |
700 |
# define Perl_va_copy(s, d) __va_copy(d, s) |
701 |
# else |
702 |
# define Perl_va_copy(s, d) Copy(s, d, 1, va_list) |
703 |
# endif |
704 |
# endif |
705 |
#endif |
706 |
|
707 |
/* convenience debug macros */ |
708 |
#ifdef USE_ITHREADS |
709 |
#define pTHX_FORMAT "Perl interpreter: 0x%p" |
710 |
#define pTHX__FORMAT ", Perl interpreter: 0x%p" |
711 |
#define pTHX_VALUE_ (unsigned long)my_perl, |
712 |
#define pTHX_VALUE (unsigned long)my_perl |
713 |
#define pTHX__VALUE_ ,(unsigned long)my_perl, |
714 |
#define pTHX__VALUE ,(unsigned long)my_perl |
715 |
#else |
716 |
#define pTHX_FORMAT |
717 |
#define pTHX__FORMAT |
718 |
#define pTHX_VALUE_ |
719 |
#define pTHX_VALUE |
720 |
#define pTHX__VALUE_ |
721 |
#define pTHX__VALUE |
722 |
#endif /* USE_ITHREADS */ |