1N/Apackage Devel::PPPort;

1N/A

1N/A

1N/A

1N/Apackage Devel::PPPort;

1N/A

1N/Arequire Exporter;

1N/Arequire DynaLoader;

1N/Ause strict;

1N/Ause vars qw( $VERSION @ISA @EXPORT @EXPORT_OK $data );

1N/A

1N/A$VERSION = "2.011";

1N/A

1N/A@ISA = qw(Exporter DynaLoader);

1N/A@EXPORT = qw();

1N/A@EXPORT_OK = qw( );

1N/A

1N/Abootstrap Devel::PPPort;

1N/A

1N/Apackage Devel::PPPort;

1N/A

1N/A{

1N/A local $/ = undef;

1N/A $data = <DATA> ;

1N/A my $now = localtime;

1N/A my $pkg = __PACKAGE__;

1N/A $data =~ s/__VERSION__/$VERSION/g;

1N/A $data =~ s/__DATE__/$now/g;

1N/A $data =~ s/__PKG__/$pkg/g;

1N/A}

1N/A

1N/Asub WriteFile

1N/A{

1N/A my $file = shift || 'ppport.h' ;

1N/A

1N/A open F, ">$file" || return undef ;

1N/A print F $data ;

1N/A close F;

1N/A

1N/A return 1 ;

1N/A}

1N/A

1N/A1;

1N/A

1N/A__DATA__;

1N/A

1N/A/* ppport.h -- Perl/Pollution/Portability Version __VERSION__

1N/A *

1N/A * Automatically Created by __PKG__ on __DATE__

1N/A *

1N/A * Do NOT edit this file directly! -- Edit PPPort.pm instead.

1N/A *

1N/A * Version 2.x, Copyright (C) 2001, Paul Marquess.

1N/A * Version 1.x, Copyright (C) 1999, Kenneth Albanowski.

1N/A * This code may be used and distributed under the same license as any

1N/A * version of Perl.

1N/A *

1N/A * This version of ppport.h is designed to support operation with Perl

1N/A * installations back to 5.004, and has been tested up to 5.8.1.

1N/A *

1N/A * If this version of ppport.h is failing during the compilation of this

1N/A * module, please check if a newer version of Devel::PPPort is available

1N/A * on CPAN before sending a bug report.

1N/A *

1N/A * If you are using the latest version of Devel::PPPort and it is failing

1N/A * during compilation of this module, please send a report to perlbug@perl.com

1N/A *

1N/A * Include all following information:

1N/A *

1N/A * 1. The complete output from running "perl -V"

1N/A *

1N/A * 2. This file.

1N/A *

1N/A * 3. The name & version of the module you were trying to build.

1N/A *

1N/A * 4. A full log of the build that failed.

1N/A *

1N/A * 5. Any other information that you think could be relevant.

1N/A *

1N/A *

1N/A * For the latest version of this code, please retreive the Devel::PPPort

1N/A * module from CPAN.

1N/A *

1N/A */

1N/A

1N/A/*

1N/A * In order for a Perl extension module to be as portable as possible

1N/A * across differing versions of Perl itself, certain steps need to be taken.

1N/A * Including this header is the first major one, then using dTHR is all the

1N/A * appropriate places and using a PL_ prefix to refer to global Perl

1N/A * variables is the second.

1N/A *

1N/A */

1N/A

1N/A

1N/A/* If you use one of a few functions that were not present in earlier

1N/A * versions of Perl, please add a define before the inclusion of ppport.h

1N/A * for a static include, or use the GLOBAL request in a single module to

1N/A * produce a global definition that can be referenced from the other

1N/A * modules.

1N/A *

1N/A * Function: Static define: Extern define:

1N/A * newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL

1N/A *

1N/A */

1N/A

1N/A

1N/A/* To verify whether ppport.h is needed for your module, and whether any

1N/A * special defines should be used, ppport.h can be run through Perl to check

1N/A * your source code. Simply say:

1N/A *

1N/A * perl -x ppport.h *.c *.h *.xs foo/bar*.c [etc]

1N/A *

1N/A * The result will be a list of patches suggesting changes that should at

1N/A * least be acceptable, if not necessarily the most efficient solution, or a

1N/A * fix for all possible problems. It won't catch where dTHR is needed, and

1N/A * doesn't attempt to account for global macro or function definitions,

1N/A * nested includes, typemaps, etc.

1N/A *

1N/A * In order to test for the need of dTHR, please try your module under a

1N/A * recent version of Perl that has threading compiled-in.

1N/A *

1N/A */

1N/A

1N/A

