iframe-proxy | Sunbelt Computer Software

History

207 lines (180 loc) · 8.09 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

#ifndef Py_LONGOBJECT_H

#define Py_LONGOBJECT_H

#ifdef __cplusplus

extern "C" {

#endif

/* Long (arbitrary precision) integer object interface */

typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */

PyAPI_DATA(PyTypeObject) PyLong_Type;

#define PyLong_Check(op) \

PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)

#define PyLong_CheckExact(op) (Py_TYPE(op) == &PyLong_Type)

PyAPI_FUNC(PyObject *) PyLong_FromLong(long);

PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long);

PyAPI_FUNC(PyObject *) PyLong_FromSize_t(size_t);

PyAPI_FUNC(PyObject *) PyLong_FromSsize_t(Py_ssize_t);

PyAPI_FUNC(PyObject *) PyLong_FromDouble(double);

PyAPI_FUNC(long) PyLong_AsLong(PyObject *);

PyAPI_FUNC(long) PyLong_AsLongAndOverflow(PyObject *, int *);

PyAPI_FUNC(Py_ssize_t) PyLong_AsSsize_t(PyObject *);

PyAPI_FUNC(size_t) PyLong_AsSize_t(PyObject *);

PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);

PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(int) _PyLong_AsInt(PyObject *);

#endif

PyAPI_FUNC(PyObject *) PyLong_GetInfo(void);

/* It may be useful in the future. I've added it in the PyInt -> PyLong

cleanup to keep the extra information. [CH] */

#define PyLong_AS_LONG(op) PyLong_AsLong(op)

/* Issue #1983: pid_t can be longer than a C long on some systems */

#if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT

#define _Py_PARSE_PID "i"

#define PyLong_FromPid PyLong_FromLong

#define PyLong_AsPid PyLong_AsLong

#elif SIZEOF_PID_T == SIZEOF_LONG

#define _Py_PARSE_PID "l"

#define PyLong_FromPid PyLong_FromLong

#define PyLong_AsPid PyLong_AsLong

#elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG

#define _Py_PARSE_PID "L"

#define PyLong_FromPid PyLong_FromLongLong

#define PyLong_AsPid PyLong_AsLongLong

#else

#error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)"

#endif /* SIZEOF_PID_T */

#if SIZEOF_VOID_P == SIZEOF_INT

# define _Py_PARSE_INTPTR "i"

# define _Py_PARSE_UINTPTR "I"

#elif SIZEOF_VOID_P == SIZEOF_LONG

# define _Py_PARSE_INTPTR "l"

# define _Py_PARSE_UINTPTR "k"

#elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG

# define _Py_PARSE_INTPTR "L"

# define _Py_PARSE_UINTPTR "K"

#else

# error "void* different in size from int, long and long long"

#endif /* SIZEOF_VOID_P */

/* Used by Python/mystrtoul.c. */

#ifndef Py_LIMITED_API

PyAPI_DATA(unsigned char) _PyLong_DigitValue[256];

#endif

/* _PyLong_Frexp returns a double x and an exponent e such that the

true value is approximately equal to x * 2**e. e is >= 0. x is

0.0 if and only if the input is 0 (in which case, e and x are both

zeroes); otherwise, 0.5 <= abs(x) < 1.0. On overflow, which is

possible if the number of bits doesn't fit into a Py_ssize_t, sets

OverflowError and returns -1.0 for x, 0 for e. */

#ifndef Py_LIMITED_API

PyAPI_FUNC(double) _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e);

#endif

PyAPI_FUNC(double) PyLong_AsDouble(PyObject *);

PyAPI_FUNC(PyObject *) PyLong_FromVoidPtr(void *);

PyAPI_FUNC(void *) PyLong_AsVoidPtr(PyObject *);

#ifdef HAVE_LONG_LONG

PyAPI_FUNC(PyObject *) PyLong_FromLongLong(PY_LONG_LONG);

PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG);

PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLong(PyObject *);

PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLong(PyObject *);

PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *);

PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLongAndOverflow(PyObject *, int *);

#endif /* HAVE_LONG_LONG */

PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int);

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);

PyAPI_FUNC(PyObject *) PyLong_FromUnicodeObject(PyObject *u, int base);

PyAPI_FUNC(PyObject *) _PyLong_FromBytes(const char *, Py_ssize_t, int);

#endif

#ifndef Py_LIMITED_API