1N/A/*

1N/A@ARGV = ("*.xs") if !@ARGV;

1N/A%badmacros = %funcs = %macros = (); $replace = 0;

1N/Aforeach (<DATA>) {

1N/A $funcs{$1} = 1 if /Provide:\s+(\S+)/;

1N/A $macros{$1} = 1 if /^#\s*define\s+([a-zA-Z0-9_]+)/;

1N/A $replace = $1 if /Replace:\s+(\d+)/;

1N/A $badmacros{$2}=$1 if $replace and /^#\s*define\s+([a-zA-Z0-9_]+).*?\s+([a-zA-Z0-9_]+)/;

1N/A $badmacros{$1}=$2 if /Replace (\S+) with (\S+)/;

1N/A}

1N/Aforeach $filename (map(glob($_),@ARGV)) {

1N/A unless (open(IN, "<$filename")) {

1N/A warn "Unable to read from $file: $!\n";

1N/A next;

1N/A }

1N/A print "Scanning $filename...\n";

1N/A $c = ""; while (<IN>) { $c .= $_; } close(IN);

1N/A $need_include = 0; %add_func = (); $changes = 0;

1N/A $has_include = ($c =~ /#.*include.*ppport/m);

1N/A

1N/A foreach $func (keys %funcs) {

1N/A if ($c =~ /#.*define.*\bNEED_$func(_GLOBAL)?\b/m) {

1N/A if ($c !~ /\b$func\b/m) {

1N/A print "If $func isn't needed, you don't need to request it.\n" if

1N/A $changes += ($c =~ s/^.*#.*define.*\bNEED_$func\b.*\n//m);

1N/A } else {

1N/A print "Uses $func\n";

1N/A $need_include = 1;

1N/A }

1N/A } else {

1N/A if ($c =~ /\b$func\b/m) {

1N/A $add_func{$func} =1 ;

1N/A print "Uses $func\n";

1N/A $need_include = 1;

1N/A }

1N/A }

1N/A }

1N/A

1N/A if (not $need_include) {

1N/A foreach $macro (keys %macros) {

1N/A if ($c =~ /\b$macro\b/m) {

1N/A print "Uses $macro\n";

1N/A $need_include = 1;

1N/A }

1N/A }

1N/A }

1N/A

1N/A foreach $badmacro (keys %badmacros) {

1N/A if ($c =~ /\b$badmacro\b/m) {

1N/A $changes += ($c =~ s/\b$badmacro\b/$badmacros{$badmacro}/gm);

1N/A print "Uses $badmacros{$badmacro} (instead of $badmacro)\n";

1N/A $need_include = 1;

1N/A }

1N/A }

1N/A

1N/A if (scalar(keys %add_func) or $need_include != $has_include) {

1N/A if (!$has_include) {

1N/A $inc = join('',map("#define NEED_$_\n", sort keys %add_func)).

1N/A "#include \"ppport.h\"\n";

1N/A $c = "$inc$c" unless $c =~ s/#.*include.*XSUB.*\n/$&$inc/m;

1N/A } elsif (keys %add_func) {

1N/A $inc = join('',map("#define NEED_$_\n", sort keys %add_func));

1N/A $c = "$inc$c" unless $c =~ s/^.*#.*include.*ppport.*$/$inc$&/m;

1N/A }

1N/A if (!$need_include) {

1N/A print "Doesn't seem to need ppport.h.\n";

1N/A $c =~ s/^.*#.*include.*ppport.*\n//m;

1N/A }

1N/A $changes++;

1N/A }

1N/A

1N/A if ($changes) {

1N/A open(OUT,">/tmp/ppport.h.$$");

1N/A print OUT $c;

1N/A close(OUT);

1N/A open(DIFF, "diff -u $filename /tmp/ppport.h.$$|");

1N/A while (<DIFF>) { s!/tmp/ppport\.h\.$$!$filename.patched!; print STDOUT; }

1N/A close(DIFF);

1N/A unlink("/tmp/ppport.h.$$");

1N/A } else {

1N/A print "Looks OK\n";

1N/A }

1N/A}

1N/A*/

1N/A

1N/A

1N/A /* Replace: 1 */

1N/A /* Replace PERL_PATCHLEVEL with PERL_VERSION */

1N/A /* Replace: 0 */

1N/A

1N/A

1N/A/* It is very unlikely that anyone will try to use this with Perl 6

1N/A (or greater), but who knows.

1N/A */

1N/A

1N/A

1N/A/* Replace: 1 */

1N/A/* Replace: 0 */

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A/* IV could also be a quad (say, a long long), but Perls

1N/A * capable of those should have IVSIZE already. */

1N/A

1N/A

1N/Atypedef NVTYPE NV;

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A/* Replace: 1 */

1N/A/* Replace: 0 */

1N/A

1N/A/* DEFSV appears first in 5.004_56 */

1N/A

1N/A

1N/A ({ \

1N/A SV *nsv = (SV*)newRV(sv); \

1N/A SvREFCNT_dec(sv); \

1N/A nsv; \

1N/A })

1N/Astatic SV * newRV_noinc (SV * sv)

1N/A{

1N/A SV *nsv = (SV*)newRV(sv);

1N/A SvREFCNT_dec(sv);

1N/A return nsv;

1N/A}

1N/A (PL_Sv=(SV*)newRV(sv), SvREFCNT_dec(sv), (SV*)PL_Sv)

1N/A

1N/A/* Provide: newCONSTSUB */

1N/A

1N/A/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */

1N/A

1N/Aextern void newCONSTSUB(HV * stash, char * name, SV *sv);

1N/A

1N/AnewCONSTSUB(stash,name,sv)

1N/AHV *stash;

1N/Achar *name;

1N/ASV *sv;

1N/A{

1N/A U32 oldhints = PL_hints;

1N/A HV *old_cop_stash = PL_curcop->cop_stash;

1N/A HV *old_curstash = PL_curstash;

1N/A line_t oldline = PL_curcop->cop_line;

1N/A PL_curcop->cop_line = PL_copline;

1N/A

1N/A PL_hints &= ~HINT_BLOCK_SCOPE;

1N/A if (stash)

1N/A PL_curstash = PL_curcop->cop_stash = stash;

1N/A

1N/A newSUB(

1N/A

1N/A /* before 5.003_22 */

1N/A start_subparse(),

1N/A /* 5.003_22 */

1N/A start_subparse(0),

1N/A /* 5.003_23 onwards */

1N/A start_subparse(FALSE, 0),

1N/A

1N/A newSVOP(OP_CONST, 0, newSVpv(name,0)),

1N/A newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */

1N/A newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))

1N/A );

1N/A

1N/A PL_hints = oldhints;

1N/A PL_curcop->cop_stash = old_cop_stash;

1N/A PL_curstash = old_curstash;

1N/A PL_curcop->cop_line = oldline;

1N/A}

1N/A

1N/A

1N/A

1N/A/*

1N/A * Boilerplate macros for initializing and accessing interpreter-local

1N/A * data from C. All statics in extensions should be reworked to use

1N/A * this, if you want to make the extension thread-safe. See ext/re/re.xs

1N/A * for an example of the use of these macros.

1N/A *

1N/A * Code that uses these macros is responsible for the following:

1N/A * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"

1N/A * 2. Declare a typedef named my_cxt_t that is a structure that contains

1N/A * all the data that needs to be interpreter-local.

1N/A * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.

1N/A * 4. Use the MY_CXT_INIT macro such that it is called exactly once

1N/A * (typically put in the BOOT: section).

1N/A * 5. Use the members of the my_cxt_t structure everywhere as

1N/A * MY_CXT.member.

1N/A * 6. Use the dMY_CXT macro (a declaration) in all the functions that

1N/A * access MY_CXT.

1N/A */

1N/A

1N/A defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT)

1N/A

1N/A/* This must appear in all extensions that define a my_cxt_t structure,

1N/A * right after the definition (i.e. at file scope). The non-threads

1N/A * case below uses it to declare the data as static. */

1N/A

1N/A/* Fetches the SV that keeps the per-interpreter data. */

1N/A SV *my_cxt_sv = perl_get_sv(MY_CXT_KEY, FALSE)

1N/A SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \

1N/A sizeof(MY_CXT_KEY)-1, TRUE)

1N/A

1N/A/* This declaration should be used within all functions that use the

1N/A * interpreter-local data. */

1N/A dMY_CXT_SV; \

1N/A my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))

1N/A

1N/A/* Creates and zeroes the per-interpreter data.

1N/A * (We allocate my_cxtp in a Perl SV so that it will be released when

1N/A * the interpreter goes away.) */

1N/A dMY_CXT_SV; \

1N/A /* newSV() allocates one more than needed */ \

1N/A my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\

1N/A Zero(my_cxtp, 1, my_cxt_t); \

1N/A sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))

1N/A

1N/A/* This macro must be used to access members of the my_cxt_t structure.

1N/A * e.g. MYCXT.some_data */

1N/A