/* _PyLong_Sign. Return 0 if v is 0, -1 if v < 0, +1 if v > 0.

v must not be NULL, and must be a normalized long.

There are no error cases.

PyAPI_FUNC(int) _PyLong_Sign(PyObject *v);

/* _PyLong_NumBits. Return the number of bits needed to represent the

absolute value of a long. For example, this returns 1 for 1 and -1, 2

for 2 and -2, and 2 for 3 and -3. It returns 0 for 0.

v must not be NULL, and must be a normalized long.

(size_t)-1 is returned and OverflowError set if the true result doesn't

fit in a size_t.

PyAPI_FUNC(size_t) _PyLong_NumBits(PyObject *v);

/* _PyLong_DivmodNear. Given integers a and b, compute the nearest

integer q to the exact quotient a / b, rounding to the nearest even integer

in the case of a tie. Return (q, r), where r = a - q*b. The remainder r

will satisfy abs(r) <= abs(b)/2, with equality possible only if q is

even.

PyAPI_FUNC(PyObject *) _PyLong_DivmodNear(PyObject *, PyObject *);

/* _PyLong_FromByteArray: View the n unsigned bytes as a binary integer in

base 256, and return a Python int with the same numeric value.

If n is 0, the integer is 0. Else:

If little_endian is 1/true, bytes[n-1] is the MSB and bytes[0] the LSB;

else (little_endian is 0/false) bytes[0] is the MSB and bytes[n-1] the

LSB.

If is_signed is 0/false, view the bytes as a non-negative integer.

If is_signed is 1/true, view the bytes as a 2's-complement integer,

non-negative if bit 0x80 of the MSB is clear, negative if set.

Error returns:

+ Return NULL with the appropriate exception set if there's not

enough memory to create the Python int.

PyAPI_FUNC(PyObject *) _PyLong_FromByteArray(

const unsigned char* bytes, size_t n,

int little_endian, int is_signed);

/* _PyLong_AsByteArray: Convert the least-significant 8*n bits of long

v to a base-256 integer, stored in array bytes. Normally return 0,

return -1 on error.

If little_endian is 1/true, store the MSB at bytes[n-1] and the LSB at

bytes[0]; else (little_endian is 0/false) store the MSB at bytes[0] and

the LSB at bytes[n-1].

If is_signed is 0/false, it's an error if v < 0; else (v >= 0) n bytes

are filled and there's nothing special about bit 0x80 of the MSB.

If is_signed is 1/true, bytes is filled with the 2's-complement

representation of v's value. Bit 0x80 of the MSB is the sign bit.

Error returns (-1):

+ is_signed is 0 and v < 0. TypeError is set in this case, and bytes

isn't altered.

+ n isn't big enough to hold the full mathematical value of v. For

example, if is_signed is 0 and there are more digits in the v than

fit in n; or if is_signed is 1, v < 0, and n is just 1 bit shy of

being large enough to hold a sign bit. OverflowError is set in this

case, but bytes holds the least-significant n bytes of the true value.

PyAPI_FUNC(int) _PyLong_AsByteArray(PyLongObject* v,

unsigned char* bytes, size_t n,

int little_endian, int is_signed);

/* _PyLong_FromNbInt: Convert the given object to a PyLongObject

using the nb_int slot, if available. Raise TypeError if either the

nb_int slot is not available or the result of the call to nb_int

returns something not of type int.

PyAPI_FUNC(PyLongObject *)_PyLong_FromNbInt(PyObject *);

/* _PyLong_Format: Convert the long to a string object with given base,

appending a base prefix of 0[box] if base is 2, 8 or 16. */

PyAPI_FUNC(PyObject *) _PyLong_Format(PyObject *obj, int base);

PyAPI_FUNC(int) _PyLong_FormatWriter(

_PyUnicodeWriter *writer,

PyObject *obj,

int base,

int alternate);

/* Format the object based on the format_spec, as defined in PEP 3101

(Advanced String Formatting). */

PyAPI_FUNC(int) _PyLong_FormatAdvancedWriter(

_PyUnicodeWriter *writer,

PyObject *obj,

PyObject *format_spec,

Py_ssize_t start,

Py_ssize_t end);

#endif /* Py_LIMITED_API */

/* These aren't really part of the int object, but they're handy. The

functions are in Python/mystrtoul.c.

PyAPI_FUNC(unsigned long) PyOS_strtoul(const char *, char **, int);

PyAPI_FUNC(long) PyOS_strtol(const char *, char **, int);

/* For use by the gcd function in mathmodule.c */

PyAPI_FUNC(PyObject *) _PyLong_GCD(PyObject *, PyObject *);

#ifdef __cplusplus

}

#endif

#endif /* !Py_LONGOBJECT_H */

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

FilesExpand file tree

longobject.h

Latest commit

History

longobject.h

File metadata and controls