1N/A/* Judicious use of these macros can reduce the number of times dMY_CXT

1N/A * is used. Use is similar to pTHX, aTHX etc. */

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A defined(PERL_PRIfldbl) /* Not very likely, but let's try anyway. */

1N/A

1N/A

1N/A /* SvPVbyte does not work in perl-5.6.1, borrowed version for 5.7.3 */

1N/A ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \

1N/A ? ((lp = SvCUR(sv)), SvPVX(sv)) : my_sv_2pvbyte(aTHX_ sv, &lp))

1N/A static char *

1N/A my_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)

1N/A {

1N/A sv_utf8_downgrade(sv,0);

1N/A return SvPV(sv,*lp);

1N/A }

1N/A

1N/A ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \

1N/A ? SvPVX(sv) : sv_2pv_nolen(sv))

1N/A static char *

1N/A sv_2pv_nolen(pTHX_ register SV *sv)

1N/A {

1N/A STRLEN n_a;

1N/A return sv_2pv(sv, &n_a);

1N/A }

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/Astatic UV _grok_hex (char *string, STRLEN *len, I32 *flags, NV *result) {

1N/A NV r = scan_hex(string, *len, I32_CAST len);

1N/A if (r > UV_MAX) {

1N/A *flags |= PERL_SCAN_GREATER_THAN_UV_MAX;

1N/A if (result) *result = r;

1N/A return UV_MAX;

1N/A }

1N/A return (UV)r;

1N/A}

1N/A

1N/A _grok_hex((string), (len), (flags), (result))

1N/A

1N/Astatic UV _grok_oct (char *string, STRLEN *len, I32 *flags, NV *result) {

1N/A NV r = scan_oct(string, *len, I32_CAST len);

1N/A if (r > UV_MAX) {

1N/A *flags |= PERL_SCAN_GREATER_THAN_UV_MAX;

1N/A if (result) *result = r;

1N/A return UV_MAX;

1N/A }

1N/A return (UV)r;

1N/A}

1N/A

1N/A _grok_oct((string), (len), (flags), (result))

1N/A

1N/Astatic UV _grok_bin (char *string, STRLEN *len, I32 *flags, NV *result) {

1N/A NV r = scan_bin(string, *len, I32_CAST len);

1N/A if (r > UV_MAX) {

1N/A *flags |= PERL_SCAN_GREATER_THAN_UV_MAX;

1N/A if (result) *result = r;

1N/A return UV_MAX;

1N/A }

1N/A return (UV)r;

1N/A}

1N/A

1N/A _grok_bin((string), (len), (flags), (result))

1N/A

1N/A (PL_curcop == &PL_compiling ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/APerl_grok_numeric_radix(pTHX_ const char **sp, const char *send)

1N/A{

1N/A if (PL_numeric_radix_sv && IN_LOCALE) {

1N/A STRLEN len;

1N/A char* radix = SvPV(PL_numeric_radix_sv, len);

1N/A if (*sp + len <= send && memEQ(*sp, radix, len)) {

1N/A *sp += len;

1N/A return TRUE;

1N/A }

1N/A }

1N/A /* pre5.6.0 perls don't have PL_numeric_radix_sv so the radix

1N/A * must manually be requested from locale.h */

1N/A struct lconv *lc = localeconv();

1N/A char *radix = lc->decimal_point;

1N/A if (radix && IN_LOCALE) {

1N/A STRLEN len = strlen(radix);

1N/A if (*sp + len <= send && memEQ(*sp, radix, len)) {

1N/A *sp += len;

1N/A return TRUE;

1N/A }

1N/A }

1N/A /* always try "." if numeric radix didn't match because

1N/A * we may have data from different locales mixed */

1N/A if (*sp < send && **sp == '.') {

1N/A ++*sp;

1N/A return TRUE;

1N/A }

1N/A return FALSE;

1N/A}

1N/A

1N/A

1N/A

1N/APerl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep)

1N/A{

1N/A const char *s = pv;

1N/A const char *send = pv + len;

1N/A const UV max_div_10 = UV_MAX / 10;

1N/A const char max_mod_10 = UV_MAX % 10;

1N/A int numtype = 0;

1N/A int sawinf = 0;

1N/A int sawnan = 0;

1N/A

1N/A while (s < send && isSPACE(*s))

1N/A s++;

1N/A if (s == send) {

1N/A return 0;

1N/A } else if (*s == '-') {

1N/A s++;

1N/A numtype = IS_NUMBER_NEG;

1N/A }

1N/A else if (*s == '+')

1N/A s++;

1N/A

1N/A if (s == send)

1N/A return 0;

1N/A

1N/A /* next must be digit or the radix separator or beginning of infinity */

1N/A if (isDIGIT(*s)) {

1N/A /* UVs are at least 32 bits, so the first 9 decimal digits cannot

1N/A overflow. */

1N/A UV value = *s - '0';

1N/A /* This construction seems to be more optimiser friendly.

1N/A (without it gcc does the isDIGIT test and the *s - '0' separately)

1N/A With it gcc on arm is managing 6 instructions (6 cycles) per digit.

1N/A In theory the optimiser could deduce how far to unroll the loop

1N/A before checking for overflow. */

1N/A if (++s < send) {

1N/A int digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A digit = *s - '0';

1N/A if (digit >= 0 && digit <= 9) {

1N/A value = value * 10 + digit;

1N/A if (++s < send) {

1N/A /* Now got 9 digits, so need to check

1N/A each time for overflow. */

1N/A digit = *s - '0';

1N/A while (digit >= 0 && digit <= 9

1N/A && (value < max_div_10

1N/A || (value == max_div_10

1N/A && digit <= max_mod_10))) {

1N/A value = value * 10 + digit;

1N/A if (++s < send)

1N/A digit = *s - '0';

1N/A else

1N/A break;

1N/A }

1N/A if (digit >= 0 && digit <= 9

1N/A && (s < send)) {

1N/A /* value overflowed.

1N/A skip the remaining digits, don't

1N/A worry about setting *valuep. */

1N/A do {

1N/A s++;

1N/A } while (s < send && isDIGIT(*s));

1N/A numtype |=

1N/A IS_NUMBER_GREATER_THAN_UV_MAX;

1N/A goto skip_value;

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A }

1N/A numtype |= IS_NUMBER_IN_UV;

1N/A if (valuep)

1N/A *valuep = value;

1N/A

1N/A skip_value:

1N/A if (GROK_NUMERIC_RADIX(&s, send)) {

1N/A numtype |= IS_NUMBER_NOT_INT;

1N/A while (s < send && isDIGIT(*s)) /* optional digits after the radix */

1N/A s++;

1N/A }

1N/A }

1N/A else if (GROK_NUMERIC_RADIX(&s, send)) {

1N/A numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */

1N/A /* no digits before the radix means we need digits after it */

1N/A if (s < send && isDIGIT(*s)) {

1N/A do {

1N/A s++;

1N/A } while (s < send && isDIGIT(*s));

1N/A if (valuep) {

1N/A /* integer approximation is valid - it's 0. */

1N/A *valuep = 0;

1N/A }

1N/A }

1N/A else

1N/A return 0;

1N/A } else if (*s == 'I' || *s == 'i') {

1N/A s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;

1N/A s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;

1N/A s++; if (s < send && (*s == 'I' || *s == 'i')) {

1N/A s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;

1N/A s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;

1N/A s++; if (s == send || (*s != 'T' && *s != 't')) return 0;

1N/A s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;

1N/A s++;

1N/A }

1N/A sawinf = 1;

1N/A } else if (*s == 'N' || *s == 'n') {

1N/A /* XXX TODO: There are signaling NaNs and quiet NaNs. */

1N/A s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;

1N/A s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;

1N/A s++;

1N/A sawnan = 1;

1N/A } else

1N/A return 0;

1N/A

1N/A if (sawinf) {

1N/A numtype &= IS_NUMBER_NEG; /* Keep track of sign */

1N/A numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;

1N/A } else if (sawnan) {

1N/A numtype &= IS_NUMBER_NEG; /* Keep track of sign */

1N/A numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;

1N/A } else if (s < send) {

1N/A /* we can have an optional exponent part */

1N/A if (*s == 'e' || *s == 'E') {

1N/A /* The only flag we keep is sign. Blow away any "it's UV" */

1N/A numtype &= IS_NUMBER_NEG;

1N/A numtype |= IS_NUMBER_NOT_INT;

1N/A s++;

1N/A if (s < send && (*s == '-' || *s == '+'))

1N/A s++;

1N/A if (s < send && isDIGIT(*s)) {

1N/A do {

1N/A s++;

1N/A } while (s < send && isDIGIT(*s));

1N/A }

1N/A else

1N/A return 0;

1N/A }

1N/A }

1N/A while (s < send && isSPACE(*s))

1N/A s++;

1N/A if (s >= send)

1N/A return numtype;

1N/A if (len == 10 && memEQ(pv, "0 but true", 10)) {

1N/A if (valuep)

1N/A *valuep = 0;

1N/A return IS_NUMBER_IN_UV;

1N/A }

1N/A return 0;

1N/A}

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A

1N/A/* End of File ppport.h */