From 9991fcb647a9e2abf0183e117a04ed8bac5391db Mon Sep 17 00:00:00 2001 From: Rudolf Polzer Date: Fri, 3 Sep 2010 13:44:01 +0200 Subject: [PATCH 1/1] dp.win64 build dependencies beginning (lacks SDL still) --- misc/builddeps/dp.win64/bin/libgmp-10.dll | Bin 0 -> 550860 bytes misc/builddeps/dp.win64/include/d3dtypes.h | 1698 ++++ misc/builddeps/dp.win64/include/ddraw.h | 4844 +++++++++++ misc/builddeps/dp.win64/include/dinput.h | 1849 +++++ misc/builddeps/dp.win64/include/dsound.h | 863 ++ misc/builddeps/dp.win64/include/gmp.h | 2280 ++++++ misc/builddeps/dp.win64/lib/libgmp.dll.a | Bin 0 -> 327030 bytes misc/builddeps/dp.win64/lib/libgmp.la | 41 + misc/builddeps/dp.win64/share/info/dir | 18 + misc/builddeps/dp.win64/share/info/gmp.info | 178 + misc/builddeps/dp.win64/share/info/gmp.info-1 | 7084 +++++++++++++++++ misc/builddeps/dp.win64/share/info/gmp.info-2 | 3489 ++++++++ 12 files changed, 22344 insertions(+) create mode 100755 misc/builddeps/dp.win64/bin/libgmp-10.dll create mode 100644 misc/builddeps/dp.win64/include/d3dtypes.h create mode 100644 misc/builddeps/dp.win64/include/ddraw.h create mode 100644 misc/builddeps/dp.win64/include/dinput.h create mode 100644 misc/builddeps/dp.win64/include/dsound.h create mode 100644 misc/builddeps/dp.win64/include/gmp.h create mode 100755 misc/builddeps/dp.win64/lib/libgmp.dll.a create mode 100755 misc/builddeps/dp.win64/lib/libgmp.la create mode 100644 misc/builddeps/dp.win64/share/info/dir create mode 100644 misc/builddeps/dp.win64/share/info/gmp.info create mode 100644 misc/builddeps/dp.win64/share/info/gmp.info-1 create mode 100644 misc/builddeps/dp.win64/share/info/gmp.info-2 diff --git a/misc/builddeps/dp.win64/bin/libgmp-10.dll b/misc/builddeps/dp.win64/bin/libgmp-10.dll new file mode 100755 index 0000000000000000000000000000000000000000..c8679dd74babdf07c5554afe0865fee9b684d74d GIT binary patch literal 550860 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 ASEcc-)%Z?ge1-89;=~btCm}xvaNz8C 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 DpHlC< literal 0 HcmV?d00001 diff --git a/misc/builddeps/dp.win64/include/d3dtypes.h b/misc/builddeps/dp.win64/include/d3dtypes.h new file mode 100644 index 00000000..e2e4a1a0 --- /dev/null +++ b/misc/builddeps/dp.win64/include/d3dtypes.h @@ -0,0 +1,1698 @@ +/*==========================================================================; + * + * Copyright (C) 1995-1998 Microsoft Corporation. All Rights Reserved. + * + * File: d3dtypes.h + * Content: Direct3D types include file + * + ***************************************************************************/ + +#ifndef _D3DTYPES_H_ +#define _D3DTYPES_H_ + +#include + +#include +#include + +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0600 +#endif + +#pragma pack(4) + + +/* D3DVALUE is the fundamental Direct3D fractional data type */ + +#define D3DVALP(val, prec) ((float)(val)) +#define D3DVAL(val) ((float)(val)) +typedef float D3DVALUE, *LPD3DVALUE; +#define D3DDivide(a, b) (float)((double) (a) / (double) (b)) +#define D3DMultiply(a, b) ((a) * (b)) + +typedef LONG D3DFIXED; + +#ifndef RGB_MAKE +/* + * Format of CI colors is + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | alpha | color index | fraction | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +#define CI_GETALPHA(ci) ((ci) >> 24) +#define CI_GETINDEX(ci) (((ci) >> 8) & 0xffff) +#define CI_GETFRACTION(ci) ((ci) & 0xff) +#define CI_ROUNDINDEX(ci) CI_GETINDEX((ci) + 0x80) +#define CI_MASKALPHA(ci) ((ci) & 0xffffff) +#define CI_MAKE(a, i, f) (((a) << 24) | ((i) << 8) | (f)) + +/* + * Format of RGBA colors is + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | alpha | red | green | blue | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +#define RGBA_GETALPHA(rgb) ((rgb) >> 24) +#define RGBA_GETRED(rgb) (((rgb) >> 16) & 0xff) +#define RGBA_GETGREEN(rgb) (((rgb) >> 8) & 0xff) +#define RGBA_GETBLUE(rgb) ((rgb) & 0xff) +#define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) + +/* D3DRGB and D3DRGBA may be used as initialisers for D3DCOLORs + * The float values must be in the range 0..1 + */ +#define D3DRGB(r, g, b) \ + (0xff000000L | ( ((long)((r) * 255)) << 16) | (((long)((g) * 255)) << 8) | (long)((b) * 255)) +#define D3DRGBA(r, g, b, a) \ + ( (((long)((a) * 255)) << 24) | (((long)((r) * 255)) << 16) \ + | (((long)((g) * 255)) << 8) | (long)((b) * 255) \ + ) + +/* + * Format of RGB colors is + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | ignored | red | green | blue | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +#define RGB_GETRED(rgb) (((rgb) >> 16) & 0xff) +#define RGB_GETGREEN(rgb) (((rgb) >> 8) & 0xff) +#define RGB_GETBLUE(rgb) ((rgb) & 0xff) +#define RGBA_SETALPHA(rgba, x) (((x) << 24) | ((rgba) & 0x00ffffff)) +#define RGB_MAKE(r, g, b) ((D3DCOLOR) (((r) << 16) | ((g) << 8) | (b))) +#define RGBA_TORGB(rgba) ((D3DCOLOR) ((rgba) & 0xffffff)) +#define RGB_TORGBA(rgb) ((D3DCOLOR) ((rgb) | 0xff000000)) + +#endif + +/* + * Flags for Enumerate functions + */ + +/* + * Stop the enumeration + */ +#define D3DENUMRET_CANCEL DDENUMRET_CANCEL + +/* + * Continue the enumeration + */ +#define D3DENUMRET_OK DDENUMRET_OK + +typedef HRESULT (CALLBACK* LPD3DVALIDATECALLBACK)(LPVOID lpUserArg, DWORD dwOffset); +typedef HRESULT (CALLBACK* LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC lpDdsd, LPVOID lpContext); +typedef HRESULT (CALLBACK* LPD3DENUMPIXELFORMATSCALLBACK)(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext); + +typedef DWORD D3DCOLOR, *LPD3DCOLOR; + +typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE; +typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE; +typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE; + +typedef struct _D3DCOLORVALUE { + union { + D3DVALUE r; + D3DVALUE dvR; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DVALUE g; + D3DVALUE dvG; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DVALUE b; + D3DVALUE dvB; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + union { + D3DVALUE a; + D3DVALUE dvA; +#if defined(NONAMELESSUNION) + } u4; +#else + }; +#endif +} D3DCOLORVALUE, *LPD3DCOLORVALUE; + +typedef struct _D3DRECT { + union { + LONG x1; + LONG lX1; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + LONG y1; + LONG lY1; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + LONG x2; + LONG lX2; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + union { + LONG y2; + LONG lY2; +#if defined(NONAMELESSUNION) + } u4; +#else + }; +#endif +} D3DRECT, *LPD3DRECT; + +typedef struct _D3DVECTOR { + union { + D3DVALUE x; + D3DVALUE dvX; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DVALUE y; + D3DVALUE dvY; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DVALUE z; + D3DVALUE dvZ; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + +public: + + // ===================================== + // Constructors + // ===================================== + + _D3DVECTOR() { } + _D3DVECTOR(D3DVALUE f); + _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z); + _D3DVECTOR(const D3DVALUE f[3]); + + // ===================================== + // Access grants + // ===================================== + + const D3DVALUE&operator[](int i) const; + D3DVALUE&operator[](int i); + + // ===================================== + // Assignment operators + // ===================================== + + _D3DVECTOR& operator += (const _D3DVECTOR& v); + _D3DVECTOR& operator -= (const _D3DVECTOR& v); + _D3DVECTOR& operator *= (const _D3DVECTOR& v); + _D3DVECTOR& operator /= (const _D3DVECTOR& v); + _D3DVECTOR& operator *= (D3DVALUE s); + _D3DVECTOR& operator /= (D3DVALUE s); + + // ===================================== + // Unary operators + // ===================================== + + friend _D3DVECTOR operator + (const _D3DVECTOR& v); + friend _D3DVECTOR operator - (const _D3DVECTOR& v); + + + // ===================================== + // Binary operators + // ===================================== + + // Addition and subtraction + friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + // Scalar multiplication and division + friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s); + friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v); + friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s); + // Memberwise multiplication and division + friend _D3DVECTOR operator * (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR operator / (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Vector dominance + friend int operator < (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend int operator <= (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Bitwise equality + friend int operator == (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Length-related functions + friend D3DVALUE SquareMagnitude (const _D3DVECTOR& v); + friend D3DVALUE Magnitude (const _D3DVECTOR& v); + + // Returns vector with same direction and unit length + friend _D3DVECTOR Normalize (const _D3DVECTOR& v); + + // Return min/max component of the input vector + friend D3DVALUE Min (const _D3DVECTOR& v); + friend D3DVALUE Max (const _D3DVECTOR& v); + + // Return memberwise min/max of input vectors + friend _D3DVECTOR Minimize (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR Maximize (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Dot and cross product + friend D3DVALUE DotProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR CrossProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + +#endif +} D3DVECTOR, *LPD3DVECTOR; + +/* + * Vertex data types supported in an ExecuteBuffer. + */ + +/* + * Homogeneous vertices + */ + +typedef struct _D3DHVERTEX { + DWORD dwFlags; /* Homogeneous clipping flags */ + union { + D3DVALUE hx; + D3DVALUE dvHX; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DVALUE hy; + D3DVALUE dvHY; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DVALUE hz; + D3DVALUE dvHZ; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif +} D3DHVERTEX, *LPD3DHVERTEX; + +/* + * Transformed/lit vertices + */ +typedef struct _D3DTLVERTEX { + union { + D3DVALUE sx; /* Screen coordinates */ + D3DVALUE dvSX; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DVALUE sy; + D3DVALUE dvSY; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DVALUE sz; + D3DVALUE dvSZ; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + union { + D3DVALUE rhw; /* Reciprocal of homogeneous w */ + D3DVALUE dvRHW; +#if defined(NONAMELESSUNION) + } u4; +#else + }; +#endif + union { + D3DCOLOR color; /* Vertex color */ + D3DCOLOR dcColor; +#if defined(NONAMELESSUNION) + } u5; +#else + }; +#endif + union { + D3DCOLOR specular; /* Specular component of vertex */ + D3DCOLOR dcSpecular; +#if defined(NONAMELESSUNION) + } u6; +#else + }; +#endif + union { + D3DVALUE tu; /* Texture coordinates */ + D3DVALUE dvTU; +#if defined(NONAMELESSUNION) + } u7; +#else + }; +#endif + union { + D3DVALUE tv; + D3DVALUE dvTV; +#if defined(NONAMELESSUNION) + } u8; +#else + }; +#endif +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + _D3DTLVERTEX() { } + _D3DTLVERTEX(const D3DVECTOR& v, float _rhw, + D3DCOLOR _color, D3DCOLOR _specular, + float _tu, float _tv) + { sx = v.x; sy = v.y; sz = v.z; rhw = _rhw; + color = _color; specular = _specular; + tu = _tu; tv = _tv; + } +#endif +} D3DTLVERTEX, *LPD3DTLVERTEX; + +/* + * Untransformed/lit vertices + */ +typedef struct _D3DLVERTEX { + union { + D3DVALUE x; /* Homogeneous coordinates */ + D3DVALUE dvX; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DVALUE y; + D3DVALUE dvY; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DVALUE z; + D3DVALUE dvZ; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + DWORD dwReserved; + union { + D3DCOLOR color; /* Vertex color */ + D3DCOLOR dcColor; +#if defined(NONAMELESSUNION) + } u4; +#else + }; +#endif + union { + D3DCOLOR specular; /* Specular component of vertex */ + D3DCOLOR dcSpecular; +#if defined(NONAMELESSUNION) + } u5; +#else + }; +#endif + union { + D3DVALUE tu; /* Texture coordinates */ + D3DVALUE dvTU; +#if defined(NONAMELESSUNION) + } u6; +#else + }; +#endif + union { + D3DVALUE tv; + D3DVALUE dvTV; +#if defined(NONAMELESSUNION) + } u7; +#else + }; +#endif +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + _D3DLVERTEX() { } + _D3DLVERTEX(const D3DVECTOR& v, + D3DCOLOR _color, D3DCOLOR _specular, + float _tu, float _tv) + { x = v.x; y = v.y; z = v.z; dwReserved = 0; + color = _color; specular = _specular; + tu = _tu; tv = _tv; + } +#endif +} D3DLVERTEX, *LPD3DLVERTEX; + +/* + * Untransformed/unlit vertices + */ + +typedef struct _D3DVERTEX { + union { + D3DVALUE x; /* Homogeneous coordinates */ + D3DVALUE dvX; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DVALUE y; + D3DVALUE dvY; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DVALUE z; + D3DVALUE dvZ; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + union { + D3DVALUE nx; /* Normal */ + D3DVALUE dvNX; +#if defined(NONAMELESSUNION) + } u4; +#else + }; +#endif + union { + D3DVALUE ny; + D3DVALUE dvNY; +#if defined(NONAMELESSUNION) + } u5; +#else + }; +#endif + union { + D3DVALUE nz; + D3DVALUE dvNZ; +#if defined(NONAMELESSUNION) + } u6; +#else + }; +#endif + union { + D3DVALUE tu; /* Texture coordinates */ + D3DVALUE dvTU; +#if defined(NONAMELESSUNION) + } u7; +#else + }; +#endif + union { + D3DVALUE tv; + D3DVALUE dvTV; +#if defined(NONAMELESSUNION) + } u8; +#else + }; +#endif +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + _D3DVERTEX() { } + _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv) + { x = v.x; y = v.y; z = v.z; + nx = n.x; ny = n.y; nz = n.z; + tu = _tu; tv = _tv; + } +#endif +} D3DVERTEX, *LPD3DVERTEX; + + +/* + * Matrix, viewport, and tranformation structures and definitions. + */ + +typedef struct _D3DMATRIX { +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + union { + struct { +#endif + + D3DVALUE _11, _12, _13, _14; + D3DVALUE _21, _22, _23, _24; + D3DVALUE _31, _32, _33, _34; + D3DVALUE _41, _42, _43, _44; + +#if (defined __cplusplus) && (defined D3D_OVERLOADS) +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + D3DVALUE m[4][4]; + }; + _D3DMATRIX() { } + _D3DMATRIX( D3DVALUE _m00, D3DVALUE _m01, D3DVALUE _m02, D3DVALUE _m03, + D3DVALUE _m10, D3DVALUE _m11, D3DVALUE _m12, D3DVALUE _m13, + D3DVALUE _m20, D3DVALUE _m21, D3DVALUE _m22, D3DVALUE _m23, + D3DVALUE _m30, D3DVALUE _m31, D3DVALUE _m32, D3DVALUE _m33 + ) + { + m[0][0] = _m00; m[0][1] = _m01; m[0][2] = _m02; m[0][3] = _m03; + m[1][0] = _m10; m[1][1] = _m11; m[1][2] = _m12; m[1][3] = _m13; + m[2][0] = _m20; m[2][1] = _m21; m[2][2] = _m22; m[2][3] = _m23; + m[3][0] = _m30; m[3][1] = _m31; m[3][2] = _m32; m[3][3] = _m33; + } + + D3DVALUE& operator()(int iRow, int iColumn) { return m[iRow][iColumn]; } + const D3DVALUE& operator()(int iRow, int iColumn) const { return m[iRow][iColumn]; } + friend _D3DMATRIX operator* (const _D3DMATRIX&, const _D3DMATRIX&); +#endif +} D3DMATRIX, *LPD3DMATRIX; + +#if (defined __cplusplus) && (defined D3D_OVERLOADS) +#include "d3dvec.inl" +#endif + +typedef struct _D3DVIEWPORT { + DWORD dwSize; + DWORD dwX; + DWORD dwY; /* Top left */ + DWORD dwWidth; + DWORD dwHeight; /* Dimensions */ + D3DVALUE dvScaleX; /* Scale homogeneous to screen */ + D3DVALUE dvScaleY; /* Scale homogeneous to screen */ + D3DVALUE dvMaxX; /* Min/max homogeneous x coord */ + D3DVALUE dvMaxY; /* Min/max homogeneous y coord */ + D3DVALUE dvMinZ; + D3DVALUE dvMaxZ; /* Min/max homogeneous z coord */ +} D3DVIEWPORT, *LPD3DVIEWPORT; + +typedef struct _D3DVIEWPORT2 { + DWORD dwSize; + DWORD dwX; + DWORD dwY; /* Viewport Top left */ + DWORD dwWidth; + DWORD dwHeight; /* Viewport Dimensions */ + D3DVALUE dvClipX; /* Top left of clip volume */ + D3DVALUE dvClipY; + D3DVALUE dvClipWidth; /* Clip Volume Dimensions */ + D3DVALUE dvClipHeight; + D3DVALUE dvMinZ; /* Min/max of clip Volume */ + D3DVALUE dvMaxZ; +} D3DVIEWPORT2, *LPD3DVIEWPORT2; + +/* + * Values for clip fields. + */ +#define D3DCLIP_LEFT 0x00000001L +#define D3DCLIP_RIGHT 0x00000002L +#define D3DCLIP_TOP 0x00000004L +#define D3DCLIP_BOTTOM 0x00000008L +#define D3DCLIP_FRONT 0x00000010L +#define D3DCLIP_BACK 0x00000020L +#define D3DCLIP_GEN0 0x00000040L +#define D3DCLIP_GEN1 0x00000080L +#define D3DCLIP_GEN2 0x00000100L +#define D3DCLIP_GEN3 0x00000200L +#define D3DCLIP_GEN4 0x00000400L +#define D3DCLIP_GEN5 0x00000800L + +/* + * Values for d3d status. + */ +#define D3DSTATUS_CLIPUNIONLEFT D3DCLIP_LEFT +#define D3DSTATUS_CLIPUNIONRIGHT D3DCLIP_RIGHT +#define D3DSTATUS_CLIPUNIONTOP D3DCLIP_TOP +#define D3DSTATUS_CLIPUNIONBOTTOM D3DCLIP_BOTTOM +#define D3DSTATUS_CLIPUNIONFRONT D3DCLIP_FRONT +#define D3DSTATUS_CLIPUNIONBACK D3DCLIP_BACK +#define D3DSTATUS_CLIPUNIONGEN0 D3DCLIP_GEN0 +#define D3DSTATUS_CLIPUNIONGEN1 D3DCLIP_GEN1 +#define D3DSTATUS_CLIPUNIONGEN2 D3DCLIP_GEN2 +#define D3DSTATUS_CLIPUNIONGEN3 D3DCLIP_GEN3 +#define D3DSTATUS_CLIPUNIONGEN4 D3DCLIP_GEN4 +#define D3DSTATUS_CLIPUNIONGEN5 D3DCLIP_GEN5 + +#define D3DSTATUS_CLIPINTERSECTIONLEFT 0x00001000L +#define D3DSTATUS_CLIPINTERSECTIONRIGHT 0x00002000L +#define D3DSTATUS_CLIPINTERSECTIONTOP 0x00004000L +#define D3DSTATUS_CLIPINTERSECTIONBOTTOM 0x00008000L +#define D3DSTATUS_CLIPINTERSECTIONFRONT 0x00010000L +#define D3DSTATUS_CLIPINTERSECTIONBACK 0x00020000L +#define D3DSTATUS_CLIPINTERSECTIONGEN0 0x00040000L +#define D3DSTATUS_CLIPINTERSECTIONGEN1 0x00080000L +#define D3DSTATUS_CLIPINTERSECTIONGEN2 0x00100000L +#define D3DSTATUS_CLIPINTERSECTIONGEN3 0x00200000L +#define D3DSTATUS_CLIPINTERSECTIONGEN4 0x00400000L +#define D3DSTATUS_CLIPINTERSECTIONGEN5 0x00800000L +#define D3DSTATUS_ZNOTVISIBLE 0x01000000L +/* Do not use 0x80000000 for any status flags in future as it is reserved */ + +#define D3DSTATUS_CLIPUNIONALL ( \ + D3DSTATUS_CLIPUNIONLEFT | \ + D3DSTATUS_CLIPUNIONRIGHT | \ + D3DSTATUS_CLIPUNIONTOP | \ + D3DSTATUS_CLIPUNIONBOTTOM | \ + D3DSTATUS_CLIPUNIONFRONT | \ + D3DSTATUS_CLIPUNIONBACK | \ + D3DSTATUS_CLIPUNIONGEN0 | \ + D3DSTATUS_CLIPUNIONGEN1 | \ + D3DSTATUS_CLIPUNIONGEN2 | \ + D3DSTATUS_CLIPUNIONGEN3 | \ + D3DSTATUS_CLIPUNIONGEN4 | \ + D3DSTATUS_CLIPUNIONGEN5 \ + ) + +#define D3DSTATUS_CLIPINTERSECTIONALL ( \ + D3DSTATUS_CLIPINTERSECTIONLEFT | \ + D3DSTATUS_CLIPINTERSECTIONRIGHT | \ + D3DSTATUS_CLIPINTERSECTIONTOP | \ + D3DSTATUS_CLIPINTERSECTIONBOTTOM | \ + D3DSTATUS_CLIPINTERSECTIONFRONT | \ + D3DSTATUS_CLIPINTERSECTIONBACK | \ + D3DSTATUS_CLIPINTERSECTIONGEN0 | \ + D3DSTATUS_CLIPINTERSECTIONGEN1 | \ + D3DSTATUS_CLIPINTERSECTIONGEN2 | \ + D3DSTATUS_CLIPINTERSECTIONGEN3 | \ + D3DSTATUS_CLIPINTERSECTIONGEN4 | \ + D3DSTATUS_CLIPINTERSECTIONGEN5 \ + ) + +#define D3DSTATUS_DEFAULT ( \ + D3DSTATUS_CLIPINTERSECTIONALL | \ + D3DSTATUS_ZNOTVISIBLE) + + +/* + * Options for direct transform calls + */ +#define D3DTRANSFORM_CLIPPED 0x00000001l +#define D3DTRANSFORM_UNCLIPPED 0x00000002l + +typedef struct _D3DTRANSFORMDATA { + DWORD dwSize; + LPVOID lpIn; /* Input vertices */ + DWORD dwInSize; /* Stride of input vertices */ + LPVOID lpOut; /* Output vertices */ + DWORD dwOutSize; /* Stride of output vertices */ + LPD3DHVERTEX lpHOut; /* Output homogeneous vertices */ + DWORD dwClip; /* Clipping hint */ + DWORD dwClipIntersection; + DWORD dwClipUnion; /* Union of all clip flags */ + D3DRECT drExtent; /* Extent of transformed vertices */ +} D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA; + +/* + * Structure defining position and direction properties for lighting. + */ +typedef struct _D3DLIGHTINGELEMENT { + D3DVECTOR dvPosition; /* Lightable point in model space */ + D3DVECTOR dvNormal; /* Normalised unit vector */ +} D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT; + +/* + * Structure defining material properties for lighting. + */ +typedef struct _D3DMATERIAL { + DWORD dwSize; + union { + D3DCOLORVALUE diffuse; /* Diffuse color RGBA */ + D3DCOLORVALUE dcvDiffuse; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + D3DCOLORVALUE ambient; /* Ambient color RGB */ + D3DCOLORVALUE dcvAmbient; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + D3DCOLORVALUE specular; /* Specular 'shininess' */ + D3DCOLORVALUE dcvSpecular; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + union { + D3DCOLORVALUE emissive; /* Emissive color RGB */ + D3DCOLORVALUE dcvEmissive; +#if defined(NONAMELESSUNION) + } u4; +#else + }; +#endif + union { + D3DVALUE power; /* Sharpness if specular highlight */ + D3DVALUE dvPower; +#if defined(NONAMELESSUNION) + } u5; +#else + }; +#endif + D3DTEXTUREHANDLE hTexture; /* Handle to texture map */ + DWORD dwRampSize; +} D3DMATERIAL, *LPD3DMATERIAL; + +typedef enum _D3DLIGHTTYPE { + D3DLIGHT_POINT = 1, + D3DLIGHT_SPOT = 2, + D3DLIGHT_DIRECTIONAL = 3, + D3DLIGHT_PARALLELPOINT = 4, +#if(DIRECT3D_VERSION < 0x0500) // For backward compatible headers + D3DLIGHT_GLSPOT = 5, +#endif + D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DLIGHTTYPE; + +/* + * Structure defining a light source and its properties. + */ +typedef struct _D3DLIGHT { + DWORD dwSize; + D3DLIGHTTYPE dltType; /* Type of light source */ + D3DCOLORVALUE dcvColor; /* Color of light */ + D3DVECTOR dvPosition; /* Position in world space */ + D3DVECTOR dvDirection; /* Direction in world space */ + D3DVALUE dvRange; /* Cutoff range */ + D3DVALUE dvFalloff; /* Falloff */ + D3DVALUE dvAttenuation0; /* Constant attenuation */ + D3DVALUE dvAttenuation1; /* Linear attenuation */ + D3DVALUE dvAttenuation2; /* Quadratic attenuation */ + D3DVALUE dvTheta; /* Inner angle of spotlight cone */ + D3DVALUE dvPhi; /* Outer angle of spotlight cone */ +} D3DLIGHT, *LPD3DLIGHT; + +/* + * Structure defining a light source and its properties. + */ + +/* flags bits */ +#define D3DLIGHT_ACTIVE 0x00000001 +#define D3DLIGHT_NO_SPECULAR 0x00000002 + +/* maximum valid light range */ +#define D3DLIGHT_RANGE_MAX ((float)sqrt(FLT_MAX)) + +typedef struct _D3DLIGHT2 { + DWORD dwSize; + D3DLIGHTTYPE dltType; /* Type of light source */ + D3DCOLORVALUE dcvColor; /* Color of light */ + D3DVECTOR dvPosition; /* Position in world space */ + D3DVECTOR dvDirection; /* Direction in world space */ + D3DVALUE dvRange; /* Cutoff range */ + D3DVALUE dvFalloff; /* Falloff */ + D3DVALUE dvAttenuation0; /* Constant attenuation */ + D3DVALUE dvAttenuation1; /* Linear attenuation */ + D3DVALUE dvAttenuation2; /* Quadratic attenuation */ + D3DVALUE dvTheta; /* Inner angle of spotlight cone */ + D3DVALUE dvPhi; /* Outer angle of spotlight cone */ + DWORD dwFlags; +} D3DLIGHT2, *LPD3DLIGHT2; + +typedef struct _D3DLIGHTDATA { + DWORD dwSize; + LPD3DLIGHTINGELEMENT lpIn; /* Input positions and normals */ + DWORD dwInSize; /* Stride of input elements */ + LPD3DTLVERTEX lpOut; /* Output colors */ + DWORD dwOutSize; /* Stride of output colors */ +} D3DLIGHTDATA, *LPD3DLIGHTDATA; + +/* + * Before DX5, these values were in an enum called + * D3DCOLORMODEL. This was not correct, since they are + * bit flags. A driver can surface either or both flags + * in the dcmColorModel member of D3DDEVICEDESC. + */ +#define D3DCOLOR_MONO 1 +#define D3DCOLOR_RGB 2 + +typedef DWORD D3DCOLORMODEL; + +/* + * Options for clearing + */ +#define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */ +#define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */ +#define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */ + +/* + * Execute buffers are allocated via Direct3D. These buffers may then + * be filled by the application with instructions to execute along with + * vertex data. + */ + +/* + * Supported op codes for execute instructions. + */ +typedef enum _D3DOPCODE { + D3DOP_POINT = 1, + D3DOP_LINE = 2, + D3DOP_TRIANGLE = 3, + D3DOP_MATRIXLOAD = 4, + D3DOP_MATRIXMULTIPLY = 5, + D3DOP_STATETRANSFORM = 6, + D3DOP_STATELIGHT = 7, + D3DOP_STATERENDER = 8, + D3DOP_PROCESSVERTICES = 9, + D3DOP_TEXTURELOAD = 10, + D3DOP_EXIT = 11, + D3DOP_BRANCHFORWARD = 12, + D3DOP_SPAN = 13, + D3DOP_SETSTATUS = 14, + D3DOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DOPCODE; + +typedef struct _D3DINSTRUCTION { + BYTE bOpcode; /* Instruction opcode */ + BYTE bSize; /* Size of each instruction data unit */ + WORD wCount; /* Count of instruction data units to follow */ +} D3DINSTRUCTION, *LPD3DINSTRUCTION; + +/* + * Structure for texture loads + */ +typedef struct _D3DTEXTURELOAD { + D3DTEXTUREHANDLE hDestTexture; + D3DTEXTUREHANDLE hSrcTexture; +} D3DTEXTURELOAD, *LPD3DTEXTURELOAD; + +/* + * Structure for picking + */ +typedef struct _D3DPICKRECORD { + BYTE bOpcode; + BYTE bPad; + DWORD dwOffset; + D3DVALUE dvZ; +} D3DPICKRECORD, *LPD3DPICKRECORD; + +/* + * The following defines the rendering states which can be set in the + * execute buffer. + */ + +typedef enum _D3DSHADEMODE { + D3DSHADE_FLAT = 1, + D3DSHADE_GOURAUD = 2, + D3DSHADE_PHONG = 3, + D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DSHADEMODE; + +typedef enum _D3DFILLMODE { + D3DFILL_POINT = 1, + D3DFILL_WIREFRAME = 2, + D3DFILL_SOLID = 3, + D3DFILL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DFILLMODE; + +typedef struct _D3DLINEPATTERN { + WORD wRepeatFactor; + WORD wLinePattern; +} D3DLINEPATTERN; + +typedef enum _D3DTEXTUREFILTER { + D3DFILTER_NEAREST = 1, + D3DFILTER_LINEAR = 2, + D3DFILTER_MIPNEAREST = 3, + D3DFILTER_MIPLINEAR = 4, + D3DFILTER_LINEARMIPNEAREST = 5, + D3DFILTER_LINEARMIPLINEAR = 6, + D3DFILTER_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DTEXTUREFILTER; + +typedef enum _D3DBLEND { + D3DBLEND_ZERO = 1, + D3DBLEND_ONE = 2, + D3DBLEND_SRCCOLOR = 3, + D3DBLEND_INVSRCCOLOR = 4, + D3DBLEND_SRCALPHA = 5, + D3DBLEND_INVSRCALPHA = 6, + D3DBLEND_DESTALPHA = 7, + D3DBLEND_INVDESTALPHA = 8, + D3DBLEND_DESTCOLOR = 9, + D3DBLEND_INVDESTCOLOR = 10, + D3DBLEND_SRCALPHASAT = 11, + D3DBLEND_BOTHSRCALPHA = 12, + D3DBLEND_BOTHINVSRCALPHA = 13, + D3DBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DBLEND; + +typedef enum _D3DTEXTUREBLEND { + D3DTBLEND_DECAL = 1, + D3DTBLEND_MODULATE = 2, + D3DTBLEND_DECALALPHA = 3, + D3DTBLEND_MODULATEALPHA = 4, + D3DTBLEND_DECALMASK = 5, + D3DTBLEND_MODULATEMASK = 6, + D3DTBLEND_COPY = 7, + D3DTBLEND_ADD = 8, + D3DTBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DTEXTUREBLEND; + +typedef enum _D3DTEXTUREADDRESS { + D3DTADDRESS_WRAP = 1, + D3DTADDRESS_MIRROR = 2, + D3DTADDRESS_CLAMP = 3, + D3DTADDRESS_BORDER = 4, + D3DTADDRESS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DTEXTUREADDRESS; + +typedef enum _D3DCULL { + D3DCULL_NONE = 1, + D3DCULL_CW = 2, + D3DCULL_CCW = 3, + D3DCULL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DCULL; + +typedef enum _D3DCMPFUNC { + D3DCMP_NEVER = 1, + D3DCMP_LESS = 2, + D3DCMP_EQUAL = 3, + D3DCMP_LESSEQUAL = 4, + D3DCMP_GREATER = 5, + D3DCMP_NOTEQUAL = 6, + D3DCMP_GREATEREQUAL = 7, + D3DCMP_ALWAYS = 8, + D3DCMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DCMPFUNC; + +typedef enum _D3DSTENCILOP { + D3DSTENCILOP_KEEP = 1, + D3DSTENCILOP_ZERO = 2, + D3DSTENCILOP_REPLACE = 3, + D3DSTENCILOP_INCRSAT = 4, + D3DSTENCILOP_DECRSAT = 5, + D3DSTENCILOP_INVERT = 6, + D3DSTENCILOP_INCR = 7, + D3DSTENCILOP_DECR = 8, + D3DSTENCILOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DSTENCILOP; + +typedef enum _D3DFOGMODE { + D3DFOG_NONE = 0, + D3DFOG_EXP = 1, + D3DFOG_EXP2 = 2, + D3DFOG_LINEAR = 3, + D3DFOG_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DFOGMODE; + +typedef enum _D3DZBUFFERTYPE { + D3DZB_FALSE = 0, + D3DZB_TRUE = 1, // Z buffering + D3DZB_USEW = 2, // W buffering + D3DZB_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DZBUFFERTYPE; + +typedef enum _D3DANTIALIASMODE { + D3DANTIALIAS_NONE = 0, + D3DANTIALIAS_SORTDEPENDENT = 1, + D3DANTIALIAS_SORTINDEPENDENT = 2, + D3DANTIALIAS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DANTIALIASMODE; + +// Vertex types supported by Direct3D +typedef enum _D3DVERTEXTYPE { + D3DVT_VERTEX = 1, + D3DVT_LVERTEX = 2, + D3DVT_TLVERTEX = 3, + D3DVT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DVERTEXTYPE; + +// Primitives supported by draw-primitive API +typedef enum _D3DPRIMITIVETYPE { + D3DPT_POINTLIST = 1, + D3DPT_LINELIST = 2, + D3DPT_LINESTRIP = 3, + D3DPT_TRIANGLELIST = 4, + D3DPT_TRIANGLESTRIP = 5, + D3DPT_TRIANGLEFAN = 6, + D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DPRIMITIVETYPE; + +/* + * Amount to add to a state to generate the override for that state. + */ +#define D3DSTATE_OVERRIDE_BIAS 256 + +/* + * A state which sets the override flag for the specified state type. + */ +#define D3DSTATE_OVERRIDE(type) (D3DRENDERSTATETYPE)(((DWORD) (type) + D3DSTATE_OVERRIDE_BIAS)) + +typedef enum _D3DTRANSFORMSTATETYPE { + D3DTRANSFORMSTATE_WORLD = 1, + D3DTRANSFORMSTATE_VIEW = 2, + D3DTRANSFORMSTATE_PROJECTION = 3, + D3DTRANSFORMSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DTRANSFORMSTATETYPE; + +typedef enum _D3DLIGHTSTATETYPE { + D3DLIGHTSTATE_MATERIAL = 1, + D3DLIGHTSTATE_AMBIENT = 2, + D3DLIGHTSTATE_COLORMODEL = 3, + D3DLIGHTSTATE_FOGMODE = 4, + D3DLIGHTSTATE_FOGSTART = 5, + D3DLIGHTSTATE_FOGEND = 6, + D3DLIGHTSTATE_FOGDENSITY = 7, + D3DLIGHTSTATE_COLORVERTEX = 8, + D3DLIGHTSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DLIGHTSTATETYPE; + +typedef enum _D3DRENDERSTATETYPE { + D3DRENDERSTATE_TEXTUREHANDLE = 1, /* Texture handle for legacy interfaces (Texture,Texture2) */ + D3DRENDERSTATE_ANTIALIAS = 2, /* D3DANTIALIASMODE */ + D3DRENDERSTATE_TEXTUREADDRESS = 3, /* D3DTEXTUREADDRESS */ + D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4, /* TRUE for perspective correction */ + D3DRENDERSTATE_WRAPU = 5, /* TRUE for wrapping in u */ + D3DRENDERSTATE_WRAPV = 6, /* TRUE for wrapping in v */ + D3DRENDERSTATE_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */ + D3DRENDERSTATE_FILLMODE = 8, /* D3DFILL_MODE */ + D3DRENDERSTATE_SHADEMODE = 9, /* D3DSHADEMODE */ + D3DRENDERSTATE_LINEPATTERN = 10, /* D3DLINEPATTERN */ + D3DRENDERSTATE_MONOENABLE = 11, /* TRUE to enable mono rasterization */ + D3DRENDERSTATE_ROP2 = 12, /* ROP2 */ + D3DRENDERSTATE_PLANEMASK = 13, /* DWORD physical plane mask */ + D3DRENDERSTATE_ZWRITEENABLE = 14, /* TRUE to enable z writes */ + D3DRENDERSTATE_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */ + D3DRENDERSTATE_LASTPIXEL = 16, /* TRUE for last-pixel on lines */ + D3DRENDERSTATE_TEXTUREMAG = 17, /* D3DTEXTUREFILTER */ + D3DRENDERSTATE_TEXTUREMIN = 18, /* D3DTEXTUREFILTER */ + D3DRENDERSTATE_SRCBLEND = 19, /* D3DBLEND */ + D3DRENDERSTATE_DESTBLEND = 20, /* D3DBLEND */ + D3DRENDERSTATE_TEXTUREMAPBLEND = 21, /* D3DTEXTUREBLEND */ + D3DRENDERSTATE_CULLMODE = 22, /* D3DCULL */ + D3DRENDERSTATE_ZFUNC = 23, /* D3DCMPFUNC */ + D3DRENDERSTATE_ALPHAREF = 24, /* D3DFIXED */ + D3DRENDERSTATE_ALPHAFUNC = 25, /* D3DCMPFUNC */ + D3DRENDERSTATE_DITHERENABLE = 26, /* TRUE to enable dithering */ + D3DRENDERSTATE_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */ + D3DRENDERSTATE_FOGENABLE = 28, /* TRUE to enable fog */ + D3DRENDERSTATE_SPECULARENABLE = 29, /* TRUE to enable specular */ + D3DRENDERSTATE_ZVISIBLE = 30, /* TRUE to enable z checking */ + D3DRENDERSTATE_SUBPIXEL = 31, /* TRUE to enable subpixel correction */ + D3DRENDERSTATE_SUBPIXELX = 32, /* TRUE to enable correction in X only */ + D3DRENDERSTATE_STIPPLEDALPHA = 33, /* TRUE to enable stippled alpha */ + D3DRENDERSTATE_FOGCOLOR = 34, /* D3DCOLOR */ + D3DRENDERSTATE_FOGTABLEMODE = 35, /* D3DFOGMODE */ + D3DRENDERSTATE_FOGTABLESTART = 36, /* Fog table start */ + D3DRENDERSTATE_FOGTABLEEND = 37, /* Fog table end */ + D3DRENDERSTATE_FOGTABLEDENSITY = 38, /* Fog table density */ + D3DRENDERSTATE_STIPPLEENABLE = 39, /* TRUE to enable stippling */ + D3DRENDERSTATE_EDGEANTIALIAS = 40, /* TRUE to enable edge antialiasing */ + D3DRENDERSTATE_COLORKEYENABLE = 41, /* TRUE to enable source colorkeyed textures */ + D3DRENDERSTATE_BORDERCOLOR = 43, /* Border color for texturing w/border */ + D3DRENDERSTATE_TEXTUREADDRESSU = 44, /* Texture addressing mode for U coordinate */ + D3DRENDERSTATE_TEXTUREADDRESSV = 45, /* Texture addressing mode for V coordinate */ + D3DRENDERSTATE_MIPMAPLODBIAS = 46, /* D3DVALUE Mipmap LOD bias */ + D3DRENDERSTATE_ZBIAS = 47, /* LONG Z bias */ + D3DRENDERSTATE_RANGEFOGENABLE = 48, /* Enables range-based fog */ + D3DRENDERSTATE_ANISOTROPY = 49, /* Max. anisotropy. 1 = no anisotropy */ + D3DRENDERSTATE_FLUSHBATCH = 50, /* Explicit flush for DP batching (DX5 Only) */ + D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT=51, /* BOOL enable sort-independent transparency */ + D3DRENDERSTATE_STENCILENABLE = 52, /* BOOL enable/disable stenciling */ + D3DRENDERSTATE_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil test fails */ + D3DRENDERSTATE_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil test passes and Z test fails */ + D3DRENDERSTATE_STENCILPASS = 55, /* D3DSTENCILOP to do if both stencil and Z tests pass */ + D3DRENDERSTATE_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */ + D3DRENDERSTATE_STENCILREF = 57, /* Reference value used in stencil test */ + D3DRENDERSTATE_STENCILMASK = 58, /* Mask value used in stencil test */ + D3DRENDERSTATE_STENCILWRITEMASK = 59, /* Write mask applied to values written to stencil buffer */ + D3DRENDERSTATE_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture blend */ + D3DRENDERSTATE_STIPPLEPATTERN00 = 64, /* Stipple pattern 01... */ + D3DRENDERSTATE_STIPPLEPATTERN01 = 65, + D3DRENDERSTATE_STIPPLEPATTERN02 = 66, + D3DRENDERSTATE_STIPPLEPATTERN03 = 67, + D3DRENDERSTATE_STIPPLEPATTERN04 = 68, + D3DRENDERSTATE_STIPPLEPATTERN05 = 69, + D3DRENDERSTATE_STIPPLEPATTERN06 = 70, + D3DRENDERSTATE_STIPPLEPATTERN07 = 71, + D3DRENDERSTATE_STIPPLEPATTERN08 = 72, + D3DRENDERSTATE_STIPPLEPATTERN09 = 73, + D3DRENDERSTATE_STIPPLEPATTERN10 = 74, + D3DRENDERSTATE_STIPPLEPATTERN11 = 75, + D3DRENDERSTATE_STIPPLEPATTERN12 = 76, + D3DRENDERSTATE_STIPPLEPATTERN13 = 77, + D3DRENDERSTATE_STIPPLEPATTERN14 = 78, + D3DRENDERSTATE_STIPPLEPATTERN15 = 79, + D3DRENDERSTATE_STIPPLEPATTERN16 = 80, + D3DRENDERSTATE_STIPPLEPATTERN17 = 81, + D3DRENDERSTATE_STIPPLEPATTERN18 = 82, + D3DRENDERSTATE_STIPPLEPATTERN19 = 83, + D3DRENDERSTATE_STIPPLEPATTERN20 = 84, + D3DRENDERSTATE_STIPPLEPATTERN21 = 85, + D3DRENDERSTATE_STIPPLEPATTERN22 = 86, + D3DRENDERSTATE_STIPPLEPATTERN23 = 87, + D3DRENDERSTATE_STIPPLEPATTERN24 = 88, + D3DRENDERSTATE_STIPPLEPATTERN25 = 89, + D3DRENDERSTATE_STIPPLEPATTERN26 = 90, + D3DRENDERSTATE_STIPPLEPATTERN27 = 91, + D3DRENDERSTATE_STIPPLEPATTERN28 = 92, + D3DRENDERSTATE_STIPPLEPATTERN29 = 93, + D3DRENDERSTATE_STIPPLEPATTERN30 = 94, + D3DRENDERSTATE_STIPPLEPATTERN31 = 95, + + /* + * 128 values [128, 255] are reserved for texture coordinate wrap flags. + * These are constructed with the D3DWRAP_U and D3DWRAP_V macros. Using + * a flags word preserves forward compatibility with texture coordinates + * that are >2D. + */ + D3DRENDERSTATE_WRAP0 = 128, /* wrap for 1st texture coord. set */ + D3DRENDERSTATE_WRAP1 = 129, /* wrap for 2nd texture coord. set */ + D3DRENDERSTATE_WRAP2 = 130, /* wrap for 3rd texture coord. set */ + D3DRENDERSTATE_WRAP3 = 131, /* wrap for 4th texture coord. set */ + D3DRENDERSTATE_WRAP4 = 132, /* wrap for 5th texture coord. set */ + D3DRENDERSTATE_WRAP5 = 133, /* wrap for 6th texture coord. set */ + D3DRENDERSTATE_WRAP6 = 134, /* wrap for 7th texture coord. set */ + D3DRENDERSTATE_WRAP7 = 135, /* wrap for 8th texture coord. set */ + D3DRENDERSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DRENDERSTATETYPE; + +// For back-compatibility with legacy compilations +#define D3DRENDERSTATE_BLENDENABLE D3DRENDERSTATE_ALPHABLENDENABLE + + +// Bias to apply to the texture coordinate set to apply a wrap to. +#define D3DRENDERSTATE_WRAPBIAS 128UL + +/* Flags to construct the WRAP render states */ +#define D3DWRAP_U 0x00000001L +#define D3DWRAP_V 0x00000002L + + +#define D3DRENDERSTATE_STIPPLEPATTERN(y) (D3DRENDERSTATE_STIPPLEPATTERN00 + (y)) + +typedef struct _D3DSTATE { + union { + D3DTRANSFORMSTATETYPE dtstTransformStateType; + D3DLIGHTSTATETYPE dlstLightStateType; + D3DRENDERSTATETYPE drstRenderStateType; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + DWORD dwArg[1]; + D3DVALUE dvArg[1]; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif +} D3DSTATE, *LPD3DSTATE; + +/* + * Operation used to load matrices + * hDstMat = hSrcMat + */ +typedef struct _D3DMATRIXLOAD { + D3DMATRIXHANDLE hDestMatrix; /* Destination matrix */ + D3DMATRIXHANDLE hSrcMatrix; /* Source matrix */ +} D3DMATRIXLOAD, *LPD3DMATRIXLOAD; + +/* + * Operation used to multiply matrices + * hDstMat = hSrcMat1 * hSrcMat2 + */ +typedef struct _D3DMATRIXMULTIPLY { + D3DMATRIXHANDLE hDestMatrix; /* Destination matrix */ + D3DMATRIXHANDLE hSrcMatrix1; /* First source matrix */ + D3DMATRIXHANDLE hSrcMatrix2; /* Second source matrix */ +} D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY; + +/* + * Operation used to transform and light vertices. + */ +typedef struct _D3DPROCESSVERTICES { + DWORD dwFlags; /* Do we transform or light or just copy? */ + WORD wStart; /* Index to first vertex in source */ + WORD wDest; /* Index to first vertex in local buffer */ + DWORD dwCount; /* Number of vertices to be processed */ + DWORD dwReserved; /* Must be zero */ +} D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES; + +#define D3DPROCESSVERTICES_TRANSFORMLIGHT 0x00000000L +#define D3DPROCESSVERTICES_TRANSFORM 0x00000001L +#define D3DPROCESSVERTICES_COPY 0x00000002L +#define D3DPROCESSVERTICES_OPMASK 0x00000007L + +#define D3DPROCESSVERTICES_UPDATEEXTENTS 0x00000008L +#define D3DPROCESSVERTICES_NOCOLOR 0x00000010L + + + + +/* + * State enumerants for per-stage texture processing. + */ +typedef enum _D3DTEXTURESTAGESTATETYPE +{ + D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */ + D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */ + D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */ + D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */ + D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */ + D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */ + D3DTSS_BUMPENVMAT00 = 7, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_BUMPENVMAT01 = 8, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_BUMPENVMAT10 = 9, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_BUMPENVMAT11 = 10, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */ + D3DTSS_ADDRESS = 12, /* D3DTEXTUREADDRESS for both coordinates */ + D3DTSS_ADDRESSU = 13, /* D3DTEXTUREADDRESS for U coordinate */ + D3DTSS_ADDRESSV = 14, /* D3DTEXTUREADDRESS for V coordinate */ + D3DTSS_BORDERCOLOR = 15, /* D3DCOLOR */ + D3DTSS_MAGFILTER = 16, /* D3DTEXTUREMAGFILTER filter to use for magnification */ + D3DTSS_MINFILTER = 17, /* D3DTEXTUREMINFILTER filter to use for minification */ + D3DTSS_MIPFILTER = 18, /* D3DTEXTUREMIPFILTER filter to use between mipmaps during minification */ + D3DTSS_MIPMAPLODBIAS = 19, /* D3DVALUE Mipmap LOD bias */ + D3DTSS_MAXMIPLEVEL = 20, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */ + D3DTSS_MAXANISOTROPY = 21, /* DWORD maximum anisotropy */ + D3DTSS_BUMPENVLSCALE = 22, /* D3DVALUE scale for bump map luminance */ + D3DTSS_BUMPENVLOFFSET = 23, /* D3DVALUE offset for bump map luminance */ + D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DTEXTURESTAGESTATETYPE; + +/* + * Enumerations for COLOROP and ALPHAOP texture blending operations set in + * texture processing stage controls in D3DRENDERSTATE. + */ +typedef enum _D3DTEXTUREOP +{ +// Control + D3DTOP_DISABLE = 1, // disables stage + D3DTOP_SELECTARG1 = 2, // the default + D3DTOP_SELECTARG2 = 3, + +// Modulate + D3DTOP_MODULATE = 4, // multiply args together + D3DTOP_MODULATE2X = 5, // multiply and 1 bit + D3DTOP_MODULATE4X = 6, // multiply and 2 bits + +// Add + D3DTOP_ADD = 7, // add arguments together + D3DTOP_ADDSIGNED = 8, // add with -0.5 bias + D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit + D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation + D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product + // Arg1 + Arg2 - Arg1*Arg2 + // = Arg1 + (1-Arg1)*Arg2 + +// Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) + D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha + D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha + D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRENDERSTATE_TEXTUREFACTOR + // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) + D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha + D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color + +// Specular mapping + D3DTOP_PREMODULATE = 17, // modulate with next texture before use + D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB + // COLOROP only + D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A + // COLOROP only + D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB + // COLOROP only + D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A + // COLOROP only + +// Bump mapping + D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation + D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel + // This can do either diffuse or specular bump mapping with correct input. + // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B) + // where each component has been scaled and offset to make it signed. + // The result is replicated into all four (including alpha) channels. + // This is a valid COLOROP only. + D3DTOP_DOTPRODUCT3 = 24, + + D3DTOP_FORCE_DWORD = 0x7fffffff, +} D3DTEXTUREOP; + +/* + * Values for COLORARG1,2 and ALPHAARG1,2 texture blending operations + * set in texture processing stage controls in D3DRENDERSTATE. + */ +#define D3DTA_SELECTMASK 0x0000000f // mask for arg selector +#define D3DTA_DIFFUSE 0x00000000 // select diffuse color +#define D3DTA_CURRENT 0x00000001 // select result of previous stage +#define D3DTA_TEXTURE 0x00000002 // select texture color +#define D3DTA_TFACTOR 0x00000003 // select RENDERSTATE_TEXTUREFACTOR + +#define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x +#define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components + +/* + * IDirect3DTexture2 State Filter Types + */ +typedef enum _D3DTEXTUREMAGFILTER +{ + D3DTFG_POINT = 1, // nearest + D3DTFG_LINEAR = 2, // linear interpolation + D3DTFG_FLATCUBIC = 3, // cubic + D3DTFG_GAUSSIANCUBIC = 4, // different cubic kernel + D3DTFG_ANISOTROPIC = 5, // + D3DTFG_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DTEXTUREMAGFILTER; + +typedef enum _D3DTEXTUREMINFILTER +{ + D3DTFN_POINT = 1, // nearest + D3DTFN_LINEAR = 2, // linear interpolation + D3DTFN_ANISOTROPIC = 3, // + D3DTFN_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DTEXTUREMINFILTER; + +typedef enum _D3DTEXTUREMIPFILTER +{ + D3DTFP_NONE = 1, // mipmapping disabled (use MAG filter) + D3DTFP_POINT = 2, // nearest + D3DTFP_LINEAR = 3, // linear interpolation + D3DTFP_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DTEXTUREMIPFILTER; + + +/* + * Triangle flags + */ + +/* + * Tri strip and fan flags. + * START loads all three vertices + * EVEN and ODD load just v3 with even or odd culling + * START_FLAT contains a count from 0 to 29 that allows the + * whole strip or fan to be culled in one hit. + * e.g. for a quad len = 1 + */ +#define D3DTRIFLAG_START 0x00000000L +#define D3DTRIFLAG_STARTFLAT(len) (len) /* 0 < len < 30 */ +#define D3DTRIFLAG_ODD 0x0000001eL +#define D3DTRIFLAG_EVEN 0x0000001fL + +/* + * Triangle edge flags + * enable edges for wireframe or antialiasing + */ +#define D3DTRIFLAG_EDGEENABLE1 0x00000100L /* v0-v1 edge */ +#define D3DTRIFLAG_EDGEENABLE2 0x00000200L /* v1-v2 edge */ +#define D3DTRIFLAG_EDGEENABLE3 0x00000400L /* v2-v0 edge */ +#define D3DTRIFLAG_EDGEENABLETRIANGLE \ + (D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE2 | D3DTRIFLAG_EDGEENABLE3) + +/* + * Primitive structures and related defines. Vertex offsets are to types + * D3DVERTEX, D3DLVERTEX, or D3DTLVERTEX. + */ + +/* + * Triangle list primitive structure + */ +typedef struct _D3DTRIANGLE { + union { + WORD v1; /* Vertex indices */ + WORD wV1; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + WORD v2; + WORD wV2; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif + union { + WORD v3; + WORD wV3; +#if defined(NONAMELESSUNION) + } u3; +#else + }; +#endif + WORD wFlags; /* Edge (and other) flags */ +} D3DTRIANGLE, *LPD3DTRIANGLE; + +/* + * Line list structure. + * The instruction count defines the number of line segments. + */ +typedef struct _D3DLINE { + union { + WORD v1; /* Vertex indices */ + WORD wV1; +#if defined(NONAMELESSUNION) + } u1; +#else + }; +#endif + union { + WORD v2; + WORD wV2; +#if defined(NONAMELESSUNION) + } u2; +#else + }; +#endif +} D3DLINE, *LPD3DLINE; + +/* + * Span structure + * Spans join a list of points with the same y value. + * If the y value changes, a new span is started. + */ +typedef struct _D3DSPAN { + WORD wCount; /* Number of spans */ + WORD wFirst; /* Index to first vertex */ +} D3DSPAN, *LPD3DSPAN; + +/* + * Point structure + */ +typedef struct _D3DPOINT { + WORD wCount; /* number of points */ + WORD wFirst; /* index to first vertex */ +} D3DPOINT, *LPD3DPOINT; + + +/* + * Forward branch structure. + * Mask is logically anded with the driver status mask + * if the result equals 'value', the branch is taken. + */ +typedef struct _D3DBRANCH { + DWORD dwMask; /* Bitmask against D3D status */ + DWORD dwValue; + BOOL bNegate; /* TRUE to negate comparison */ + DWORD dwOffset; /* How far to branch forward (0 for exit)*/ +} D3DBRANCH, *LPD3DBRANCH; + +/* + * Status used for set status instruction. + * The D3D status is initialised on device creation + * and is modified by all execute calls. + */ +typedef struct _D3DSTATUS { + DWORD dwFlags; /* Do we set extents or status */ + DWORD dwStatus; /* D3D status */ + D3DRECT drExtent; +} D3DSTATUS, *LPD3DSTATUS; + +#define D3DSETSTATUS_STATUS 0x00000001L +#define D3DSETSTATUS_EXTENTS 0x00000002L +#define D3DSETSTATUS_ALL (D3DSETSTATUS_STATUS | D3DSETSTATUS_EXTENTS) + +typedef struct _D3DCLIPSTATUS { + DWORD dwFlags; /* Do we set 2d extents, 3D extents or status */ + DWORD dwStatus; /* Clip status */ + float minx, maxx; /* X extents */ + float miny, maxy; /* Y extents */ + float minz, maxz; /* Z extents */ +} D3DCLIPSTATUS, *LPD3DCLIPSTATUS; + +#define D3DCLIPSTATUS_STATUS 0x00000001L +#define D3DCLIPSTATUS_EXTENTS2 0x00000002L +#define D3DCLIPSTATUS_EXTENTS3 0x00000004L + +/* + * Statistics structure + */ +typedef struct _D3DSTATS { + DWORD dwSize; + DWORD dwTrianglesDrawn; + DWORD dwLinesDrawn; + DWORD dwPointsDrawn; + DWORD dwSpansDrawn; + DWORD dwVerticesProcessed; +} D3DSTATS, *LPD3DSTATS; + +/* + * Execute options. + * When calling using D3DEXECUTE_UNCLIPPED all the primitives + * inside the buffer must be contained within the viewport. + */ +#define D3DEXECUTE_CLIPPED 0x00000001l +#define D3DEXECUTE_UNCLIPPED 0x00000002l + +typedef struct _D3DEXECUTEDATA { + DWORD dwSize; + DWORD dwVertexOffset; + DWORD dwVertexCount; + DWORD dwInstructionOffset; + DWORD dwInstructionLength; + DWORD dwHVertexOffset; + D3DSTATUS dsStatus; /* Status after execute */ +} D3DEXECUTEDATA, *LPD3DEXECUTEDATA; + +/* + * Palette flags. + * This are or'ed with the peFlags in the PALETTEENTRYs passed to DirectDraw. + */ +#define D3DPAL_FREE 0x00 /* Renderer may use this entry freely */ +#define D3DPAL_READONLY 0x40 /* Renderer may not set this entry */ +#define D3DPAL_RESERVED 0x80 /* Renderer may not use this entry */ + + + +typedef struct _D3DVERTEXBUFFERDESC { + DWORD dwSize; + DWORD dwCaps; + DWORD dwFVF; + DWORD dwNumVertices; +} D3DVERTEXBUFFERDESC, *LPD3DVERTEXBUFFERDESC; + +/* These correspond to DDSCAPS_* flags */ +#define D3DVBCAPS_SYSTEMMEMORY 0x00000800l +#define D3DVBCAPS_WRITEONLY 0x00010000l +#define D3DVBCAPS_OPTIMIZED 0x80000000l + +/* Vertex Operations for ProcessVertices */ +#define D3DVOP_LIGHT (1 << 10) +#define D3DVOP_TRANSFORM (1 << 0) +#define D3DVOP_CLIP (1 << 2) +#define D3DVOP_EXTENTS (1 << 3) + +//------------------------------------------------------------------- + +// Flexible vertex format bits +// +#define D3DFVF_RESERVED0 0x001 +#define D3DFVF_POSITION_MASK 0x00E +#define D3DFVF_XYZ 0x002 +#define D3DFVF_XYZRHW 0x004 +#define D3DFVF_NORMAL 0x010 +#define D3DFVF_RESERVED1 0x020 +#define D3DFVF_DIFFUSE 0x040 +#define D3DFVF_SPECULAR 0x080 + +#define D3DFVF_TEXCOUNT_MASK 0xf00 +#define D3DFVF_TEXCOUNT_SHIFT 8 +#define D3DFVF_TEX0 0x000 +#define D3DFVF_TEX1 0x100 +#define D3DFVF_TEX2 0x200 +#define D3DFVF_TEX3 0x300 +#define D3DFVF_TEX4 0x400 +#define D3DFVF_TEX5 0x500 +#define D3DFVF_TEX6 0x600 +#define D3DFVF_TEX7 0x700 +#define D3DFVF_TEX8 0x800 + +#define D3DFVF_RESERVED2 0xf000 // 4 reserved bits + +#define D3DFVF_VERTEX ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 ) +#define D3DFVF_LVERTEX ( D3DFVF_XYZ | D3DFVF_RESERVED1 | D3DFVF_DIFFUSE | \ + D3DFVF_SPECULAR | D3DFVF_TEX1 ) +#define D3DFVF_TLVERTEX ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | \ + D3DFVF_TEX1 ) + +typedef struct _D3DDP_PTRSTRIDE +{ + LPVOID lpvData; + DWORD dwStride; +} D3DDP_PTRSTRIDE; + +#define D3DDP_MAXTEXCOORD 8 + +typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA +{ + D3DDP_PTRSTRIDE position; + D3DDP_PTRSTRIDE normal; + D3DDP_PTRSTRIDE diffuse; + D3DDP_PTRSTRIDE specular; + D3DDP_PTRSTRIDE textureCoords[D3DDP_MAXTEXCOORD]; +} D3DDRAWPRIMITIVESTRIDEDDATA, *LPD3DDRAWPRIMITIVESTRIDEDDATA; +//--------------------------------------------------------------------- +// ComputeSphereVisibility return values +// +#define D3DVIS_INSIDE_FRUSTUM 0 +#define D3DVIS_INTERSECT_FRUSTUM 1 +#define D3DVIS_OUTSIDE_FRUSTUM 2 +#define D3DVIS_INSIDE_LEFT 0 +#define D3DVIS_INTERSECT_LEFT (1 << 2) +#define D3DVIS_OUTSIDE_LEFT (2 << 2) +#define D3DVIS_INSIDE_RIGHT 0 +#define D3DVIS_INTERSECT_RIGHT (1 << 4) +#define D3DVIS_OUTSIDE_RIGHT (2 << 4) +#define D3DVIS_INSIDE_TOP 0 +#define D3DVIS_INTERSECT_TOP (1 << 6) +#define D3DVIS_OUTSIDE_TOP (2 << 6) +#define D3DVIS_INSIDE_BOTTOM 0 +#define D3DVIS_INTERSECT_BOTTOM (1 << 8) +#define D3DVIS_OUTSIDE_BOTTOM (2 << 8) +#define D3DVIS_INSIDE_NEAR 0 +#define D3DVIS_INTERSECT_NEAR (1 << 10) +#define D3DVIS_OUTSIDE_NEAR (2 << 10) +#define D3DVIS_INSIDE_FAR 0 +#define D3DVIS_INTERSECT_FAR (1 << 12) +#define D3DVIS_OUTSIDE_FAR (2 << 12) + +#define D3DVIS_MASK_FRUSTUM (3 << 0) +#define D3DVIS_MASK_LEFT (3 << 2) +#define D3DVIS_MASK_RIGHT (3 << 4) +#define D3DVIS_MASK_TOP (3 << 6) +#define D3DVIS_MASK_BOTTOM (3 << 8) +#define D3DVIS_MASK_NEAR (3 << 10) +#define D3DVIS_MASK_FAR (3 << 12) + + +#pragma pack() +#endif /* _D3DTYPES_H_ */ + diff --git a/misc/builddeps/dp.win64/include/ddraw.h b/misc/builddeps/dp.win64/include/ddraw.h new file mode 100644 index 00000000..feaec698 --- /dev/null +++ b/misc/builddeps/dp.win64/include/ddraw.h @@ -0,0 +1,4844 @@ +/*==========================================================================; + * + * Copyright (C) 1994-1997 Microsoft Corporation. All Rights Reserved. + * + * File: ddraw.h + * Content: DirectDraw include file + * + ***************************************************************************/ + +#ifndef __DDRAW_INCLUDED__ +#define __DDRAW_INCLUDED__ + +/* + * If you wish an application built against the newest version of DirectDraw + * to run against an older DirectDraw run time then define DIRECTDRAW_VERSION + * to be the earlies version of DirectDraw you wish to run against. For, + * example if you wish an application to run against a DX 3 runtime define + * DIRECTDRAW_VERSION to be 0x0300. + */ +#ifndef DIRECTDRAW_VERSION +#define DIRECTDRAW_VERSION 0x0600 +#endif /* DIRECTDRAW_VERSION */ + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#define COM_NO_WINDOWS_H +#include +#else +#define IUnknown void +#if !defined( NT_BUILD_ENVIRONMENT ) && !defined(WINNT) + #define CO_E_NOTINITIALIZED 0x800401F0L +#endif +#endif + +#define _FACDD 0x876 +#define MAKE_DDHRESULT( code ) MAKE_HRESULT( 1, _FACDD, code ) + +#ifdef __cplusplus +extern "C" { +#endif + +// +// For compilers that don't support nameless unions, do a +// +// #define NONAMELESSUNION +// +// before #include +// +#ifndef DUMMYUNIONNAMEN +#if defined(__cplusplus) || !defined(NONAMELESSUNION) +#define DUMMYUNIONNAMEN(n) +#else +#define DUMMYUNIONNAMEN(n) u##n +#endif +#endif + +#ifndef MAKEFOURCC + #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ + ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) +#endif //defined(MAKEFOURCC) + +/* + * FOURCC codes for DX compressed-texture pixel formats + */ +#define FOURCC_DXT1 (MAKEFOURCC('D','X','T','1')) +#define FOURCC_DXT2 (MAKEFOURCC('D','X','T','2')) +#define FOURCC_DXT3 (MAKEFOURCC('D','X','T','3')) +#define FOURCC_DXT4 (MAKEFOURCC('D','X','T','4')) +#define FOURCC_DXT5 (MAKEFOURCC('D','X','T','5')) + +/* + * GUIDS used by DirectDraw objects + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) + +DEFINE_GUID( CLSID_DirectDraw, 0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35 ); +DEFINE_GUID( CLSID_DirectDrawClipper, 0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56 ); +DEFINE_GUID( IID_IDirectDraw, 0x6C14DB80,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDraw2, 0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 ); +DEFINE_GUID( IID_IDirectDraw4, 0x9c59509a,0x39bd,0x11d1,0x8c,0x4a,0x00,0xc0,0x4f,0xd9,0x30,0xc5 ); +DEFINE_GUID( IID_IDirectDrawSurface, 0x6C14DB81,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDrawSurface2, 0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27 ); +DEFINE_GUID( IID_IDirectDrawSurface3, 0xDA044E00,0x69B2,0x11D0,0xA1,0xD5,0x00,0xAA,0x00,0xB8,0xDF,0xBB ); +DEFINE_GUID( IID_IDirectDrawSurface4, 0x0B2B8630,0xAD35,0x11D0,0x8E,0xA6,0x00,0x60,0x97,0x97,0xEA,0x5B ); + +DEFINE_GUID( IID_IDirectDrawPalette, 0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDrawClipper, 0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDrawColorControl, 0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8 ); +DEFINE_GUID( IID_IDirectDrawGammaControl, 0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00,0xC0,0x4F,0xC2,0x9B,0x4E ); + +#endif + +/*============================================================================ + * + * DirectDraw Structures + * + * Various structures used to invoke DirectDraw. + * + *==========================================================================*/ + +struct IDirectDraw; +struct IDirectDrawSurface; +struct IDirectDrawPalette; +struct IDirectDrawClipper; + +typedef struct IDirectDraw FAR *LPDIRECTDRAW; +typedef struct IDirectDraw2 FAR *LPDIRECTDRAW2; +typedef struct IDirectDraw4 FAR *LPDIRECTDRAW4; +typedef struct IDirectDrawSurface FAR *LPDIRECTDRAWSURFACE; +typedef struct IDirectDrawSurface2 FAR *LPDIRECTDRAWSURFACE2; +typedef struct IDirectDrawSurface3 FAR *LPDIRECTDRAWSURFACE3; +typedef struct IDirectDrawSurface4 FAR *LPDIRECTDRAWSURFACE4; + +typedef struct IDirectDrawPalette FAR *LPDIRECTDRAWPALETTE; +typedef struct IDirectDrawClipper FAR *LPDIRECTDRAWCLIPPER; +typedef struct IDirectDrawColorControl FAR *LPDIRECTDRAWCOLORCONTROL; +typedef struct IDirectDrawGammaControl FAR *LPDIRECTDRAWGAMMACONTROL; + +typedef struct _DDFXROP FAR *LPDDFXROP; +typedef struct _DDSURFACEDESC FAR *LPDDSURFACEDESC; +typedef struct _DDSURFACEDESC2 FAR *LPDDSURFACEDESC2; +typedef struct _DDCOLORCONTROL FAR *LPDDCOLORCONTROL; + +/* + * API's + */ +#if (defined (WIN32) || defined( _WIN32 ) ) && !defined( _NO_COM ) +//#if defined( _WIN32 ) && !defined( _NO_ENUM ) + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID); + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID); + extern HRESULT WINAPI DirectDrawEnumerateW( LPDDENUMCALLBACKW lpCallback, LPVOID lpContext ); + extern HRESULT WINAPI DirectDrawEnumerateA( LPDDENUMCALLBACKA lpCallback, LPVOID lpContext ); + /* + * Protect against old SDKs + */ + #ifndef SM_CMONITORS + #define HMONITOR HANDLE + #endif + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXA)(GUID FAR *, LPSTR, LPSTR, LPVOID, HMONITOR); + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID, HMONITOR); + extern HRESULT WINAPI DirectDrawEnumerateExW( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags); + extern HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); + typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXA)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); + typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXW)( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags); + + #ifdef UNICODE + typedef LPDDENUMCALLBACKW LPDDENUMCALLBACK; + #define DirectDrawEnumerate DirectDrawEnumerateW + typedef LPDDENUMCALLBACKEXW LPDDENUMCALLBACKEX; + typedef LPDIRECTDRAWENUMERATEEXW LPDIRECTDRAWENUMERATEEX; + #define DirectDrawEnumerateEx DirectDrawEnumerateExW + #else + typedef LPDDENUMCALLBACKA LPDDENUMCALLBACK; + #define DirectDrawEnumerate DirectDrawEnumerateA + typedef LPDDENUMCALLBACKEXA LPDDENUMCALLBACKEX; + typedef LPDIRECTDRAWENUMERATEEXA LPDIRECTDRAWENUMERATEEX; + #define DirectDrawEnumerateEx DirectDrawEnumerateExA + #endif + extern HRESULT WINAPI DirectDrawCreate( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter ); + extern HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter ); +#endif +/* + * Flags for DirectDrawEnumerateEx + * DirectDrawEnumerateEx supercedes DirectDrawEnumerate. You must use GetProcAddress to + * obtain a function pointer (of type LPDIRECTDRAWENUMERATEEX) to DirectDrawEnumerateEx. + * By default, only the primary display device is enumerated. + * DirectDrawEnumerate is equivalent to DirectDrawEnumerate(,,DDENUM_NONDISPLAYDEVICES) + */ + +/* + * This flag causes enumeration of any GDI display devices which are part of + * the Windows Desktop + */ +#define DDENUM_ATTACHEDSECONDARYDEVICES 0x00000001L + +/* + * This flag causes enumeration of any GDI display devices which are not + * part of the Windows Desktop + */ +#define DDENUM_DETACHEDSECONDARYDEVICES 0x00000002L + +/* + * This flag causes enumeration of non-display devices + */ +#define DDENUM_NONDISPLAYDEVICES 0x00000004L + + +#define REGSTR_KEY_DDHW_DESCRIPTION "Description" +#define REGSTR_KEY_DDHW_DRIVERNAME "DriverName" +#define REGSTR_PATH_DDHW "Hardware\\DirectDrawDrivers" + +#define DDCREATE_HARDWAREONLY 0x00000001l +#define DDCREATE_EMULATIONONLY 0x00000002l + +#if defined(WINNT) || !defined(WIN32) +typedef long HRESULT; +#endif + +//#ifndef WINNT +typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK2)(LPDDSURFACEDESC2, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK2)(LPDIRECTDRAWSURFACE4, LPDDSURFACEDESC2, LPVOID); +//#endif + +/* + * Generic pixel format with 8-bit RGB and alpha components + */ +typedef struct _DDRGBA +{ + BYTE red; + BYTE green; + BYTE blue; + BYTE alpha; +} DDRGBA; + +typedef DDRGBA FAR *LPDDRGBA; + +/* + * DDCOLORKEY + */ +typedef struct _DDCOLORKEY +{ + DWORD dwColorSpaceLowValue; // low boundary of color space that is to + // be treated as Color Key, inclusive + DWORD dwColorSpaceHighValue; // high boundary of color space that is + // to be treated as Color Key, inclusive +} DDCOLORKEY; + +typedef DDCOLORKEY FAR* LPDDCOLORKEY; + +/* + * DDBLTFX + * Used to pass override information to the DIRECTDRAWSURFACE callback Blt. + */ +typedef struct _DDBLTFX +{ + DWORD dwSize; // size of structure + DWORD dwDDFX; // FX operations + DWORD dwROP; // Win32 raster operations + DWORD dwDDROP; // Raster operations new for DirectDraw + DWORD dwRotationAngle; // Rotation angle for blt + DWORD dwZBufferOpCode; // ZBuffer compares + DWORD dwZBufferLow; // Low limit of Z buffer + DWORD dwZBufferHigh; // High limit of Z buffer + DWORD dwZBufferBaseDest; // Destination base value + DWORD dwZDestConstBitDepth; // Bit depth used to specify Z constant for destination + union + { + DWORD dwZDestConst; // Constant to use as Z buffer for dest + LPDIRECTDRAWSURFACE lpDDSZBufferDest; // Surface to use as Z buffer for dest + } DUMMYUNIONNAMEN(1); + DWORD dwZSrcConstBitDepth; // Bit depth used to specify Z constant for source + union + { + DWORD dwZSrcConst; // Constant to use as Z buffer for src + LPDIRECTDRAWSURFACE lpDDSZBufferSrc; // Surface to use as Z buffer for src + } DUMMYUNIONNAMEN(2); + DWORD dwAlphaEdgeBlendBitDepth; // Bit depth used to specify constant for alpha edge blend + DWORD dwAlphaEdgeBlend; // Alpha for edge blending + DWORD dwReserved; + DWORD dwAlphaDestConstBitDepth; // Bit depth used to specify alpha constant for destination + union + { + DWORD dwAlphaDestConst; // Constant to use as Alpha Channel + LPDIRECTDRAWSURFACE lpDDSAlphaDest; // Surface to use as Alpha Channel + } DUMMYUNIONNAMEN(3); + DWORD dwAlphaSrcConstBitDepth; // Bit depth used to specify alpha constant for source + union + { + DWORD dwAlphaSrcConst; // Constant to use as Alpha Channel + LPDIRECTDRAWSURFACE lpDDSAlphaSrc; // Surface to use as Alpha Channel + } DUMMYUNIONNAMEN(4); + union + { + DWORD dwFillColor; // color in RGB or Palettized + DWORD dwFillDepth; // depth value for z-buffer + DWORD dwFillPixel; // pixel value for RGBA or RGBZ + LPDIRECTDRAWSURFACE lpDDSPattern; // Surface to use as pattern + } DUMMYUNIONNAMEN(5); + DDCOLORKEY ddckDestColorkey; // DestColorkey override + DDCOLORKEY ddckSrcColorkey; // SrcColorkey override +} DDBLTFX; + +typedef DDBLTFX FAR* LPDDBLTFX; + + +/* + * DDSCAPS + */ +typedef struct _DDSCAPS +{ + DWORD dwCaps; // capabilities of surface wanted +} DDSCAPS; + +typedef DDSCAPS FAR* LPDDSCAPS; + + +/* + * DDOSCAPS + */ +typedef struct _DDOSCAPS +{ + DWORD dwCaps; // capabilities of surface wanted +} DDOSCAPS; + +typedef DDOSCAPS FAR* LPDDOSCAPS; + +/* + * This structure is used internally by DirectDraw. + */ +typedef struct _DDSCAPSEX +{ + DWORD dwCaps2; + DWORD dwCaps3; + DWORD dwCaps4; +} DDSCAPSEX, FAR * LPDDSCAPSEX; + +/* + * DDSCAPS2 + */ +typedef struct _DDSCAPS2 +{ + DWORD dwCaps; // capabilities of surface wanted + DWORD dwCaps2; + DWORD dwCaps3; + DWORD dwCaps4; +} DDSCAPS2; + +typedef DDSCAPS2 FAR* LPDDSCAPS2; + +/* + * DDCAPS + */ +#define DD_ROP_SPACE (256/32) // space required to store ROP array + +/* + * This structure is the DDCAPS structure as it was in version 2 and 3 of Direct X. + * It is present for back compatability. + */ +typedef struct _DDCAPS_DX3 +{ + DWORD dwSize; // size of the DDDRIVERCAPS structure + DWORD dwCaps; // driver specific capabilities + DWORD dwCaps2; // more driver specific capabilites + DWORD dwCKeyCaps; // color key capabilities of the surface + DWORD dwFXCaps; // driver specific stretching and effects capabilites + DWORD dwFXAlphaCaps; // alpha driver specific capabilities + DWORD dwPalCaps; // palette capabilities + DWORD dwSVCaps; // stereo vision capabilities + DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 + DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 + DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 + DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 + DWORD dwVidMemTotal; // total amount of video memory + DWORD dwVidMemFree; // amount of free video memory + DWORD dwMaxVisibleOverlays; // maximum number of visible overlays + DWORD dwCurrVisibleOverlays; // current number of visible overlays + DWORD dwNumFourCCCodes; // number of four cc codes + DWORD dwAlignBoundarySrc; // source rectangle alignment + DWORD dwAlignSizeSrc; // source rectangle byte size + DWORD dwAlignBoundaryDest; // dest rectangle alignment + DWORD dwAlignSizeDest; // dest rectangle byte size + DWORD dwAlignStrideAlign; // stride alignment + DWORD dwRops[DD_ROP_SPACE]; // ROPS supported + DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities + DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwReserved1; // reserved + DWORD dwReserved2; // reserved + DWORD dwReserved3; // reserved + DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts + DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts + DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts + DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts + DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts + DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts + DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts + DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts + DWORD dwSSBCaps; // driver specific capabilities for System->System blts + DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts + DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts + DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts + DWORD dwReserved4; // reserved + DWORD dwReserved5; // reserved + DWORD dwReserved6; // reserved +} DDCAPS_DX3; +typedef DDCAPS_DX3 FAR* LPDDCAPS_DX3; + +/* + * This structure is the DDCAPS structure as it was in version 5 of Direct X. + * It is present for back compatability. + */ +typedef struct _DDCAPS_DX5 +{ +/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure +/* 4*/ DWORD dwCaps; // driver specific capabilities +/* 8*/ DWORD dwCaps2; // more driver specific capabilites +/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface +/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites +/* 14*/ DWORD dwFXAlphaCaps; // alpha driver specific capabilities +/* 18*/ DWORD dwPalCaps; // palette capabilities +/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities +/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 +/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 +/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 +/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 +/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 +/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 +/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 +/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory +/* 40*/ DWORD dwVidMemFree; // amount of free video memory +/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays +/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays +/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes +/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment +/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size +/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment +/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size +/* 60*/ DWORD dwAlignStrideAlign; // stride alignment +/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported +/* 84*/ DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities +/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* a0*/ DWORD dwReserved1; // reserved +/* a4*/ DWORD dwReserved2; // reserved +/* a8*/ DWORD dwReserved3; // reserved +/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts +/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts +/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts +/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts +/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts +/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts +/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts +/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts +/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts +/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts +/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts +/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts +// Members added for DX5: +/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports +/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used +/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts +/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts +/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts +/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts +/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts +/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts +} DDCAPS_DX5; +typedef DDCAPS_DX5 FAR* LPDDCAPS_DX5; + +typedef struct _DDCAPS_DX6 +{ +/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure +/* 4*/ DWORD dwCaps; // driver specific capabilities +/* 8*/ DWORD dwCaps2; // more driver specific capabilites +/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface +/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites +/* 14*/ DWORD dwFXAlphaCaps; // alpha caps +/* 18*/ DWORD dwPalCaps; // palette capabilities +/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities +/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 +/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 +/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 +/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 +/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 +/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 +/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 +/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory +/* 40*/ DWORD dwVidMemFree; // amount of free video memory +/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays +/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays +/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes +/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment +/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size +/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment +/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size +/* 60*/ DWORD dwAlignStrideAlign; // stride alignment +/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported +/* 84*/ DDSCAPS ddsOldCaps; // Was DDSCAPS ddsCaps. ddsCaps is of type DDSCAPS2 for DX6 +/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* a0*/ DWORD dwReserved1; // reserved +/* a4*/ DWORD dwReserved2; // reserved +/* a8*/ DWORD dwReserved3; // reserved +/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts +/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts +/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts +/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts +/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts +/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts +/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts +/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts +/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts +/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts +/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts +/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts +/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports +/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used +/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts +/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts +/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts +/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts +/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts +/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts +// Members added for DX6 release +/*16c*/ DDSCAPS2 ddsCaps; // Surface Caps +} DDCAPS_DX6; +typedef DDCAPS_DX6 FAR* LPDDCAPS_DX6; + + +#if DIRECTDRAW_VERSION <= 0x300 + typedef DDCAPS_DX3 DDCAPS; +#elif DIRECTDRAW_VERSION <= 0x500 + typedef DDCAPS_DX5 DDCAPS; +#else + typedef DDCAPS_DX6 DDCAPS; +#endif + +typedef DDCAPS FAR* LPDDCAPS; + + + +/* + * DDPIXELFORMAT + */ +typedef struct _DDPIXELFORMAT +{ + DWORD dwSize; // size of structure + DWORD dwFlags; // pixel format flags + DWORD dwFourCC; // (FOURCC code) + union + { + DWORD dwRGBBitCount; // how many bits per pixel + DWORD dwYUVBitCount; // how many bits per pixel + DWORD dwZBufferBitDepth; // how many total bits/pixel in z buffer (including any stencil bits) + DWORD dwAlphaBitDepth; // how many bits for alpha channels + DWORD dwLuminanceBitCount; // how many bits per pixel + DWORD dwBumpBitCount; // how many bits per "buxel", total + } DUMMYUNIONNAMEN(1); + union + { + DWORD dwRBitMask; // mask for red bit + DWORD dwYBitMask; // mask for Y bits + DWORD dwStencilBitDepth; // how many stencil bits (note: dwZBufferBitDepth-dwStencilBitDepth is total Z-only bits) + DWORD dwLuminanceBitMask; // mask for luminance bits + DWORD dwBumpDuBitMask; // mask for bump map U delta bits + } DUMMYUNIONNAMEN(2); + union + { + DWORD dwGBitMask; // mask for green bits + DWORD dwUBitMask; // mask for U bits + DWORD dwZBitMask; // mask for Z bits + DWORD dwBumpDvBitMask; // mask for bump map V delta bits + } DUMMYUNIONNAMEN(3); + union + { + DWORD dwBBitMask; // mask for blue bits + DWORD dwVBitMask; // mask for V bits + DWORD dwStencilBitMask; // mask for stencil bits + DWORD dwBumpLuminanceBitMask; // mask for luminance in bump map + } DUMMYUNIONNAMEN(4); + union + { + DWORD dwRGBAlphaBitMask; // mask for alpha channel + DWORD dwYUVAlphaBitMask; // mask for alpha channel + DWORD dwLuminanceAlphaBitMask;// mask for alpha channel + DWORD dwRGBZBitMask; // mask for Z channel + DWORD dwYUVZBitMask; // mask for Z channel + } DUMMYUNIONNAMEN(5); +} DDPIXELFORMAT; + +typedef DDPIXELFORMAT FAR* LPDDPIXELFORMAT; + +/* + * DDOVERLAYFX + */ +typedef struct _DDOVERLAYFX +{ + DWORD dwSize; // size of structure + DWORD dwAlphaEdgeBlendBitDepth; // Bit depth used to specify constant for alpha edge blend + DWORD dwAlphaEdgeBlend; // Constant to use as alpha for edge blend + DWORD dwReserved; + DWORD dwAlphaDestConstBitDepth; // Bit depth used to specify alpha constant for destination + union + { + DWORD dwAlphaDestConst; // Constant to use as alpha channel for dest + LPDIRECTDRAWSURFACE lpDDSAlphaDest; // Surface to use as alpha channel for dest + } DUMMYUNIONNAMEN(1); + DWORD dwAlphaSrcConstBitDepth; // Bit depth used to specify alpha constant for source + union + { + DWORD dwAlphaSrcConst; // Constant to use as alpha channel for src + LPDIRECTDRAWSURFACE lpDDSAlphaSrc; // Surface to use as alpha channel for src + } DUMMYUNIONNAMEN(2); + DDCOLORKEY dckDestColorkey; // DestColorkey override + DDCOLORKEY dckSrcColorkey; // DestColorkey override + DWORD dwDDFX; // Overlay FX + DWORD dwFlags; // flags +} DDOVERLAYFX; + +typedef DDOVERLAYFX FAR *LPDDOVERLAYFX; + + +/* + * DDBLTBATCH: BltBatch entry structure + */ +typedef struct _DDBLTBATCH +{ + LPRECT lprDest; + LPDIRECTDRAWSURFACE lpDDSSrc; + LPRECT lprSrc; + DWORD dwFlags; + LPDDBLTFX lpDDBltFx; +} DDBLTBATCH; + +typedef DDBLTBATCH FAR * LPDDBLTBATCH; + + +/* + * DDGAMMARAMP + */ +typedef struct _DDGAMMARAMP +{ + WORD red[256]; + WORD green[256]; + WORD blue[256]; +} DDGAMMARAMP; +typedef DDGAMMARAMP FAR * LPDDGAMMARAMP; + +/* + * This is the structure within which DirectDraw returns data about the current graphics driver and chipset + */ + +#define MAX_DDDEVICEID_STRING 512 + +typedef struct tagDDDEVICEIDENTIFIER +{ + /* + * These elements are for presentation to the user only. They should not be used to identify particular + * drivers, since this is unreliable and many different strings may be associated with the same + * device, and the same driver from different vendors. + */ + char szDriver[MAX_DDDEVICEID_STRING]; + char szDescription[MAX_DDDEVICEID_STRING]; + + /* + * This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons + * on the whole 64 bits. Caution should be exercised if you use this element to identify problematic + * drivers. It is recommended that guidDeviceIdentifier is used for this purpose. + * + * This version has the form: + * wProduct = HIWORD(liDriverVersion.HighPart) + * wVersion = LOWORD(liDriverVersion.HighPart) + * wSubVersion = HIWORD(liDriverVersion.LowPart) + * wBuild = LOWORD(liDriverVersion.LowPart) + */ +#ifdef _WIN32 + LARGE_INTEGER liDriverVersion; /* Defined for applications and other 32 bit components */ +#else + DWORD dwDriverVersionLowPart; /* Defined for 16 bit driver components */ + DWORD dwDriverVersionHighPart; +#endif + + + /* + * These elements can be used to identify particular chipsets. Use with extreme caution. + * dwVendorId Identifies the manufacturer. May be zero if unknown. + * dwDeviceId Identifies the type of chipset. May be zero if unknown. + * dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown. + * dwRevision Identifies the revision level of the chipset. May be zero if unknown. + */ + DWORD dwVendorId; + DWORD dwDeviceId; + DWORD dwSubSysId; + DWORD dwRevision; + + /* + * This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the + * driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to + * reprofile the graphics subsystem. + * This element can also be used to identify particular problematic drivers. + */ + GUID guidDeviceIdentifier; +} DDDEVICEIDENTIFIER, * LPDDDEVICEIDENTIFIER; + +/* + * Flags for the IDirectDraw4::GetDeviceIdentifier method + */ + +/* + * This flag causes GetDeviceIdentifier to return information about the host (typically 2D) adapter in a system equipped + * with a stacked secondary 3D adapter. Such an adapter appears to the application as if it were part of the + * host adapter, but is typically physcially located on a separate card. The stacked secondary's information is + * returned when GetDeviceIdentifier's dwFlags field is zero, since this most accurately reflects the qualities + * of the DirectDraw object involved. + */ +#define DDGDI_GETHOSTIDENTIFIER 0x00000001L + + + +/* + * callbacks + */ +typedef DWORD (FAR PASCAL *LPCLIPPERCALLBACK)(LPDIRECTDRAWCLIPPER lpDDClipper, HWND hWnd, DWORD code, LPVOID lpContext ); +#ifdef STREAMING +typedef DWORD (FAR PASCAL *LPSURFACESTREAMINGCALLBACK)(DWORD); +#endif + + +/* + * INTERACES FOLLOW: + * IDirectDraw + * IDirectDrawClipper + * IDirectDrawPalette + * IDirectDrawSurface + */ + +/* + * IDirectDraw + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw +DECLARE_INTERFACE_( IDirectDraw, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw_SetDisplayMode(p, a, b, c) (p)->lpVtbl->SetDisplayMode(p, a, b, c) +#define IDirectDraw_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#else +#define IDirectDraw_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw_AddRef(p) (p)->AddRef() +#define IDirectDraw_Release(p) (p)->Release() +#define IDirectDraw_Compact(p) (p)->Compact() +#define IDirectDraw_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw_SetDisplayMode(p, a, b, c) (p)->SetDisplayMode(a, b, c) +#define IDirectDraw_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#endif + +#endif + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw2 +DECLARE_INTERFACE_( IDirectDraw2, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS, LPDWORD, LPDWORD) PURE; +}; +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw2_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw2_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw2_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw2_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw2_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw2_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw2_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw2_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw2_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw2_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw2_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw2_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw2_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw2_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw2_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw2_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw2_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw2_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw2_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e) +#define IDirectDraw2_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#define IDirectDraw2_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c) +#else +#define IDirectDraw2_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw2_AddRef(p) (p)->AddRef() +#define IDirectDraw2_Release(p) (p)->Release() +#define IDirectDraw2_Compact(p) (p)->Compact() +#define IDirectDraw2_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw2_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw2_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw2_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw2_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw2_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw2_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw2_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw2_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw2_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw2_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw2_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw2_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw2_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw2_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw2_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e) +#define IDirectDraw2_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#define IDirectDraw2_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c) +#endif + +#endif + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw4 +DECLARE_INTERFACE_( IDirectDraw4, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE4 FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE4 FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE; + /*** Added in the V4 Interface ***/ + STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE4 *) PURE; + STDMETHOD(RestoreAllSurfaces)(THIS) PURE; + STDMETHOD(TestCooperativeLevel)(THIS) PURE; + STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER, DWORD ) PURE; +}; +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw4_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw4_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw4_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw4_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw4_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw4_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw4_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw4_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw4_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw4_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw4_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw4_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw4_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw4_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw4_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw4_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw4_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw4_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw4_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw4_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e) +#define IDirectDraw4_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#define IDirectDraw4_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c) +#define IDirectDraw4_GetSurfaceFromDC(p, a, b) (p)->lpVtbl->GetSurfaceFromDC(p, a, b) +#define IDirectDraw4_RestoreAllSurfaces(p) (p)->lpVtbl->RestoreAllSurfaces(p) +#define IDirectDraw4_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p) +#define IDirectDraw4_GetDeviceIdentifier(p,a,b) (p)->lpVtbl->GetDeviceIdentifier(p,a,b) +#else +#define IDirectDraw4_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw4_AddRef(p) (p)->AddRef() +#define IDirectDraw4_Release(p) (p)->Release() +#define IDirectDraw4_Compact(p) (p)->Compact() +#define IDirectDraw4_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw4_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw4_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw4_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw4_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw4_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw4_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw4_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw4_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw4_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw4_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw4_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw4_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw4_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw4_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw4_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e) +#define IDirectDraw4_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#define IDirectDraw4_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c) +#define IDirectDraw4_GetSurfaceFromDC(p, a, b) (p)->GetSurfaceFromDC(a, b) +#define IDirectDraw4_RestoreAllSurfaces(p) (p)->RestoreAllSurfaces() +#define IDirectDraw4_TestCooperativeLevel(p) (p)->TestCooperativeLevel() +#define IDirectDraw4_GetDeviceIdentifier(p,a,b) (p)->GetDeviceIdentifier(a,b) +#endif + +#endif + + +/* + * IDirectDrawPalette + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawPalette +DECLARE_INTERFACE_( IDirectDrawPalette, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawPalette methods ***/ + STDMETHOD(GetCaps)(THIS_ LPDWORD) PURE; + STDMETHOD(GetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD, LPPALETTEENTRY) PURE; + STDMETHOD(SetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawPalette_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawPalette_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawPalette_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawPalette_GetCaps(p, a) (p)->lpVtbl->GetCaps(p, a) +#define IDirectDrawPalette_GetEntries(p, a, b, c, d) (p)->lpVtbl->GetEntries(p, a, b, c, d) +#define IDirectDrawPalette_Initialize(p, a, b, c) (p)->lpVtbl->Initialize(p, a, b, c) +#define IDirectDrawPalette_SetEntries(p, a, b, c, d) (p)->lpVtbl->SetEntries(p, a, b, c, d) +#else +#define IDirectDrawPalette_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawPalette_AddRef(p) (p)->AddRef() +#define IDirectDrawPalette_Release(p) (p)->Release() +#define IDirectDrawPalette_GetCaps(p, a) (p)->GetCaps(a) +#define IDirectDrawPalette_GetEntries(p, a, b, c, d) (p)->GetEntries(a, b, c, d) +#define IDirectDrawPalette_Initialize(p, a, b, c) (p)->Initialize(a, b, c) +#define IDirectDrawPalette_SetEntries(p, a, b, c, d) (p)->SetEntries(a, b, c, d) +#endif + +#endif + + + +/* + * IDirectDrawClipper + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawClipper +DECLARE_INTERFACE_( IDirectDrawClipper, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawClipper methods ***/ + STDMETHOD(GetClipList)(THIS_ LPRECT, LPRGNDATA, LPDWORD) PURE; + STDMETHOD(GetHWnd)(THIS_ HWND FAR *) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD) PURE; + STDMETHOD(IsClipListChanged)(THIS_ BOOL FAR *) PURE; + STDMETHOD(SetClipList)(THIS_ LPRGNDATA,DWORD) PURE; + STDMETHOD(SetHWnd)(THIS_ DWORD, HWND ) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawClipper_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawClipper_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawClipper_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawClipper_GetClipList(p, a, b, c) (p)->lpVtbl->GetClipList(p, a, b, c) +#define IDirectDrawClipper_GetHWnd(p, a) (p)->lpVtbl->GetHWnd(p, a) +#define IDirectDrawClipper_Initialize(p, a, b) (p)->lpVtbl->Initialize(p, a, b) +#define IDirectDrawClipper_IsClipListChanged(p, a) (p)->lpVtbl->IsClipListChanged(p, a) +#define IDirectDrawClipper_SetClipList(p, a, b) (p)->lpVtbl->SetClipList(p, a, b) +#define IDirectDrawClipper_SetHWnd(p, a, b) (p)->lpVtbl->SetHWnd(p, a, b) +#else +#define IDirectDrawClipper_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawClipper_AddRef(p) (p)->AddRef() +#define IDirectDrawClipper_Release(p) (p)->Release() +#define IDirectDrawClipper_GetClipList(p, a, b, c) (p)->GetClipList(a, b, c) +#define IDirectDrawClipper_GetHWnd(p, a) (p)->GetHWnd(a) +#define IDirectDrawClipper_Initialize(p, a, b) (p)->Initialize(a, b) +#define IDirectDrawClipper_IsClipListChanged(p, a) (p)->IsClipListChanged(a) +#define IDirectDrawClipper_SetClipList(p, a, b) (p)->SetClipList(a, b) +#define IDirectDrawClipper_SetHWnd(p, a, b) (p)->SetHWnd(a, b) +#endif + +#endif + +/* + * IDirectDrawSurface and related interfaces + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawSurface +DECLARE_INTERFACE_( IDirectDrawSurface, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPVOID) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#else +#define IDirectDrawSurface_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface_Release(p) (p)->Release() +#define IDirectDrawSurface_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface_Restore(p) (p)->Restore() +#define IDirectDrawSurface_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#endif + +/* + * IDirectDrawSurface2 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface2 +DECLARE_INTERFACE_( IDirectDrawSurface2, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE2) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE2) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE2, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPVOID) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE2) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface2_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface2_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface2_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface2_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface2_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface2_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface2_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface2_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface2_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface2_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface2_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface2_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface2_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface2_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface2_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface2_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface2_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface2_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface2_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface2_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface2_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface2_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface2_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface2_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface2_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface2_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface2_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface2_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface2_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#else +#define IDirectDrawSurface2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface2_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface2_Release(p) (p)->Release() +#define IDirectDrawSurface2_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface2_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface2_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface2_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface2_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface2_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface2_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface2_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface2_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface2_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface2_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface2_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface2_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface2_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface2_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface2_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface2_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface2_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface2_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface2_Restore(p) (p)->Restore() +#define IDirectDrawSurface2_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface2_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface2_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface2_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface2_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface2_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface2_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface2_PageUnlock(p,a) (p)->PageUnlock(a) +#endif + +/* + * IDirectDrawSurface3 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface3 +DECLARE_INTERFACE_( IDirectDrawSurface3, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE3) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE3) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE3, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPVOID) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE3) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; + /*** Added in the V3 interface ***/ + STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC, DWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface3_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface3_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface3_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface3_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface3_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface3_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface3_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface3_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface3_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface3_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface3_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface3_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface3_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface3_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface3_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface3_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface3_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface3_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface3_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface3_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface3_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface3_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface3_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface3_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface3_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface3_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface3_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface3_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface3_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b) +#else +#define IDirectDrawSurface3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface3_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface3_Release(p) (p)->Release() +#define IDirectDrawSurface3_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface3_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface3_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface3_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface3_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface3_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface3_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface3_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface3_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface3_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface3_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface3_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface3_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface3_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface3_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface3_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface3_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface3_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface3_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface3_Restore(p) (p)->Restore() +#define IDirectDrawSurface3_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface3_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface3_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface3_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface3_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface3_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface3_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface3_PageUnlock(p,a) (p)->PageUnlock(a) +#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b) +#endif + +/* + * IDirectDrawSurface4 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface4 +DECLARE_INTERFACE_( IDirectDrawSurface4, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE4) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE4) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK2) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE4, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPRECT) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE4) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; + /*** Added in the v3 interface ***/ + STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE; + /*** Added in the v4 interface ***/ + STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE; + STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE; + STDMETHOD(ChangeUniquenessValue)(THIS) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface4_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface4_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface4_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface4_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface4_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface4_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface4_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface4_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface4_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface4_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface4_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface4_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface4_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface4_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface4_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface4_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface4_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface4_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface4_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface4_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface4_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface4_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface4_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface4_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface4_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface4_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface4_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface4_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface4_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface4_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface4_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b) +#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirectDrawSurface4_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirectDrawSurface4_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirectDrawSurface4_GetUniquenessValue(p, a) (p)->lpVtbl->GetUniquenessValue(p, a) +#define IDirectDrawSurface4_ChangeUniquenessValue(p) (p)->lpVtbl->ChangeUniquenessValue(p) +#else +#define IDirectDrawSurface4_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface4_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface4_Release(p) (p)->Release() +#define IDirectDrawSurface4_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface4_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface4_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface4_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface4_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface4_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface4_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface4_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface4_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface4_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface4_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface4_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface4_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface4_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface4_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface4_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface4_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface4_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface4_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface4_Restore(p) (p)->Restore() +#define IDirectDrawSurface4_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface4_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface4_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface4_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface4_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface4_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface4_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface4_PageUnlock(p,a) (p)->PageUnlock(a) +#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b) +#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirectDrawSurface4_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirectDrawSurface4_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirectDrawSurface4_GetUniquenessValue(p, a) (p)->GetUniquenessValue(a) +#define IDirectDrawSurface4_ChangeUniquenessValue(p) (p)->ChangeUniquenessValue() +#endif + + + +/* + * IDirectDrawColorControl + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawColorControl +DECLARE_INTERFACE_( IDirectDrawColorControl, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawColorControl methods ***/ + STDMETHOD(GetColorControls)(THIS_ LPDDCOLORCONTROL) PURE; + STDMETHOD(SetColorControls)(THIS_ LPDDCOLORCONTROL) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawColorControl_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawColorControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawColorControl_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawColorControl_GetColorControls(p, a) (p)->lpVtbl->GetColorControls(p, a) +#define IDirectDrawColorControl_SetColorControls(p, a) (p)->lpVtbl->SetColorControls(p, a) +#else +#define IDirectDrawColorControl_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawColorControl_AddRef(p) (p)->AddRef() +#define IDirectDrawColorControl_Release(p) (p)->Release() +#define IDirectDrawColorControl_GetColorControls(p, a) (p)->GetColorControls(a) +#define IDirectDrawColorControl_SetColorControls(p, a) (p)->SetColorControls(a) +#endif + +#endif + + +/* + * IDirectDrawGammaControl + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawGammaControl +DECLARE_INTERFACE_( IDirectDrawGammaControl, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawColorControl methods ***/ + STDMETHOD(GetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE; + STDMETHOD(SetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawGammaControl_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawGammaControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawGammaControl_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawGammaControl_GetGammaRamp(p, a, b) (p)->lpVtbl->GetGammaRamp(p, a, b) +#define IDirectDrawGammaControl_SetGammaRamp(p, a, b) (p)->lpVtbl->SetGammaRamp(p, a, b) +#else +#define IDirectDrawGammaControl_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawGammaControl_AddRef(p) (p)->AddRef() +#define IDirectDrawGammaControl_Release(p) (p)->Release() +#define IDirectDrawGammaControl_GetGammaRamp(p, a, b) (p)->GetGammaRamp(a, b) +#define IDirectDrawGammaControl_SetGammaRamp(p, a, b) (p)->SetGammaRamp(a, b) +#endif + +#endif + + + +#endif + + +/* + * DDSURFACEDESC + */ +typedef struct _DDSURFACEDESC +{ + DWORD dwSize; // size of the DDSURFACEDESC structure + DWORD dwFlags; // determines what fields are valid + DWORD dwHeight; // height of surface to be created + DWORD dwWidth; // width of input surface + union + { + LONG lPitch; // distance to start of next line (return value only) + DWORD dwLinearSize; // Formless late-allocated optimized surface size + } DUMMYUNIONNAMEN(1); + DWORD dwBackBufferCount; // number of back buffers requested + union + { + DWORD dwMipMapCount; // number of mip-map levels requested + DWORD dwZBufferBitDepth; // depth of Z buffer requested + DWORD dwRefreshRate; // refresh rate (used when display mode is described) + } DUMMYUNIONNAMEN(2); + DWORD dwAlphaBitDepth; // depth of alpha buffer requested + DWORD dwReserved; // reserved + LPVOID lpSurface; // pointer to the associated surface memory + DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use + DDCOLORKEY ddckCKDestBlt; // color key for destination blt use + DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use + DDCOLORKEY ddckCKSrcBlt; // color key for source blt use + DDPIXELFORMAT ddpfPixelFormat; // pixel format description of the surface + DDSCAPS ddsCaps; // direct draw surface capabilities +} DDSURFACEDESC; + +/* + * DDSURFACEDESC2 + */ +typedef struct _DDSURFACEDESC2 +{ + DWORD dwSize; // size of the DDSURFACEDESC structure + DWORD dwFlags; // determines what fields are valid + DWORD dwHeight; // height of surface to be created + DWORD dwWidth; // width of input surface + union + { + LONG lPitch; // distance to start of next line (return value only) + DWORD dwLinearSize; // Formless late-allocated optimized surface size + } DUMMYUNIONNAMEN(1); + DWORD dwBackBufferCount; // number of back buffers requested + union + { + DWORD dwMipMapCount; // number of mip-map levels requestde + // dwZBufferBitDepth removed, use ddpfPixelFormat one instead + DWORD dwRefreshRate; // refresh rate (used when display mode is described) + } DUMMYUNIONNAMEN(2); + DWORD dwAlphaBitDepth; // depth of alpha buffer requested + DWORD dwReserved; // reserved + LPVOID lpSurface; // pointer to the associated surface memory + DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use + DDCOLORKEY ddckCKDestBlt; // color key for destination blt use + DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use + DDCOLORKEY ddckCKSrcBlt; // color key for source blt use + DDPIXELFORMAT ddpfPixelFormat; // pixel format description of the surface + DDSCAPS2 ddsCaps; // direct draw surface capabilities + DWORD dwTextureStage; // stage in multitexture cascade +} DDSURFACEDESC2; + +/* + * ddsCaps field is valid. + */ +#define DDSD_CAPS 0x00000001l // default + +/* + * dwHeight field is valid. + */ +#define DDSD_HEIGHT 0x00000002l + +/* + * dwWidth field is valid. + */ +#define DDSD_WIDTH 0x00000004l + +/* + * lPitch is valid. + */ +#define DDSD_PITCH 0x00000008l + +/* + * dwBackBufferCount is valid. + */ +#define DDSD_BACKBUFFERCOUNT 0x00000020l + +/* + * dwZBufferBitDepth is valid. (shouldnt be used in DDSURFACEDESC2) + */ +#define DDSD_ZBUFFERBITDEPTH 0x00000040l + +/* + * dwAlphaBitDepth is valid. + */ +#define DDSD_ALPHABITDEPTH 0x00000080l + + +/* + * lpSurface is valid. + */ +#define DDSD_LPSURFACE 0x00000800l + +/* + * ddpfPixelFormat is valid. + */ +#define DDSD_PIXELFORMAT 0x00001000l + +/* + * ddckCKDestOverlay is valid. + */ +#define DDSD_CKDESTOVERLAY 0x00002000l + +/* + * ddckCKDestBlt is valid. + */ +#define DDSD_CKDESTBLT 0x00004000l + +/* + * ddckCKSrcOverlay is valid. + */ +#define DDSD_CKSRCOVERLAY 0x00008000l + +/* + * ddckCKSrcBlt is valid. + */ +#define DDSD_CKSRCBLT 0x00010000l + +/* + * dwMipMapCount is valid. + */ +#define DDSD_MIPMAPCOUNT 0x00020000l + + /* + * dwRefreshRate is valid + */ +#define DDSD_REFRESHRATE 0x00040000l + +/* + * dwLinearSize is valid + */ +#define DDSD_LINEARSIZE 0x00080000l + +/* + * dwTextureStage is valid + */ +#define DDSD_TEXTURESTAGE 0x00100000l +/* + * All input fields are valid. + */ +#define DDSD_ALL 0x001ff9eel + + +/* + * DDOPTSURFACEDESC + */ +typedef struct _DDOPTSURFACEDESC +{ + DWORD dwSize; // size of the DDOPTSURFACEDESC structure + DWORD dwFlags; // determines what fields are valid + DDSCAPS2 ddSCaps; // Common caps like: Memory type + DDOSCAPS ddOSCaps; // Common caps like: Memory type + GUID guid; // Compression technique GUID + DWORD dwCompressionRatio; // Compression ratio +} DDOPTSURFACEDESC; + +/* + * guid field is valid. + */ +#define DDOSD_GUID 0x00000001l + +/* + * dwCompressionRatio field is valid. + */ +#define DDOSD_COMPRESSION_RATIO 0x00000002l + +/* + * ddSCaps field is valid. + */ +#define DDOSD_SCAPS 0x00000004l + +/* + * ddOSCaps field is valid. + */ +#define DDOSD_OSCAPS 0x00000008l + +/* + * All input fields are valid. + */ +#define DDOSD_ALL 0x0000000fl + +/* + * The surface's optimized pixelformat is compressed + */ +#define DDOSDCAPS_OPTCOMPRESSED 0x00000001l + +/* + * The surface's optimized pixelformat is reordered + */ +#define DDOSDCAPS_OPTREORDERED 0x00000002l + +/* + * The opt surface is a monolithic mipmap + */ +#define DDOSDCAPS_MONOLITHICMIPMAP 0x00000004l + +/* + * The valid Surf caps: + * #define DDSCAPS_SYSTEMMEMORY 0x00000800l + * #define DDSCAPS_VIDEOMEMORY 0x00004000l + * #define DDSCAPS_LOCALVIDMEM 0x10000000l + * #define DDSCAPS_NONLOCALVIDMEM 0x20000000l + */ +#define DDOSDCAPS_VALIDSCAPS 0x30004800l + +/* + * The valid OptSurf caps + */ +#define DDOSDCAPS_VALIDOSCAPS 0x00000007l + + +/* + * DDCOLORCONTROL + */ +typedef struct _DDCOLORCONTROL +{ + DWORD dwSize; + DWORD dwFlags; + LONG lBrightness; + LONG lContrast; + LONG lHue; + LONG lSaturation; + LONG lSharpness; + LONG lGamma; + LONG lColorEnable; + DWORD dwReserved1; +} DDCOLORCONTROL; + + +/* + * lBrightness field is valid. + */ +#define DDCOLOR_BRIGHTNESS 0x00000001l + +/* + * lContrast field is valid. + */ +#define DDCOLOR_CONTRAST 0x00000002l + +/* + * lHue field is valid. + */ +#define DDCOLOR_HUE 0x00000004l + +/* + * lSaturation field is valid. + */ +#define DDCOLOR_SATURATION 0x00000008l + +/* + * lSharpness field is valid. + */ +#define DDCOLOR_SHARPNESS 0x00000010l + +/* + * lGamma field is valid. + */ +#define DDCOLOR_GAMMA 0x00000020l + +/* + * lColorEnable field is valid. + */ +#define DDCOLOR_COLORENABLE 0x00000040l + + + +/*============================================================================ + * + * Direct Draw Capability Flags + * + * These flags are used to describe the capabilities of a given Surface. + * All flags are bit flags. + * + *==========================================================================*/ + +/**************************************************************************** + * + * DIRECTDRAWSURFACE CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * This bit is reserved. It should not be specified. + */ +#define DDSCAPS_RESERVED1 0x00000001l + +/* + * Indicates that this surface contains alpha-only information. + * (To determine if a surface is RGBA/YUVA, the pixel format must be + * interrogated.) + */ +#define DDSCAPS_ALPHA 0x00000002l + +/* + * Indicates that this surface is a backbuffer. It is generally + * set by CreateSurface when the DDSCAPS_FLIP capability bit is set. + * It indicates that this surface is THE back buffer of a surface + * flipping structure. DirectDraw supports N surfaces in a + * surface flipping structure. Only the surface that immediately + * precedeces the DDSCAPS_FRONTBUFFER has this capability bit set. + * The other surfaces are identified as back buffers by the presence + * of the DDSCAPS_FLIP capability, their attachment order, and the + * absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER + * capabilities. The bit is sent to CreateSurface when a standalone + * back buffer is being created. This surface could be attached to + * a front buffer and/or back buffers to form a flipping surface + * structure after the CreateSurface call. See AddAttachments for + * a detailed description of the behaviors in this case. + */ +#define DDSCAPS_BACKBUFFER 0x00000004l + +/* + * Indicates a complex surface structure is being described. A + * complex surface structure results in the creation of more than + * one surface. The additional surfaces are attached to the root + * surface. The complex structure can only be destroyed by + * destroying the root. + */ +#define DDSCAPS_COMPLEX 0x00000008l + +/* + * Indicates that this surface is a part of a surface flipping structure. + * When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and + * DDSCAP_BACKBUFFER bits are not set. They are set by CreateSurface + * on the resulting creations. The dwBackBufferCount field in the + * DDSURFACEDESC structure must be set to at least 1 in order for + * the CreateSurface call to succeed. The DDSCAPS_COMPLEX capability + * must always be set with creating multiple surfaces through CreateSurface. + */ +#define DDSCAPS_FLIP 0x00000010l + +/* + * Indicates that this surface is THE front buffer of a surface flipping + * structure. It is generally set by CreateSurface when the DDSCAPS_FLIP + * capability bit is set. + * If this capability is sent to CreateSurface then a standalonw front buffer + * is created. This surface will not have the DDSCAPS_FLIP capability. + * It can be attached to other back buffers to form a flipping structure. + * See AddAttachments for a detailed description of the behaviors in this + * case. + */ +#define DDSCAPS_FRONTBUFFER 0x00000020l + +/* + * Indicates that this surface is any offscreen surface that is not an overlay, + * texture, zbuffer, front buffer, back buffer, or alpha surface. It is used + * to identify plain vanilla surfaces. + */ +#define DDSCAPS_OFFSCREENPLAIN 0x00000040l + +/* + * Indicates that this surface is an overlay. It may or may not be directly visible + * depending on whether or not it is currently being overlayed onto the primary + * surface. DDSCAPS_VISIBLE can be used to determine whether or not it is being + * overlayed at the moment. + */ +#define DDSCAPS_OVERLAY 0x00000080l + +/* + * Indicates that unique DirectDrawPalette objects can be created and + * attached to this surface. + */ +#define DDSCAPS_PALETTE 0x00000100l + +/* + * Indicates that this surface is the primary surface. The primary + * surface represents what the user is seeing at the moment. + */ +#define DDSCAPS_PRIMARYSURFACE 0x00000200l + +/* + * Indicates that this surface is the primary surface for the left eye. + * The primary surface for the left eye represents what the user is seeing + * at the moment with the users left eye. When this surface is created the + * DDSCAPS_PRIMARYSURFACE represents what the user is seeing with the users + * right eye. + */ +#define DDSCAPS_PRIMARYSURFACELEFT 0x00000400l + +/* + * Indicates that this surface memory was allocated in system memory + */ +#define DDSCAPS_SYSTEMMEMORY 0x00000800l + +/* + * Indicates that this surface can be used as a 3D texture. It does not + * indicate whether or not the surface is being used for that purpose. + */ +#define DDSCAPS_TEXTURE 0x00001000l + +/* + * Indicates that a surface may be a destination for 3D rendering. This + * bit must be set in order to query for a Direct3D Device Interface + * from this surface. + */ +#define DDSCAPS_3DDEVICE 0x00002000l + +/* + * Indicates that this surface exists in video memory. + */ +#define DDSCAPS_VIDEOMEMORY 0x00004000l + +/* + * Indicates that changes made to this surface are immediately visible. + * It is always set for the primary surface and is set for overlays while + * they are being overlayed and texture maps while they are being textured. + */ +#define DDSCAPS_VISIBLE 0x00008000l + +/* + * Indicates that only writes are permitted to the surface. Read accesses + * from the surface may or may not generate a protection fault, but the + * results of a read from this surface will not be meaningful. READ ONLY. + */ +#define DDSCAPS_WRITEONLY 0x00010000l + +/* + * Indicates that this surface is a z buffer. A z buffer does not contain + * displayable information. Instead it contains bit depth information that is + * used to determine which pixels are visible and which are obscured. + */ +#define DDSCAPS_ZBUFFER 0x00020000l + +/* + * Indicates surface will have a DC associated long term + */ +#define DDSCAPS_OWNDC 0x00040000l + +/* + * Indicates surface should be able to receive live video + */ +#define DDSCAPS_LIVEVIDEO 0x00080000l + +/* + * Indicates surface should be able to have a stream decompressed + * to it by the hardware. + */ +#define DDSCAPS_HWCODEC 0x00100000l + +/* + * Surface is a ModeX surface. + * + */ +#define DDSCAPS_MODEX 0x00200000l + +/* + * Indicates surface is one level of a mip-map. This surface will + * be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map. + * This can be done explicitly, by creating a number of surfaces and + * attaching them with AddAttachedSurface or by implicitly by CreateSurface. + * If this bit is set then DDSCAPS_TEXTURE must also be set. + */ +#define DDSCAPS_MIPMAP 0x00400000l + +/* + * This bit is reserved. It should not be specified. + */ +#define DDSCAPS_RESERVED2 0x00800000l + + +/* + * Indicates that memory for the surface is not allocated until the surface + * is loaded (via the Direct3D texture Load() function). + */ +#define DDSCAPS_ALLOCONLOAD 0x04000000l + +/* + * Indicates that the surface will recieve data from a video port. + */ +#define DDSCAPS_VIDEOPORT 0x08000000l + +/* + * Indicates that a video memory surface is resident in true, local video + * memory rather than non-local video memory. If this flag is specified then + * so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with + * DDSCAPS_NONLOCALVIDMEM. + */ +#define DDSCAPS_LOCALVIDMEM 0x10000000l + +/* + * Indicates that a video memory surface is resident in non-local video + * memory rather than true, local video memory. If this flag is specified + * then so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with + * DDSCAPS_LOCALVIDMEM. + */ +#define DDSCAPS_NONLOCALVIDMEM 0x20000000l + +/* + * Indicates that this surface is a standard VGA mode surface, and not a + * ModeX surface. (This flag will never be set in combination with the + * DDSCAPS_MODEX flag). + */ +#define DDSCAPS_STANDARDVGAMODE 0x40000000l + +/* + * Indicates that this surface will be an optimized surface. This flag is + * currently only valid in conjunction with the DDSCAPS_TEXTURE flag. The surface + * will be created without any underlying video memory until loaded. + */ +#define DDSCAPS_OPTIMIZED 0x80000000l + + + + +/* + * Indicates that this surface will receive data from a video port using + * the de-interlacing hardware. This allows the driver to allocate memory + * for any extra buffers that may be required. The DDSCAPS_VIDEOPORT and + * DDSCAPS_OVERLAY flags must also be set. + */ +#define DDSCAPS2_HARDWAREDEINTERLACE 0x00000002L + +/* + * Indicates to the driver that this surface will be locked very frequently + * (for procedural textures, dynamic lightmaps, etc). Surfaces with this cap + * set must also have DDSCAPS_TEXTURE. This cap cannot be used with + * DDSCAPS2_HINTSTATIC and DDSCAPS2_OPAQUE. + */ +#define DDSCAPS2_HINTDYNAMIC 0x00000004L + +/* + * Indicates to the driver that this surface can be re-ordered/retiled on + * load. This operation will not change the size of the texture. It is + * relatively fast and symmetrical, since the application may lock these + * bits (although it will take a performance hit when doing so). Surfaces + * with this cap set must also have DDSCAPS_TEXTURE. This cap cannot be + * used with DDSCAPS2_HINTDYNAMIC and DDSCAPS2_OPAQUE. + */ +#define DDSCAPS2_HINTSTATIC 0x00000008L + +/* + * Indicates that the client would like this texture surface to be managed by the + * DirectDraw/Direct3D runtime. Surfaces with this cap set must also have + * DDSCAPS_TEXTURE set. + */ +#define DDSCAPS2_TEXTUREMANAGE 0x00000010L + +/* + * These bits are reserved for internal use */ +#define DDSCAPS2_RESERVED1 0x00000020L +#define DDSCAPS2_RESERVED2 0x00000040L + +/* + * Indicates to the driver that this surface will never be locked again. + * The driver is free to optimize this surface via retiling and actual compression. + * All calls to Lock() or Blts from this surface will fail. Surfaces with this + * cap set must also have DDSCAPS_TEXTURE. This cap cannot be used with + * DDSCAPS2_HINTDYNAMIC and DDSCAPS2_HINTSTATIC. + */ +#define DDSCAPS2_OPAQUE 0x00000080L + +/* + * Applications should set this bit at CreateSurface time to indicate that they + * intend to use antialiasing. Only valid if DDSCAPS_3DDEVICE is also set. + */ +#define DDSCAPS2_HINTANTIALIASING 0x00000100L + + + + + /**************************************************************************** + * + * DIRECTDRAW DRIVER CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Display hardware has 3D acceleration. + */ +#define DDCAPS_3D 0x00000001l + +/* + * Indicates that DirectDraw will support only dest rectangles that are aligned + * on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively. + * READ ONLY. + */ +#define DDCAPS_ALIGNBOUNDARYDEST 0x00000002l + +/* + * Indicates that DirectDraw will support only source rectangles whose sizes in + * BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively. READ ONLY. + */ +#define DDCAPS_ALIGNSIZEDEST 0x00000004l +/* + * Indicates that DirectDraw will support only source rectangles that are aligned + * on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively. + * READ ONLY. + */ +#define DDCAPS_ALIGNBOUNDARYSRC 0x00000008l + +/* + * Indicates that DirectDraw will support only source rectangles whose sizes in + * BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively. READ ONLY. + */ +#define DDCAPS_ALIGNSIZESRC 0x00000010l + +/* + * Indicates that DirectDraw will create video memory surfaces that have a stride + * alignment equal to DIRECTDRAWCAPS.dwAlignStride. READ ONLY. + */ +#define DDCAPS_ALIGNSTRIDE 0x00000020l + +/* + * Display hardware is capable of blt operations. + */ +#define DDCAPS_BLT 0x00000040l + +/* + * Display hardware is capable of asynchronous blt operations. + */ +#define DDCAPS_BLTQUEUE 0x00000080l + +/* + * Display hardware is capable of color space conversions during the blt operation. + */ +#define DDCAPS_BLTFOURCC 0x00000100l + +/* + * Display hardware is capable of stretching during blt operations. + */ +#define DDCAPS_BLTSTRETCH 0x00000200l + +/* + * Display hardware is shared with GDI. + */ +#define DDCAPS_GDI 0x00000400l + +/* + * Display hardware can overlay. + */ +#define DDCAPS_OVERLAY 0x00000800l + +/* + * Set if display hardware supports overlays but can not clip them. + */ +#define DDCAPS_OVERLAYCANTCLIP 0x00001000l + +/* + * Indicates that overlay hardware is capable of color space conversions during + * the overlay operation. + */ +#define DDCAPS_OVERLAYFOURCC 0x00002000l + +/* + * Indicates that stretching can be done by the overlay hardware. + */ +#define DDCAPS_OVERLAYSTRETCH 0x00004000l + +/* + * Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces + * other than the primary surface. + */ +#define DDCAPS_PALETTE 0x00008000l + +/* + * Indicates that palette changes can be syncd with the veritcal refresh. + */ +#define DDCAPS_PALETTEVSYNC 0x00010000l + +/* + * Display hardware can return the current scan line. + */ +#define DDCAPS_READSCANLINE 0x00020000l + +/* + * Display hardware has stereo vision capabilities. DDSCAPS_PRIMARYSURFACELEFT + * can be created. + */ +#define DDCAPS_STEREOVIEW 0x00040000l + +/* + * Display hardware is capable of generating a vertical blank interrupt. + */ +#define DDCAPS_VBI 0x00080000l + +/* + * Supports the use of z buffers with blt operations. + */ +#define DDCAPS_ZBLTS 0x00100000l + +/* + * Supports Z Ordering of overlays. + */ +#define DDCAPS_ZOVERLAYS 0x00200000l + +/* + * Supports color key + */ +#define DDCAPS_COLORKEY 0x00400000l + +/* + * Supports alpha surfaces + */ +#define DDCAPS_ALPHA 0x00800000l + +/* + * colorkey is hardware assisted(DDCAPS_COLORKEY will also be set) + */ +#define DDCAPS_COLORKEYHWASSIST 0x01000000l + +/* + * no hardware support at all + */ +#define DDCAPS_NOHARDWARE 0x02000000l + +/* + * Display hardware is capable of color fill with bltter + */ +#define DDCAPS_BLTCOLORFILL 0x04000000l + +/* + * Display hardware is bank switched, and potentially very slow at + * random access to VRAM. + */ +#define DDCAPS_BANKSWITCHED 0x08000000l + +/* + * Display hardware is capable of depth filling Z-buffers with bltter + */ +#define DDCAPS_BLTDEPTHFILL 0x10000000l + +/* + * Display hardware is capable of clipping while bltting. + */ +#define DDCAPS_CANCLIP 0x20000000l + +/* + * Display hardware is capable of clipping while stretch bltting. + */ +#define DDCAPS_CANCLIPSTRETCHED 0x40000000l + +/* + * Display hardware is capable of bltting to or from system memory + */ +#define DDCAPS_CANBLTSYSMEM 0x80000000l + + + /**************************************************************************** + * + * MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2) + * + ****************************************************************************/ + +/* + * Display hardware is certified + */ +#define DDCAPS2_CERTIFIED 0x00000001l + +/* + * Driver cannot interleave 2D operations (lock and blt) to surfaces with + * Direct3D rendering operations between calls to BeginScene() and EndScene() + */ +#define DDCAPS2_NO2DDURING3DSCENE 0x00000002l + +/* + * Display hardware contains a video port + */ +#define DDCAPS2_VIDEOPORT 0x00000004l + +/* + * The overlay can be automatically flipped according to the video port + * VSYNCs, providing automatic doubled buffered display of video port + * data using an overlay + */ +#define DDCAPS2_AUTOFLIPOVERLAY 0x00000008l + +/* + * Overlay can display each field of interlaced data individually while + * it is interleaved in memory without causing jittery artifacts. + */ +#define DDCAPS2_CANBOBINTERLEAVED 0x00000010l + +/* + * Overlay can display each field of interlaced data individually while + * it is not interleaved in memory without causing jittery artifacts. + */ +#define DDCAPS2_CANBOBNONINTERLEAVED 0x00000020l + +/* + * The overlay surface contains color controls (brightness, sharpness, etc.) + */ +#define DDCAPS2_COLORCONTROLOVERLAY 0x00000040l + +/* + * The primary surface contains color controls (gamma, etc.) + */ +#define DDCAPS2_COLORCONTROLPRIMARY 0x00000080l + +/* + * RGBZ -> RGB supported for 16:16 RGB:Z + */ +#define DDCAPS2_CANDROPZ16BIT 0x00000100l + +/* + * Driver supports non-local video memory. + */ +#define DDCAPS2_NONLOCALVIDMEM 0x00000200l + +/* + * Dirver supports non-local video memory but has different capabilities for + * non-local video memory surfaces. If this bit is set then so must + * DDCAPS2_NONLOCALVIDMEM. + */ +#define DDCAPS2_NONLOCALVIDMEMCAPS 0x00000400l + +/* + * Driver neither requires nor prefers surfaces to be pagelocked when performing + * blts involving system memory surfaces + */ +#define DDCAPS2_NOPAGELOCKREQUIRED 0x00000800l + +/* + * Driver can create surfaces which are wider than the primary surface + */ +#define DDCAPS2_WIDESURFACES 0x00001000l + +/* + * Driver supports bob without using a video port by handling the + * DDFLIP_ODD and DDFLIP_EVEN flags specified in Flip. + */ +#define DDCAPS2_CANFLIPODDEVEN 0x00002000l + +/* + * Driver supports bob using hardware + */ +#define DDCAPS2_CANBOBHARDWARE 0x00004000l + +/* + * Driver supports bltting any FOURCC surface to another surface of the same FOURCC + */ +#define DDCAPS2_COPYFOURCC 0x00008000l + + +/* + * Driver supports loadable gamma ramps for the primary surface + */ +#define DDCAPS2_PRIMARYGAMMA 0x00020000l + +/* + * Driver can render in windowed mode. + */ +#define DDCAPS2_CANRENDERWINDOWED 0x00080000l + +/* + * A calibrator is available to adjust the gamma ramp according to the + * physical display properties so that the result will be identical on + * all calibrated systems. + */ +#define DDCAPS2_CANCALIBRATEGAMMA 0x00100000l + +/* + * Indicates that the driver will respond to DDFLIP_INTERVALn flags + */ +#define DDCAPS2_FLIPINTERVAL 0x00200000l + +/* + * Indicates that the driver will respond to DDFLIP_NOVSYNC + */ +#define DDCAPS2_FLIPNOVSYNC 0x00400000l + + +/**************************************************************************** + * + * DIRECTDRAW FX ALPHA CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Supports alpha blending around the edge of a source color keyed surface. + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHAEDGEBLEND 0x00000001l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value becomes + * more opaque as the alpha value increases. (0 is transparent.) + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHAPIXELS 0x00000002l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value + * becomes more transparent as the alpha value increases. (0 is opaque.) + * This flag can only be set if DDCAPS_ALPHA is set. + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHAPIXELSNEG 0x00000004l + +/* + * Supports alpha only surfaces. The bit depth of an alpha only surface can be + * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases. + * (0 is transparent.) + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHASURFACES 0x00000008l + +/* + * The depth of the alpha channel data can range can be 1,2,4, or 8. + * The NEG suffix indicates that this alpha channel becomes more transparent + * as the alpha value increases. (0 is opaque.) This flag can only be set if + * DDCAPS_ALPHA is set. + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHASURFACESNEG 0x00000010l + +/* + * Supports alpha blending around the edge of a source color keyed surface. + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND 0x00000020l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value becomes + * more opaque as the alpha value increases. (0 is transparent.) + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHAPIXELS 0x00000040l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value + * becomes more transparent as the alpha value increases. (0 is opaque.) + * This flag can only be set if DDCAPS_ALPHA is set. + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG 0x00000080l + +/* + * Supports alpha only surfaces. The bit depth of an alpha only surface can be + * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases. + * (0 is transparent.) + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHASURFACES 0x00000100l + +/* + * The depth of the alpha channel data can range can be 1,2,4, or 8. + * The NEG suffix indicates that this alpha channel becomes more transparent + * as the alpha value increases. (0 is opaque.) This flag can only be set if + * DDCAPS_ALPHA is set. + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHASURFACESNEG 0x00000200l + +#if DIRECTDRAW_VERSION < 0x0600 +#endif //DIRECTDRAW_VERSION + + + + +/**************************************************************************** + * + * DIRECTDRAW FX CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Uses arithmetic operations to stretch and shrink surfaces during blt + * rather than pixel doubling techniques. Along the Y axis. + */ +#define DDFXCAPS_BLTARITHSTRETCHY 0x00000020l + +/* + * Uses arithmetic operations to stretch during blt + * rather than pixel doubling techniques. Along the Y axis. Only + * works for x1, x2, etc. + */ +#define DDFXCAPS_BLTARITHSTRETCHYN 0x00000010l + +/* + * Supports mirroring left to right in blt. + */ +#define DDFXCAPS_BLTMIRRORLEFTRIGHT 0x00000040l + +/* + * Supports mirroring top to bottom in blt. + */ +#define DDFXCAPS_BLTMIRRORUPDOWN 0x00000080l + +/* + * Supports arbitrary rotation for blts. + */ +#define DDFXCAPS_BLTROTATION 0x00000100l + +/* + * Supports 90 degree rotations for blts. + */ +#define DDFXCAPS_BLTROTATION90 0x00000200l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKX 0x00000400l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKXN 0x00000800l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * y axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKY 0x00001000l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the y axis (vertical direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKYN 0x00002000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHX 0x00004000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHXN 0x00008000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * y axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHY 0x00010000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the y axis (vertical direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHYN 0x00020000l + +/* + * Uses arithmetic operations to stretch and shrink surfaces during + * overlay rather than pixel doubling techniques. Along the Y axis + * for overlays. + */ +#define DDFXCAPS_OVERLAYARITHSTRETCHY 0x00040000l + +/* + * Uses arithmetic operations to stretch surfaces during + * overlay rather than pixel doubling techniques. Along the Y axis + * for overlays. Only works for x1, x2, etc. + */ +#define DDFXCAPS_OVERLAYARITHSTRETCHYN 0x00000008l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKX 0x00080000l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKXN 0x00100000l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * y axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKY 0x00200000l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the y axis (vertical direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKYN 0x00400000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHX 0x00800000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHXN 0x01000000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * y axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHY 0x02000000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the y axis (vertical direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHYN 0x04000000l + +/* + * DirectDraw supports mirroring of overlays across the vertical axis + */ +#define DDFXCAPS_OVERLAYMIRRORLEFTRIGHT 0x08000000l + +/* + * DirectDraw supports mirroring of overlays across the horizontal axis + */ +#define DDFXCAPS_OVERLAYMIRRORUPDOWN 0x10000000l + +/* + * Driver can do alpha blending for blits. + */ +#define DDFXCAPS_BLTALPHA 0x00000001l + +/* + * Driver can do geometric transformations (or warps) for blits. + */ +#define DDFXCAPS_BLTTRANSFORM 0x00000002l + +/* + * Driver can do surface-reconstruction filtering for warped blits. + */ +#define DDFXCAPS_BLTFILTER DDFXCAPS_BLTARITHSTRETCHY + +/* + * Driver can do alpha blending for overlays. + */ +#define DDFXCAPS_OVERLAYALPHA 0x00000004l + +/* + * Driver can do geometric transformations (or warps) for overlays. + */ +#define DDFXCAPS_OVERLAYTRANSFORM 0x20000000l + +/* + * Driver can do surface-reconstruction filtering for warped overlays. + */ +#define DDFXCAPS_OVERLAYFILTER DDFXCAPS_OVERLAYARITHSTRETCHY + + +/**************************************************************************** + * + * DIRECTDRAW STEREO VIEW CAPABILITIES + * + ****************************************************************************/ + +/* + * The stereo view is accomplished via enigma encoding. + */ +#define DDSVCAPS_ENIGMA 0x00000001l + +/* + * The stereo view is accomplished via high frequency flickering. + */ +#define DDSVCAPS_FLICKER 0x00000002l + +/* + * The stereo view is accomplished via red and blue filters applied + * to the left and right eyes. All images must adapt their colorspaces + * for this process. + */ +#define DDSVCAPS_REDBLUE 0x00000004l + +/* + * The stereo view is accomplished with split screen technology. + */ +#define DDSVCAPS_SPLIT 0x00000008l + +/**************************************************************************** + * + * DIRECTDRAWPALETTE CAPABILITIES + * + ****************************************************************************/ + +/* + * Index is 4 bits. There are sixteen color entries in the palette table. + */ +#define DDPCAPS_4BIT 0x00000001l + +/* + * Index is onto a 8 bit color index. This field is only valid with the + * DDPCAPS_1BIT, DDPCAPS_2BIT or DDPCAPS_4BIT capability and the target + * surface is in 8bpp. Each color entry is one byte long and is an index + * into destination surface's 8bpp palette. + */ +#define DDPCAPS_8BITENTRIES 0x00000002l + +/* + * Index is 8 bits. There are 256 color entries in the palette table. + */ +#define DDPCAPS_8BIT 0x00000004l + +/* + * Indicates that this DIRECTDRAWPALETTE should use the palette color array + * passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE + * object. + */ +#define DDPCAPS_INITIALIZE 0x00000008l + +/* + * This palette is the one attached to the primary surface. Changing this + * table has immediate effect on the display unless DDPSETPAL_VSYNC is specified + * and supported. + */ +#define DDPCAPS_PRIMARYSURFACE 0x00000010l + +/* + * This palette is the one attached to the primary surface left. Changing + * this table has immediate effect on the display for the left eye unless + * DDPSETPAL_VSYNC is specified and supported. + */ +#define DDPCAPS_PRIMARYSURFACELEFT 0x00000020l + +/* + * This palette can have all 256 entries defined + */ +#define DDPCAPS_ALLOW256 0x00000040l + +/* + * This palette can have modifications to it synced with the monitors + * refresh rate. + */ +#define DDPCAPS_VSYNC 0x00000080l + +/* + * Index is 1 bit. There are two color entries in the palette table. + */ +#define DDPCAPS_1BIT 0x00000100l + +/* + * Index is 2 bit. There are four color entries in the palette table. + */ +#define DDPCAPS_2BIT 0x00000200l + +/* + * The peFlags member of PALETTEENTRY denotes an 8 bit alpha value + */ +#define DDPCAPS_ALPHA 0x00000400l + + +/**************************************************************************** + * + * DIRECTDRAWPALETTE SETENTRY CONSTANTS + * + ****************************************************************************/ + + +/**************************************************************************** + * + * DIRECTDRAWPALETTE GETENTRY CONSTANTS + * + ****************************************************************************/ + +/* 0 is the only legal value */ + +/**************************************************************************** + * + * DIRECTDRAWSURFACE SETPRIVATEDATA CONSTANTS + * + ****************************************************************************/ + +/* + * The passed pointer is an IUnknown ptr. The cbData argument to SetPrivateData + * must be set to sizeof(IUnknown*). DirectDraw will call AddRef through this + * pointer and Release when the private data is destroyed. This includes when + * the surface or palette is destroyed before such priovate data is destroyed. + */ +#define DDSPD_IUNKNOWNPOINTER 0x00000001L + +/* + * Private data is only valid for the current state of the object, + * as determined by the uniqueness value. + */ +#define DDSPD_VOLATILE 0x00000002L + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE SETPALETTE CONSTANTS + * + ****************************************************************************/ + + +/**************************************************************************** + * + * DIRECTDRAW BITDEPTH CONSTANTS + * + * NOTE: These are only used to indicate supported bit depths. These + * are flags only, they are not to be used as an actual bit depth. The + * absolute numbers 1, 2, 4, 8, 16, 24 and 32 are used to indicate actual + * bit depths in a surface or for changing the display mode. + * + ****************************************************************************/ + +/* + * 1 bit per pixel. + */ +#define DDBD_1 0x00004000l + +/* + * 2 bits per pixel. + */ +#define DDBD_2 0x00002000l + +/* + * 4 bits per pixel. + */ +#define DDBD_4 0x00001000l + +/* + * 8 bits per pixel. + */ +#define DDBD_8 0x00000800l + +/* + * 16 bits per pixel. + */ +#define DDBD_16 0x00000400l + +/* + * 24 bits per pixel. + */ +#define DDBD_24 0X00000200l + +/* + * 32 bits per pixel. + */ +#define DDBD_32 0x00000100l + +/**************************************************************************** + * + * DIRECTDRAWSURFACE SET/GET COLOR KEY FLAGS + * + ****************************************************************************/ + +/* + * Set if the structure contains a color space. Not set if the structure + * contains a single color key. + */ +#define DDCKEY_COLORSPACE 0x00000001l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a destination color key for blt operations. + */ +#define DDCKEY_DESTBLT 0x00000002l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a destination color key for overlay operations. + */ +#define DDCKEY_DESTOVERLAY 0x00000004l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a source color key for blt operations. + */ +#define DDCKEY_SRCBLT 0x00000008l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a source color key for overlay operations. + */ +#define DDCKEY_SRCOVERLAY 0x00000010l + + +/**************************************************************************** + * + * DIRECTDRAW COLOR KEY CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Supports transparent blting using a color key to identify the replaceable + * bits of the destination surface for RGB colors. + */ +#define DDCKEYCAPS_DESTBLT 0x00000001l + +/* + * Supports transparent blting using a color space to identify the replaceable + * bits of the destination surface for RGB colors. + */ +#define DDCKEYCAPS_DESTBLTCLRSPACE 0x00000002l + +/* + * Supports transparent blting using a color space to identify the replaceable + * bits of the destination surface for YUV colors. + */ +#define DDCKEYCAPS_DESTBLTCLRSPACEYUV 0x00000004l + +/* + * Supports transparent blting using a color key to identify the replaceable + * bits of the destination surface for YUV colors. + */ +#define DDCKEYCAPS_DESTBLTYUV 0x00000008l + +/* + * Supports overlaying using colorkeying of the replaceable bits of the surface + * being overlayed for RGB colors. + */ +#define DDCKEYCAPS_DESTOVERLAY 0x00000010l + +/* + * Supports a color space as the color key for the destination for RGB colors. + */ +#define DDCKEYCAPS_DESTOVERLAYCLRSPACE 0x00000020l + +/* + * Supports a color space as the color key for the destination for YUV colors. + */ +#define DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV 0x00000040l + +/* + * Supports only one active destination color key value for visible overlay + * surfaces. + */ +#define DDCKEYCAPS_DESTOVERLAYONEACTIVE 0x00000080l + +/* + * Supports overlaying using colorkeying of the replaceable bits of the + * surface being overlayed for YUV colors. + */ +#define DDCKEYCAPS_DESTOVERLAYYUV 0x00000100l + +/* + * Supports transparent blting using the color key for the source with + * this surface for RGB colors. + */ +#define DDCKEYCAPS_SRCBLT 0x00000200l + +/* + * Supports transparent blting using a color space for the source with + * this surface for RGB colors. + */ +#define DDCKEYCAPS_SRCBLTCLRSPACE 0x00000400l + +/* + * Supports transparent blting using a color space for the source with + * this surface for YUV colors. + */ +#define DDCKEYCAPS_SRCBLTCLRSPACEYUV 0x00000800l + +/* + * Supports transparent blting using the color key for the source with + * this surface for YUV colors. + */ +#define DDCKEYCAPS_SRCBLTYUV 0x00001000l + +/* + * Supports overlays using the color key for the source with this + * overlay surface for RGB colors. + */ +#define DDCKEYCAPS_SRCOVERLAY 0x00002000l + +/* + * Supports overlays using a color space as the source color key for + * the overlay surface for RGB colors. + */ +#define DDCKEYCAPS_SRCOVERLAYCLRSPACE 0x00004000l + +/* + * Supports overlays using a color space as the source color key for + * the overlay surface for YUV colors. + */ +#define DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV 0x00008000l + +/* + * Supports only one active source color key value for visible + * overlay surfaces. + */ +#define DDCKEYCAPS_SRCOVERLAYONEACTIVE 0x00010000l + +/* + * Supports overlays using the color key for the source with this + * overlay surface for YUV colors. + */ +#define DDCKEYCAPS_SRCOVERLAYYUV 0x00020000l + +/* + * there are no bandwidth trade-offs for using colorkey with an overlay + */ +#define DDCKEYCAPS_NOCOSTOVERLAY 0x00040000l + + +/**************************************************************************** + * + * DIRECTDRAW PIXELFORMAT FLAGS + * + ****************************************************************************/ + +/* + * The surface has alpha channel information in the pixel format. + */ +#define DDPF_ALPHAPIXELS 0x00000001l + +/* + * The pixel format contains alpha only information + */ +#define DDPF_ALPHA 0x00000002l + +/* + * The FourCC code is valid. + */ +#define DDPF_FOURCC 0x00000004l + +/* + * The surface is 4-bit color indexed. + */ +#define DDPF_PALETTEINDEXED4 0x00000008l + +/* + * The surface is indexed into a palette which stores indices + * into the destination surface's 8-bit palette. + */ +#define DDPF_PALETTEINDEXEDTO8 0x00000010l + +/* + * The surface is 8-bit color indexed. + */ +#define DDPF_PALETTEINDEXED8 0x00000020l + +/* + * The RGB data in the pixel format structure is valid. + */ +#define DDPF_RGB 0x00000040l + +/* + * The surface will accept pixel data in the format specified + * and compress it during the write. + */ +#define DDPF_COMPRESSED 0x00000080l + +/* + * The surface will accept RGB data and translate it during + * the write to YUV data. The format of the data to be written + * will be contained in the pixel format structure. The DDPF_RGB + * flag will be set. + */ +#define DDPF_RGBTOYUV 0x00000100l + +/* + * pixel format is YUV - YUV data in pixel format struct is valid + */ +#define DDPF_YUV 0x00000200l + +/* + * pixel format is a z buffer only surface + */ +#define DDPF_ZBUFFER 0x00000400l + +/* + * The surface is 1-bit color indexed. + */ +#define DDPF_PALETTEINDEXED1 0x00000800l + +/* + * The surface is 2-bit color indexed. + */ +#define DDPF_PALETTEINDEXED2 0x00001000l + +/* + * The surface contains Z information in the pixels + */ +#define DDPF_ZPIXELS 0x00002000l + +/* + * The surface contains stencil information along with Z + */ +#define DDPF_STENCILBUFFER 0x00004000l + +/* + * Premultiplied alpha format -- the color components have been + * premultiplied by the alpha component. + */ +#define DDPF_ALPHAPREMULT 0x00008000l + + +/* + * Luminance data in the pixel format is valid. + * Use this flag for luminance-only or luminance+alpha surfaces, + * the bit depth is then ddpf.dwLuminanceBitCount. + */ +#define DDPF_LUMINANCE 0x00020000l + +/* + * Luminance data in the pixel format is valid. + * Use this flag when hanging luminance off bumpmap surfaces, + * the bit mask for the luminance portion of the pixel is then + * ddpf.dwBumpLuminanceBitMask + */ +#define DDPF_BUMPLUMINANCE 0x00040000l + +/* + * Bump map dUdV data in the pixel format is valid. + */ +#define DDPF_BUMPDUDV 0x00080000l + +/*=========================================================================== + * + * + * DIRECTDRAW CALLBACK FLAGS + * + * + *==========================================================================*/ + +/**************************************************************************** + * + * DIRECTDRAW ENUMSURFACES FLAGS + * + ****************************************************************************/ + +/* + * Enumerate all of the surfaces that meet the search criterion. + */ +#define DDENUMSURFACES_ALL 0x00000001l + +/* + * A search hit is a surface that matches the surface description. + */ +#define DDENUMSURFACES_MATCH 0x00000002l + +/* + * A search hit is a surface that does not match the surface description. + */ +#define DDENUMSURFACES_NOMATCH 0x00000004l + +/* + * Enumerate the first surface that can be created which meets the search criterion. + */ +#define DDENUMSURFACES_CANBECREATED 0x00000008l + +/* + * Enumerate the surfaces that already exist that meet the search criterion. + */ +#define DDENUMSURFACES_DOESEXIST 0x00000010l + + +/**************************************************************************** + * + * DIRECTDRAW SETDISPLAYMODE FLAGS + * + ****************************************************************************/ + +/* + * The desired mode is a standard VGA mode + */ +#define DDSDM_STANDARDVGAMODE 0x00000001l + + + +/**************************************************************************** + * + * DIRECTDRAW ENUMDISPLAYMODES FLAGS + * + ****************************************************************************/ + +/* + * Enumerate Modes with different refresh rates. EnumDisplayModes guarantees + * that a particular mode will be enumerated only once. This flag specifies whether + * the refresh rate is taken into account when determining if a mode is unique. + */ +#define DDEDM_REFRESHRATES 0x00000001l + +/* + * Enumerate VGA modes. Specify this flag if you wish to enumerate supported VGA + * modes such as mode 0x13 in addition to the usual ModeX modes (which are always + * enumerated if the application has previously called SetCooperativeLevel with the + * DDSCL_ALLOWMODEX flag set). + */ +#define DDEDM_STANDARDVGAMODES 0x00000002L + + +/**************************************************************************** + * + * DIRECTDRAW SETCOOPERATIVELEVEL FLAGS + * + ****************************************************************************/ + +/* + * Exclusive mode owner will be responsible for the entire primary surface. + * GDI can be ignored. used with DD + */ +#define DDSCL_FULLSCREEN 0x00000001l + +/* + * allow CTRL_ALT_DEL to work while in fullscreen exclusive mode + */ +#define DDSCL_ALLOWREBOOT 0x00000002l + +/* + * prevents DDRAW from modifying the application window. + * prevents DDRAW from minimize/restore the application window on activation. + */ +#define DDSCL_NOWINDOWCHANGES 0x00000004l + +/* + * app wants to work as a regular Windows application + */ +#define DDSCL_NORMAL 0x00000008l + +/* + * app wants exclusive access + */ +#define DDSCL_EXCLUSIVE 0x00000010l + + +/* + * app can deal with non-windows display modes + */ +#define DDSCL_ALLOWMODEX 0x00000040l + +/* + * this window will receive the focus messages + */ +#define DDSCL_SETFOCUSWINDOW 0x00000080l + +/* + * this window is associated with the DDRAW object and will + * cover the screen in fullscreen mode + */ +#define DDSCL_SETDEVICEWINDOW 0x00000100l + +/* + * app wants DDRAW to create a window to be associated with the + * DDRAW object + */ +#define DDSCL_CREATEDEVICEWINDOW 0x00000200l + +/* + * App explicitly asks DDRAW/D3D to be multithread safe. This makes D3D + * take the global crtisec more frequently. + */ +#define DDSCL_MULTITHREADED 0x00000400l + +/* + * App hints that it would like to keep the FPU set up for optimal Direct3D + * performance (single precision and exceptions disabled) so Direct3D + * does not need to explicitly set the FPU each time + */ +#define DDSCL_FPUSETUP 0x00000800l + + +/**************************************************************************** + * + * DIRECTDRAW BLT FLAGS + * + ****************************************************************************/ + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the destination surface as the alpha channel for this blt. + */ +#define DDBLT_ALPHADEST 0x00000001l + +/* + * Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel + * for the destination surface for this blt. + */ +#define DDBLT_ALPHADESTCONSTOVERRIDE 0x00000002l + +/* + * The NEG suffix indicates that the destination surface becomes more + * transparent as the alpha value increases. (0 is opaque) + */ +#define DDBLT_ALPHADESTNEG 0x00000004l + +/* + * Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha + * channel for the destination for this blt. + */ +#define DDBLT_ALPHADESTSURFACEOVERRIDE 0x00000008l + +/* + * Use the dwAlphaEdgeBlend field in the DDBLTFX structure as the alpha channel + * for the edges of the image that border the color key colors. + */ +#define DDBLT_ALPHAEDGEBLEND 0x00000010l + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the source surface as the alpha channel for this blt. + */ +#define DDBLT_ALPHASRC 0x00000020l + +/* + * Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel + * for the source for this blt. + */ +#define DDBLT_ALPHASRCCONSTOVERRIDE 0x00000040l + +/* + * The NEG suffix indicates that the source surface becomes more transparent + * as the alpha value increases. (0 is opaque) + */ +#define DDBLT_ALPHASRCNEG 0x00000080l + +/* + * Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel + * for the source for this blt. + */ +#define DDBLT_ALPHASRCSURFACEOVERRIDE 0x00000100l + +/* + * Do this blt asynchronously through the FIFO in the order received. If + * there is no room in the hardware FIFO fail the call. + */ +#define DDBLT_ASYNC 0x00000200l + +/* + * Uses the dwFillColor field in the DDBLTFX structure as the RGB color + * to fill the destination rectangle on the destination surface with. + */ +#define DDBLT_COLORFILL 0x00000400l + +/* + * Uses the dwDDFX field in the DDBLTFX structure to specify the effects + * to use for the blt. + */ +#define DDBLT_DDFX 0x00000800l + +/* + * Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS + * that are not part of the Win32 API. + */ +#define DDBLT_DDROPS 0x00001000l + +/* + * Use the color key associated with the destination surface. + */ +#define DDBLT_KEYDEST 0x00002000l + +/* + * Use the dckDestColorkey field in the DDBLTFX structure as the color key + * for the destination surface. + */ +#define DDBLT_KEYDESTOVERRIDE 0x00004000l + +/* + * Use the color key associated with the source surface. + */ +#define DDBLT_KEYSRC 0x00008000l + +/* + * Use the dckSrcColorkey field in the DDBLTFX structure as the color key + * for the source surface. + */ +#define DDBLT_KEYSRCOVERRIDE 0x00010000l + +/* + * Use the dwROP field in the DDBLTFX structure for the raster operation + * for this blt. These ROPs are the same as the ones defined in the Win32 API. + */ +#define DDBLT_ROP 0x00020000l + +/* + * Use the dwRotationAngle field in the DDBLTFX structure as the angle + * (specified in 1/100th of a degree) to rotate the surface. + */ +#define DDBLT_ROTATIONANGLE 0x00040000l + +/* + * Z-buffered blt using the z-buffers attached to the source and destination + * surfaces and the dwZBufferOpCode field in the DDBLTFX structure as the + * z-buffer opcode. + */ +#define DDBLT_ZBUFFER 0x00080000l + +/* + * Z-buffered blt using the dwConstDest Zfield and the dwZBufferOpCode field + * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively + * for the destination. + */ +#define DDBLT_ZBUFFERDESTCONSTOVERRIDE 0x00100000l + +/* + * Z-buffered blt using the lpDDSDestZBuffer field and the dwZBufferOpCode + * field in the DDBLTFX structure as the z-buffer and z-buffer opcode + * respectively for the destination. + */ +#define DDBLT_ZBUFFERDESTOVERRIDE 0x00200000l + +/* + * Z-buffered blt using the dwConstSrcZ field and the dwZBufferOpCode field + * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively + * for the source. + */ +#define DDBLT_ZBUFFERSRCCONSTOVERRIDE 0x00400000l + +/* + * Z-buffered blt using the lpDDSSrcZBuffer field and the dwZBufferOpCode + * field in the DDBLTFX structure as the z-buffer and z-buffer opcode + * respectively for the source. + */ +#define DDBLT_ZBUFFERSRCOVERRIDE 0x00800000l + +/* + * wait until the device is ready to handle the blt + * this will cause blt to not return DDERR_WASSTILLDRAWING + */ +#define DDBLT_WAIT 0x01000000l + +/* + * Uses the dwFillDepth field in the DDBLTFX structure as the depth value + * to fill the destination rectangle on the destination Z-buffer surface + * with. + */ +#define DDBLT_DEPTHFILL 0x02000000l + + +/**************************************************************************** + * + * BLTFAST FLAGS + * + ****************************************************************************/ + +#define DDBLTFAST_NOCOLORKEY 0x00000000 +#define DDBLTFAST_SRCCOLORKEY 0x00000001 +#define DDBLTFAST_DESTCOLORKEY 0x00000002 +#define DDBLTFAST_WAIT 0x00000010 + + + + +/**************************************************************************** + * + * FLIP FLAGS + * + ****************************************************************************/ + +#define DDFLIP_WAIT 0x00000001L + +/* + * Indicates that the target surface contains the even field of video data. + * This flag is only valid with an overlay surface. + */ +#define DDFLIP_EVEN 0x00000002L + +/* + * Indicates that the target surface contains the odd field of video data. + * This flag is only valid with an overlay surface. + */ +#define DDFLIP_ODD 0x00000004L + +/* + * Causes DirectDraw to perform the physical flip immediately and return + * to the application. Typically, what was the front buffer but is now the back + * buffer will still be visible (depending on timing) until the next vertical + * retrace. Subsequent operations involving the two flipped surfaces will + * not check to see if the physical flip has finished (i.e. will not return + * DDERR_WASSTILLDRAWING for that reason (but may for other reasons)). + * This allows an application to perform Flips at a higher frequency than the + * monitor refresh rate, but may introduce visible artifacts. + * Only effective if DDCAPS2_FLIPNOVSYNC is set. If that bit is not set, + * DDFLIP_NOVSYNC has no effect. + */ +#define DDFLIP_NOVSYNC 0x00000008L + + +/* + * Flip Interval Flags. These flags indicate how many vertical retraces to wait between + * each flip. The default is one. DirectDraw will return DDERR_WASSTILLDRAWING for each + * surface involved in the flip until the specified number of vertical retraces has + * ocurred. Only effective if DDCAPS2_FLIPINTERVAL is set. If that bit is not set, + * DDFLIP_INTERVALn has no effect. + */ + +/* + * DirectDraw will flip on every other vertical sync + */ +#define DDFLIP_INTERVAL2 0x02000000L + + +/* + * DirectDraw will flip on every third vertical sync + */ +#define DDFLIP_INTERVAL3 0x03000000L + + +/* + * DirectDraw will flip on every fourth vertical sync + */ +#define DDFLIP_INTERVAL4 0x04000000L + + + +/**************************************************************************** + * + * DIRECTDRAW SURFACE OVERLAY FLAGS + * + ****************************************************************************/ + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the destination surface as the alpha channel for the + * destination overlay. + */ +#define DDOVER_ALPHADEST 0x00000001l + +/* + * Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the + * destination alpha channel for this overlay. + */ +#define DDOVER_ALPHADESTCONSTOVERRIDE 0x00000002l + +/* + * The NEG suffix indicates that the destination surface becomes more + * transparent as the alpha value increases. + */ +#define DDOVER_ALPHADESTNEG 0x00000004l + +/* + * Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha + * channel destination for this overlay. + */ +#define DDOVER_ALPHADESTSURFACEOVERRIDE 0x00000008l + +/* + * Use the dwAlphaEdgeBlend field in the DDOVERLAYFX structure as the alpha + * channel for the edges of the image that border the color key colors. + */ +#define DDOVER_ALPHAEDGEBLEND 0x00000010l + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the source surface as the source alpha channel for this overlay. + */ +#define DDOVER_ALPHASRC 0x00000020l + +/* + * Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source + * alpha channel for this overlay. + */ +#define DDOVER_ALPHASRCCONSTOVERRIDE 0x00000040l + +/* + * The NEG suffix indicates that the source surface becomes more transparent + * as the alpha value increases. + */ +#define DDOVER_ALPHASRCNEG 0x00000080l + +/* + * Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel + * source for this overlay. + */ +#define DDOVER_ALPHASRCSURFACEOVERRIDE 0x00000100l + +/* + * Turn this overlay off. + */ +#define DDOVER_HIDE 0x00000200l + +/* + * Use the color key associated with the destination surface. + */ +#define DDOVER_KEYDEST 0x00000400l + +/* + * Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key + * for the destination surface + */ +#define DDOVER_KEYDESTOVERRIDE 0x00000800l + +/* + * Use the color key associated with the source surface. + */ +#define DDOVER_KEYSRC 0x00001000l + +/* + * Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key + * for the source surface. + */ +#define DDOVER_KEYSRCOVERRIDE 0x00002000l + +/* + * Turn this overlay on. + */ +#define DDOVER_SHOW 0x00004000l + +/* + * Add a dirty rect to an emulated overlayed surface. + */ +#define DDOVER_ADDDIRTYRECT 0x00008000l + +/* + * Redraw all dirty rects on an emulated overlayed surface. + */ +#define DDOVER_REFRESHDIRTYRECTS 0x00010000l + +/* + * Redraw the entire surface on an emulated overlayed surface. + */ +#define DDOVER_REFRESHALL 0x00020000l + + +/* + * Use the overlay FX flags to define special overlay FX + */ +#define DDOVER_DDFX 0x00080000l + +/* + * Autoflip the overlay when ever the video port autoflips + */ +#define DDOVER_AUTOFLIP 0x00100000l + +/* + * Display each field of video port data individually without + * causing any jittery artifacts + */ +#define DDOVER_BOB 0x00200000l + +/* + * Indicates that bob/weave decisions should not be overridden by other + * interfaces. + */ +#define DDOVER_OVERRIDEBOBWEAVE 0x00400000l + +/* + * Indicates that the surface memory is composed of interleaved fields. + */ +#define DDOVER_INTERLEAVED 0x00800000l + +/* + * Indicates that bob will be performed using hardware rather than + * software or emulated. + */ +#define DDOVER_BOBHARDWARE 0x01000000l + + + + + + + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE LOCK FLAGS + * + ****************************************************************************/ + +/* + * The default. Set to indicate that Lock should return a valid memory pointer + * to the top of the specified rectangle. If no rectangle is specified then a + * pointer to the top of the surface is returned. + */ +#define DDLOCK_SURFACEMEMORYPTR 0x00000000L // default + +/* + * Set to indicate that Lock should wait until it can obtain a valid memory + * pointer before returning. If this bit is set, Lock will never return + * DDERR_WASSTILLDRAWING. + */ +#define DDLOCK_WAIT 0x00000001L + +/* + * Set if an event handle is being passed to Lock. Lock will trigger the event + * when it can return the surface memory pointer requested. + */ +#define DDLOCK_EVENT 0x00000002L + +/* + * Indicates that the surface being locked will only be read from. + */ +#define DDLOCK_READONLY 0x00000010L + +/* + * Indicates that the surface being locked will only be written to + */ +#define DDLOCK_WRITEONLY 0x00000020L + + +/* + * Indicates that a system wide lock should not be taken when this surface + * is locked. This has several advantages (cursor responsiveness, ability + * to call more Windows functions, easier debugging) when locking video + * memory surfaces. However, an application specifying this flag must + * comply with a number of conditions documented in the help file. + * Furthermore, this flag cannot be specified when locking the primary. + */ +#define DDLOCK_NOSYSLOCK 0x00000800L + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE PAGELOCK FLAGS + * + ****************************************************************************/ + +/* + * No flags defined at present + */ + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE PAGEUNLOCK FLAGS + * + ****************************************************************************/ + +/* + * No flags defined at present + */ + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE BLT FX FLAGS + * + ****************************************************************************/ + +/* + * If stretching, use arithmetic stretching along the Y axis for this blt. + */ +#define DDBLTFX_ARITHSTRETCHY 0x00000001l + +/* + * Do this blt mirroring the surface left to right. Spin the + * surface around its y-axis. + */ +#define DDBLTFX_MIRRORLEFTRIGHT 0x00000002l + +/* + * Do this blt mirroring the surface up and down. Spin the surface + * around its x-axis. + */ +#define DDBLTFX_MIRRORUPDOWN 0x00000004l + +/* + * Schedule this blt to avoid tearing. + */ +#define DDBLTFX_NOTEARING 0x00000008l + +/* + * Do this blt rotating the surface one hundred and eighty degrees. + */ +#define DDBLTFX_ROTATE180 0x00000010l + +/* + * Do this blt rotating the surface two hundred and seventy degrees. + */ +#define DDBLTFX_ROTATE270 0x00000020l + +/* + * Do this blt rotating the surface ninety degrees. + */ +#define DDBLTFX_ROTATE90 0x00000040l + +/* + * Do this z blt using dwZBufferLow and dwZBufferHigh as range values + * specified to limit the bits copied from the source surface. + */ +#define DDBLTFX_ZBUFFERRANGE 0x00000080l + +/* + * Do this z blt adding the dwZBufferBaseDest to each of the sources z values + * before comparing it with the desting z values. + */ +#define DDBLTFX_ZBUFFERBASEDEST 0x00000100l + +/**************************************************************************** + * + * DIRECTDRAWSURFACE OVERLAY FX FLAGS + * + ****************************************************************************/ + +/* + * If stretching, use arithmetic stretching along the Y axis for this overlay. + */ +#define DDOVERFX_ARITHSTRETCHY 0x00000001l + +/* + * Mirror the overlay across the vertical axis + */ +#define DDOVERFX_MIRRORLEFTRIGHT 0x00000002l + +/* + * Mirror the overlay across the horizontal axis + */ +#define DDOVERFX_MIRRORUPDOWN 0x00000004l + +/**************************************************************************** + * + * Flags for dwDDFX member of DDSPRITEFX structure + * + ****************************************************************************/ +/* + * Use affine transformation matrix in fTransform member. + */ +#define DDSPRITEFX_AFFINETRANSFORM 0x00000001l + +/* + * Use RGBA scaling factors in ddrgbaScaleFactors member. + */ +#define DDSPRITEFX_RGBASCALING 0x00000002l + +/* + * Degrade RGBA scaling factors to accommodate driver's capabilities. + */ +#define DDSPRITEFX_DEGRADERGBASCALING 0x00000004l + +/* + * Do bilinear filtering of stretched or warped sprite. + */ +#define DDSPRITEFX_BILINEARFILTER 0x00000008l + +/* + * Do "blur" filtering of stretched or warped sprite. + */ +#define DDSPRITEFX_BLURFILTER 0x00000010l + +/* + * Do "flat" filtering of stretched or warped sprite. + */ +#define DDSPRITEFX_FLATFILTER 0x00000020l + +/* + * Degrade filtering operation to accommodate driver's capabilities. + */ +#define DDSPRITEFX_DEGRADEFILTER 0x00000040l + + +/**************************************************************************** + * + * DIRECTDRAW WAITFORVERTICALBLANK FLAGS + * + ****************************************************************************/ + +/* + * return when the vertical blank interval begins + */ +#define DDWAITVB_BLOCKBEGIN 0x00000001l + +/* + * set up an event to trigger when the vertical blank begins + */ +#define DDWAITVB_BLOCKBEGINEVENT 0x00000002l + +/* + * return when the vertical blank interval ends and display begins + */ +#define DDWAITVB_BLOCKEND 0x00000004l + +/**************************************************************************** + * + * DIRECTDRAW GETFLIPSTATUS FLAGS + * + ****************************************************************************/ + +/* + * is it OK to flip now? + */ +#define DDGFS_CANFLIP 0x00000001l + +/* + * is the last flip finished? + */ +#define DDGFS_ISFLIPDONE 0x00000002l + +/**************************************************************************** + * + * DIRECTDRAW GETBLTSTATUS FLAGS + * + ****************************************************************************/ + +/* + * is it OK to blt now? + */ +#define DDGBS_CANBLT 0x00000001l + +/* + * is the blt to the surface finished? + */ +#define DDGBS_ISBLTDONE 0x00000002l + + +/**************************************************************************** + * + * DIRECTDRAW ENUMOVERLAYZORDER FLAGS + * + ****************************************************************************/ + +/* + * Enumerate overlays back to front. + */ +#define DDENUMOVERLAYZ_BACKTOFRONT 0x00000000l + +/* + * Enumerate overlays front to back + */ +#define DDENUMOVERLAYZ_FRONTTOBACK 0x00000001l + +/**************************************************************************** + * + * DIRECTDRAW UPDATEOVERLAYZORDER FLAGS + * + ****************************************************************************/ + +/* + * Send overlay to front + */ +#define DDOVERZ_SENDTOFRONT 0x00000000l + +/* + * Send overlay to back + */ +#define DDOVERZ_SENDTOBACK 0x00000001l + +/* + * Move Overlay forward + */ +#define DDOVERZ_MOVEFORWARD 0x00000002l + +/* + * Move Overlay backward + */ +#define DDOVERZ_MOVEBACKWARD 0x00000003l + +/* + * Move Overlay in front of relative surface + */ +#define DDOVERZ_INSERTINFRONTOF 0x00000004l + +/* + * Move Overlay in back of relative surface + */ +#define DDOVERZ_INSERTINBACKOF 0x00000005l + + + +/**************************************************************************** + * + * DIRECTDRAW SETGAMMARAMP FLAGS + * + ****************************************************************************/ + +/* + * Request calibrator to adjust the gamma ramp according to the physical + * properties of the display so that the result should appear identical + * on all systems. + */ +#define DDSGR_CALIBRATE 0x00000001L + + +/*=========================================================================== + * + * + * DIRECTDRAW RETURN CODES + * + * The return values from DirectDraw Commands and Surface that return an HRESULT + * are codes from DirectDraw concerning the results of the action + * requested by DirectDraw. + * + *==========================================================================*/ + +/* + * Status is OK + * + * Issued by: DirectDraw Commands and all callbacks + */ +#define DD_OK 0 +#define DD_FALSE S_FALSE + +/**************************************************************************** + * + * DIRECTDRAW ENUMCALLBACK RETURN VALUES + * + * EnumCallback returns are used to control the flow of the DIRECTDRAW and + * DIRECTDRAWSURFACE object enumerations. They can only be returned by + * enumeration callback routines. + * + ****************************************************************************/ + +/* + * stop the enumeration + */ +#define DDENUMRET_CANCEL 0 + +/* + * continue the enumeration + */ +#define DDENUMRET_OK 1 + +/**************************************************************************** + * + * DIRECTDRAW ERRORS + * + * Errors are represented by negative values and cannot be combined. + * + ****************************************************************************/ + +/* + * This object is already initialized + */ +#define DDERR_ALREADYINITIALIZED MAKE_DDHRESULT( 5 ) + +/* + * This surface can not be attached to the requested surface. + */ +#define DDERR_CANNOTATTACHSURFACE MAKE_DDHRESULT( 10 ) + +/* + * This surface can not be detached from the requested surface. + */ +#define DDERR_CANNOTDETACHSURFACE MAKE_DDHRESULT( 20 ) + +/* + * Support is currently not available. + */ +#define DDERR_CURRENTLYNOTAVAIL MAKE_DDHRESULT( 40 ) + +/* + * An exception was encountered while performing the requested operation + */ +#define DDERR_EXCEPTION MAKE_DDHRESULT( 55 ) + +/* + * Generic failure. + */ +#define DDERR_GENERIC E_FAIL + +/* + * Height of rectangle provided is not a multiple of reqd alignment + */ +#define DDERR_HEIGHTALIGN MAKE_DDHRESULT( 90 ) + +/* + * Unable to match primary surface creation request with existing + * primary surface. + */ +#define DDERR_INCOMPATIBLEPRIMARY MAKE_DDHRESULT( 95 ) + +/* + * One or more of the caps bits passed to the callback are incorrect. + */ +#define DDERR_INVALIDCAPS MAKE_DDHRESULT( 100 ) + +/* + * DirectDraw does not support provided Cliplist. + */ +#define DDERR_INVALIDCLIPLIST MAKE_DDHRESULT( 110 ) + +/* + * DirectDraw does not support the requested mode + */ +#define DDERR_INVALIDMODE MAKE_DDHRESULT( 120 ) + +/* + * DirectDraw received a pointer that was an invalid DIRECTDRAW object. + */ +#define DDERR_INVALIDOBJECT MAKE_DDHRESULT( 130 ) + +/* + * One or more of the parameters passed to the callback function are + * incorrect. + */ +#define DDERR_INVALIDPARAMS E_INVALIDARG + +/* + * pixel format was invalid as specified + */ +#define DDERR_INVALIDPIXELFORMAT MAKE_DDHRESULT( 145 ) + +/* + * Rectangle provided was invalid. + */ +#define DDERR_INVALIDRECT MAKE_DDHRESULT( 150 ) + +/* + * Operation could not be carried out because one or more surfaces are locked + */ +#define DDERR_LOCKEDSURFACES MAKE_DDHRESULT( 160 ) + +/* + * There is no 3D present. + */ +#define DDERR_NO3D MAKE_DDHRESULT( 170 ) + +/* + * Operation could not be carried out because there is no alpha accleration + * hardware present or available. + */ +#define DDERR_NOALPHAHW MAKE_DDHRESULT( 180 ) + + +/* + * no clip list available + */ +#define DDERR_NOCLIPLIST MAKE_DDHRESULT( 205 ) + +/* + * Operation could not be carried out because there is no color conversion + * hardware present or available. + */ +#define DDERR_NOCOLORCONVHW MAKE_DDHRESULT( 210 ) + +/* + * Create function called without DirectDraw object method SetCooperativeLevel + * being called. + */ +#define DDERR_NOCOOPERATIVELEVELSET MAKE_DDHRESULT( 212 ) + +/* + * Surface doesn't currently have a color key + */ +#define DDERR_NOCOLORKEY MAKE_DDHRESULT( 215 ) + +/* + * Operation could not be carried out because there is no hardware support + * of the dest color key. + */ +#define DDERR_NOCOLORKEYHW MAKE_DDHRESULT( 220 ) + +/* + * No DirectDraw support possible with current display driver + */ +#define DDERR_NODIRECTDRAWSUPPORT MAKE_DDHRESULT( 222 ) + +/* + * Operation requires the application to have exclusive mode but the + * application does not have exclusive mode. + */ +#define DDERR_NOEXCLUSIVEMODE MAKE_DDHRESULT( 225 ) + +/* + * Flipping visible surfaces is not supported. + */ +#define DDERR_NOFLIPHW MAKE_DDHRESULT( 230 ) + +/* + * There is no GDI present. + */ +#define DDERR_NOGDI MAKE_DDHRESULT( 240 ) + +/* + * Operation could not be carried out because there is no hardware present + * or available. + */ +#define DDERR_NOMIRRORHW MAKE_DDHRESULT( 250 ) + +/* + * Requested item was not found + */ +#define DDERR_NOTFOUND MAKE_DDHRESULT( 255 ) + +/* + * Operation could not be carried out because there is no overlay hardware + * present or available. + */ +#define DDERR_NOOVERLAYHW MAKE_DDHRESULT( 260 ) + +/* + * Operation could not be carried out because the source and destination + * rectangles are on the same surface and overlap each other. + */ +#define DDERR_OVERLAPPINGRECTS MAKE_DDHRESULT( 270 ) + +/* + * Operation could not be carried out because there is no appropriate raster + * op hardware present or available. + */ +#define DDERR_NORASTEROPHW MAKE_DDHRESULT( 280 ) + +/* + * Operation could not be carried out because there is no rotation hardware + * present or available. + */ +#define DDERR_NOROTATIONHW MAKE_DDHRESULT( 290 ) + +/* + * Operation could not be carried out because there is no hardware support + * for stretching + */ +#define DDERR_NOSTRETCHHW MAKE_DDHRESULT( 310 ) + +/* + * DirectDrawSurface is not in 4 bit color palette and the requested operation + * requires 4 bit color palette. + */ +#define DDERR_NOT4BITCOLOR MAKE_DDHRESULT( 316 ) + +/* + * DirectDrawSurface is not in 4 bit color index palette and the requested + * operation requires 4 bit color index palette. + */ +#define DDERR_NOT4BITCOLORINDEX MAKE_DDHRESULT( 317 ) + +/* + * DirectDraw Surface is not in 8 bit color mode and the requested operation + * requires 8 bit color. + */ +#define DDERR_NOT8BITCOLOR MAKE_DDHRESULT( 320 ) + +/* + * Operation could not be carried out because there is no texture mapping + * hardware present or available. + */ +#define DDERR_NOTEXTUREHW MAKE_DDHRESULT( 330 ) + +/* + * Operation could not be carried out because there is no hardware support + * for vertical blank synchronized operations. + */ +#define DDERR_NOVSYNCHW MAKE_DDHRESULT( 335 ) + +/* + * Operation could not be carried out because there is no hardware support + * for zbuffer blting. + */ +#define DDERR_NOZBUFFERHW MAKE_DDHRESULT( 340 ) + +/* + * Overlay surfaces could not be z layered based on their BltOrder because + * the hardware does not support z layering of overlays. + */ +#define DDERR_NOZOVERLAYHW MAKE_DDHRESULT( 350 ) + +/* + * The hardware needed for the requested operation has already been + * allocated. + */ +#define DDERR_OUTOFCAPS MAKE_DDHRESULT( 360 ) + +/* + * DirectDraw does not have enough memory to perform the operation. + */ +#define DDERR_OUTOFMEMORY E_OUTOFMEMORY + +/* + * DirectDraw does not have enough memory to perform the operation. + */ +#define DDERR_OUTOFVIDEOMEMORY MAKE_DDHRESULT( 380 ) + +/* + * hardware does not support clipped overlays + */ +#define DDERR_OVERLAYCANTCLIP MAKE_DDHRESULT( 382 ) + +/* + * Can only have ony color key active at one time for overlays + */ +#define DDERR_OVERLAYCOLORKEYONLYONEACTIVE MAKE_DDHRESULT( 384 ) + +/* + * Access to this palette is being refused because the palette is already + * locked by another thread. + */ +#define DDERR_PALETTEBUSY MAKE_DDHRESULT( 387 ) + +/* + * No src color key specified for this operation. + */ +#define DDERR_COLORKEYNOTSET MAKE_DDHRESULT( 400 ) + +/* + * This surface is already attached to the surface it is being attached to. + */ +#define DDERR_SURFACEALREADYATTACHED MAKE_DDHRESULT( 410 ) + +/* + * This surface is already a dependency of the surface it is being made a + * dependency of. + */ +#define DDERR_SURFACEALREADYDEPENDENT MAKE_DDHRESULT( 420 ) + +/* + * Access to this surface is being refused because the surface is already + * locked by another thread. + */ +#define DDERR_SURFACEBUSY MAKE_DDHRESULT( 430 ) + +/* + * Access to this surface is being refused because no driver exists + * which can supply a pointer to the surface. + * This is most likely to happen when attempting to lock the primary + * surface when no DCI provider is present. + * Will also happen on attempts to lock an optimized surface. + */ +#define DDERR_CANTLOCKSURFACE MAKE_DDHRESULT( 435 ) + +/* + * Access to Surface refused because Surface is obscured. + */ +#define DDERR_SURFACEISOBSCURED MAKE_DDHRESULT( 440 ) + +/* + * Access to this surface is being refused because the surface is gone. + * The DIRECTDRAWSURFACE object representing this surface should + * have Restore called on it. + */ +#define DDERR_SURFACELOST MAKE_DDHRESULT( 450 ) + +/* + * The requested surface is not attached. + */ +#define DDERR_SURFACENOTATTACHED MAKE_DDHRESULT( 460 ) + +/* + * Height requested by DirectDraw is too large. + */ +#define DDERR_TOOBIGHEIGHT MAKE_DDHRESULT( 470 ) + +/* + * Size requested by DirectDraw is too large -- The individual height and + * width are OK. + */ +#define DDERR_TOOBIGSIZE MAKE_DDHRESULT( 480 ) + +/* + * Width requested by DirectDraw is too large. + */ +#define DDERR_TOOBIGWIDTH MAKE_DDHRESULT( 490 ) + +/* + * Action not supported. + */ +#define DDERR_UNSUPPORTED E_NOTIMPL + +/* + * FOURCC format requested is unsupported by DirectDraw + */ +#define DDERR_UNSUPPORTEDFORMAT MAKE_DDHRESULT( 510 ) + +/* + * Bitmask in the pixel format requested is unsupported by DirectDraw + */ +#define DDERR_UNSUPPORTEDMASK MAKE_DDHRESULT( 520 ) + +/* + * The specified stream contains invalid data + */ +#define DDERR_INVALIDSTREAM MAKE_DDHRESULT( 521 ) + +/* + * vertical blank is in progress + */ +#define DDERR_VERTICALBLANKINPROGRESS MAKE_DDHRESULT( 537 ) + +/* + * Informs DirectDraw that the previous Blt which is transfering information + * to or from this Surface is incomplete. + */ +#define DDERR_WASSTILLDRAWING MAKE_DDHRESULT( 540 ) + + +/* + * Rectangle provided was not horizontally aligned on reqd. boundary + */ +#define DDERR_XALIGN MAKE_DDHRESULT( 560 ) + +/* + * The GUID passed to DirectDrawCreate is not a valid DirectDraw driver + * identifier. + */ +#define DDERR_INVALIDDIRECTDRAWGUID MAKE_DDHRESULT( 561 ) + +/* + * A DirectDraw object representing this driver has already been created + * for this process. + */ +#define DDERR_DIRECTDRAWALREADYCREATED MAKE_DDHRESULT( 562 ) + +/* + * A hardware only DirectDraw object creation was attempted but the driver + * did not support any hardware. + */ +#define DDERR_NODIRECTDRAWHW MAKE_DDHRESULT( 563 ) + +/* + * this process already has created a primary surface + */ +#define DDERR_PRIMARYSURFACEALREADYEXISTS MAKE_DDHRESULT( 564 ) + +/* + * software emulation not available. + */ +#define DDERR_NOEMULATION MAKE_DDHRESULT( 565 ) + +/* + * region passed to Clipper::GetClipList is too small. + */ +#define DDERR_REGIONTOOSMALL MAKE_DDHRESULT( 566 ) + +/* + * an attempt was made to set a clip list for a clipper objec that + * is already monitoring an hwnd. + */ +#define DDERR_CLIPPERISUSINGHWND MAKE_DDHRESULT( 567 ) + +/* + * No clipper object attached to surface object + */ +#define DDERR_NOCLIPPERATTACHED MAKE_DDHRESULT( 568 ) + +/* + * Clipper notification requires an HWND or + * no HWND has previously been set as the CooperativeLevel HWND. + */ +#define DDERR_NOHWND MAKE_DDHRESULT( 569 ) + +/* + * HWND used by DirectDraw CooperativeLevel has been subclassed, + * this prevents DirectDraw from restoring state. + */ +#define DDERR_HWNDSUBCLASSED MAKE_DDHRESULT( 570 ) + +/* + * The CooperativeLevel HWND has already been set. + * It can not be reset while the process has surfaces or palettes created. + */ +#define DDERR_HWNDALREADYSET MAKE_DDHRESULT( 571 ) + +/* + * No palette object attached to this surface. + */ +#define DDERR_NOPALETTEATTACHED MAKE_DDHRESULT( 572 ) + +/* + * No hardware support for 16 or 256 color palettes. + */ +#define DDERR_NOPALETTEHW MAKE_DDHRESULT( 573 ) + +/* + * If a clipper object is attached to the source surface passed into a + * BltFast call. + */ +#define DDERR_BLTFASTCANTCLIP MAKE_DDHRESULT( 574 ) + +/* + * No blter. + */ +#define DDERR_NOBLTHW MAKE_DDHRESULT( 575 ) + +/* + * No DirectDraw ROP hardware. + */ +#define DDERR_NODDROPSHW MAKE_DDHRESULT( 576 ) + +/* + * returned when GetOverlayPosition is called on a hidden overlay + */ +#define DDERR_OVERLAYNOTVISIBLE MAKE_DDHRESULT( 577 ) + +/* + * returned when GetOverlayPosition is called on a overlay that UpdateOverlay + * has never been called on to establish a destionation. + */ +#define DDERR_NOOVERLAYDEST MAKE_DDHRESULT( 578 ) + +/* + * returned when the position of the overlay on the destionation is no longer + * legal for that destionation. + */ +#define DDERR_INVALIDPOSITION MAKE_DDHRESULT( 579 ) + +/* + * returned when an overlay member is called for a non-overlay surface + */ +#define DDERR_NOTAOVERLAYSURFACE MAKE_DDHRESULT( 580 ) + +/* + * An attempt was made to set the cooperative level when it was already + * set to exclusive. + */ +#define DDERR_EXCLUSIVEMODEALREADYSET MAKE_DDHRESULT( 581 ) + +/* + * An attempt has been made to flip a surface that is not flippable. + */ +#define DDERR_NOTFLIPPABLE MAKE_DDHRESULT( 582 ) + +/* + * Can't duplicate primary & 3D surfaces, or surfaces that are implicitly + * created. + */ +#define DDERR_CANTDUPLICATE MAKE_DDHRESULT( 583 ) + +/* + * Surface was not locked. An attempt to unlock a surface that was not + * locked at all, or by this process, has been attempted. + */ +#define DDERR_NOTLOCKED MAKE_DDHRESULT( 584 ) + +/* + * Windows can not create any more DCs, or a DC was requested for a paltte-indexed + * surface when the surface had no palette AND the display mode was not palette-indexed + * (in this case DirectDraw cannot select a proper palette into the DC) + */ +#define DDERR_CANTCREATEDC MAKE_DDHRESULT( 585 ) + +/* + * No DC was ever created for this surface. + */ +#define DDERR_NODC MAKE_DDHRESULT( 586 ) + +/* + * This surface can not be restored because it was created in a different + * mode. + */ +#define DDERR_WRONGMODE MAKE_DDHRESULT( 587 ) + +/* + * This surface can not be restored because it is an implicitly created + * surface. + */ +#define DDERR_IMPLICITLYCREATED MAKE_DDHRESULT( 588 ) + +/* + * The surface being used is not a palette-based surface + */ +#define DDERR_NOTPALETTIZED MAKE_DDHRESULT( 589 ) + + +/* + * The display is currently in an unsupported mode + */ +#define DDERR_UNSUPPORTEDMODE MAKE_DDHRESULT( 590 ) + +/* + * Operation could not be carried out because there is no mip-map + * texture mapping hardware present or available. + */ +#define DDERR_NOMIPMAPHW MAKE_DDHRESULT( 591 ) + +/* + * The requested action could not be performed because the surface was of + * the wrong type. + */ +#define DDERR_INVALIDSURFACETYPE MAKE_DDHRESULT( 592 ) + + + +/* + * Device does not support optimized surfaces, therefore no video memory optimized surfaces + */ +#define DDERR_NOOPTIMIZEHW MAKE_DDHRESULT( 600 ) + +/* + * Surface is an optimized surface, but has not yet been allocated any memory + */ +#define DDERR_NOTLOADED MAKE_DDHRESULT( 601 ) + +/* + * Attempt was made to create or set a device window without first setting + * the focus window + */ +#define DDERR_NOFOCUSWINDOW MAKE_DDHRESULT( 602 ) + +/* + * A DC has already been returned for this surface. Only one DC can be + * retrieved per surface. + */ +#define DDERR_DCALREADYCREATED MAKE_DDHRESULT( 620 ) + +/* + * An attempt was made to allocate non-local video memory from a device + * that does not support non-local video memory. + */ +#define DDERR_NONONLOCALVIDMEM MAKE_DDHRESULT( 630 ) + +/* + * The attempt to page lock a surface failed. + */ +#define DDERR_CANTPAGELOCK MAKE_DDHRESULT( 640 ) + + +/* + * The attempt to page unlock a surface failed. + */ +#define DDERR_CANTPAGEUNLOCK MAKE_DDHRESULT( 660 ) + +/* + * An attempt was made to page unlock a surface with no outstanding page locks. + */ +#define DDERR_NOTPAGELOCKED MAKE_DDHRESULT( 680 ) + +/* + * There is more data available than the specified buffer size could hold + */ +#define DDERR_MOREDATA MAKE_DDHRESULT( 690 ) + +/* + * The data has expired and is therefore no longer valid. + */ +#define DDERR_EXPIRED MAKE_DDHRESULT( 691 ) + +/* + * The video port is not active + */ +#define DDERR_VIDEONOTACTIVE MAKE_DDHRESULT( 695 ) + +/* + * Surfaces created by one direct draw device cannot be used directly by + * another direct draw device. + */ +#define DDERR_DEVICEDOESNTOWNSURFACE MAKE_DDHRESULT( 699 ) + + +/* + * An attempt was made to invoke an interface member of a DirectDraw object + * created by CoCreateInstance() before it was initialized. + */ +#define DDERR_NOTINITIALIZED CO_E_NOTINITIALIZED + + +/* Alpha bit depth constants */ + + +#ifdef __cplusplus +}; +#endif + +#endif + diff --git a/misc/builddeps/dp.win64/include/dinput.h b/misc/builddeps/dp.win64/include/dinput.h new file mode 100644 index 00000000..5bf9f5ae --- /dev/null +++ b/misc/builddeps/dp.win64/include/dinput.h @@ -0,0 +1,1849 @@ +/**************************************************************************** + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: dinput.h + * Content: DirectInput include file + * + ****************************************************************************/ + +#ifndef __DINPUT_INCLUDED__ +#define __DINPUT_INCLUDED__ + +#ifndef DIJ_RINGZERO + +#ifdef _WIN32 +#define COM_NO_WINDOWS_H +#include +#endif + +#endif /* DIJ_RINGZERO */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef DIRECTINPUT_VERSION +#define DIRECTINPUT_VERSION 0x0500 +#endif + +#ifndef DIJ_RINGZERO +/**************************************************************************** + * + * Class IDs + * + ****************************************************************************/ + +DEFINE_GUID(CLSID_DirectInput, 0x25E609E0,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(CLSID_DirectInputDevice,0x25E609E1,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +/**************************************************************************** + * + * Interfaces + * + ****************************************************************************/ + +DEFINE_GUID(IID_IDirectInputA, 0x89521360,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(IID_IDirectInputW, 0x89521361,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(IID_IDirectInput2A, 0x5944E662,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(IID_IDirectInput2W, 0x5944E663,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +DEFINE_GUID(IID_IDirectInputDeviceA, 0x5944E680,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(IID_IDirectInputDeviceW, 0x5944E681,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(IID_IDirectInputDevice2A,0x5944E682,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(IID_IDirectInputDevice2W,0x5944E683,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +DEFINE_GUID(IID_IDirectInputEffect, 0xE7E1F7C0,0x88D2,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); + +/**************************************************************************** + * + * Predefined object types + * + ****************************************************************************/ + +DEFINE_GUID(GUID_XAxis, 0xA36D02E0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_YAxis, 0xA36D02E1,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_ZAxis, 0xA36D02E2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_RxAxis, 0xA36D02F4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_RyAxis, 0xA36D02F5,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_RzAxis, 0xA36D02E3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_Slider, 0xA36D02E4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +DEFINE_GUID(GUID_Button, 0xA36D02F0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_Key, 0x55728220,0xD33C,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +DEFINE_GUID(GUID_POV, 0xA36D02F2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +DEFINE_GUID(GUID_Unknown, 0xA36D02F3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +/**************************************************************************** + * + * Predefined product GUIDs + * + ****************************************************************************/ + +DEFINE_GUID(GUID_SysMouse, 0x6F1D2B60,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_SysKeyboard,0x6F1D2B61,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); +DEFINE_GUID(GUID_Joystick ,0x6F1D2B70,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); + +/**************************************************************************** + * + * Predefined force feedback effects + * + ****************************************************************************/ + +DEFINE_GUID(GUID_ConstantForce,0x13541C20,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_RampForce, 0x13541C21,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Square, 0x13541C22,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Sine, 0x13541C23,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Triangle, 0x13541C24,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_SawtoothUp, 0x13541C25,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_SawtoothDown, 0x13541C26,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Spring, 0x13541C27,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Damper, 0x13541C28,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Inertia, 0x13541C29,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_Friction, 0x13541C2A,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); +DEFINE_GUID(GUID_CustomForce, 0x13541C2B,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35); + + +#endif /* DIJ_RINGZERO */ + +/**************************************************************************** + * + * Interfaces and Structures... + * + ****************************************************************************/ + +#if(DIRECTINPUT_VERSION >= 0x0500) + +/**************************************************************************** + * + * IDirectInputEffect + * + ****************************************************************************/ + +#define DIEFT_ALL 0x00000000 + +#define DIEFT_CONSTANTFORCE 0x00000001 +#define DIEFT_RAMPFORCE 0x00000002 +#define DIEFT_PERIODIC 0x00000003 +#define DIEFT_CONDITION 0x00000004 +#define DIEFT_CUSTOMFORCE 0x00000005 +#define DIEFT_HARDWARE 0x000000FF + +#define DIEFT_FFATTACK 0x00000200 +#define DIEFT_FFFADE 0x00000400 +#define DIEFT_SATURATION 0x00000800 +#define DIEFT_POSNEGCOEFFICIENTS 0x00001000 +#define DIEFT_POSNEGSATURATION 0x00002000 +#define DIEFT_DEADBAND 0x00004000 + +#define DIEFT_GETTYPE(n) LOBYTE(n) + +#define DI_DEGREES 100 +#define DI_FFNOMINALMAX 10000 +#define DI_SECONDS 1000000 + +typedef struct DICONSTANTFORCE { + LONG lMagnitude; +} DICONSTANTFORCE, *LPDICONSTANTFORCE; +typedef const DICONSTANTFORCE *LPCDICONSTANTFORCE; + +typedef struct DIRAMPFORCE { + LONG lStart; + LONG lEnd; +} DIRAMPFORCE, *LPDIRAMPFORCE; +typedef const DIRAMPFORCE *LPCDIRAMPFORCE; + +typedef struct DIPERIODIC { + DWORD dwMagnitude; + LONG lOffset; + DWORD dwPhase; + DWORD dwPeriod; +} DIPERIODIC, *LPDIPERIODIC; +typedef const DIPERIODIC *LPCDIPERIODIC; + +typedef struct DICONDITION { + LONG lOffset; + LONG lPositiveCoefficient; + LONG lNegativeCoefficient; + DWORD dwPositiveSaturation; + DWORD dwNegativeSaturation; + LONG lDeadBand; +} DICONDITION, *LPDICONDITION; +typedef const DICONDITION *LPCDICONDITION; + +typedef struct DICUSTOMFORCE { + DWORD cChannels; + DWORD dwSamplePeriod; + DWORD cSamples; + LPLONG rglForceData; +} DICUSTOMFORCE, *LPDICUSTOMFORCE; +typedef const DICUSTOMFORCE *LPCDICUSTOMFORCE; + +typedef struct DIENVELOPE { + DWORD dwSize; /* sizeof(DIENVELOPE) */ + DWORD dwAttackLevel; + DWORD dwAttackTime; /* Microseconds */ + DWORD dwFadeLevel; + DWORD dwFadeTime; /* Microseconds */ +} DIENVELOPE, *LPDIENVELOPE; +typedef const DIENVELOPE *LPCDIENVELOPE; + +typedef struct DIEFFECT { + DWORD dwSize; /* sizeof(DIEFFECT) */ + DWORD dwFlags; /* DIEFF_* */ + DWORD dwDuration; /* Microseconds */ + DWORD dwSamplePeriod; /* Microseconds */ + DWORD dwGain; + DWORD dwTriggerButton; /* or DIEB_NOTRIGGER */ + DWORD dwTriggerRepeatInterval; /* Microseconds */ + DWORD cAxes; /* Number of axes */ + LPDWORD rgdwAxes; /* Array of axes */ + LPLONG rglDirection; /* Array of directions */ + LPDIENVELOPE lpEnvelope; /* Optional */ + DWORD cbTypeSpecificParams; /* Size of params */ + LPVOID lpvTypeSpecificParams; /* Pointer to params */ +} DIEFFECT, *LPDIEFFECT; +typedef const DIEFFECT *LPCDIEFFECT; + +#define DIEFF_OBJECTIDS 0x00000001 +#define DIEFF_OBJECTOFFSETS 0x00000002 +#define DIEFF_CARTESIAN 0x00000010 +#define DIEFF_POLAR 0x00000020 +#define DIEFF_SPHERICAL 0x00000040 + +#define DIEP_DURATION 0x00000001 +#define DIEP_SAMPLEPERIOD 0x00000002 +#define DIEP_GAIN 0x00000004 +#define DIEP_TRIGGERBUTTON 0x00000008 +#define DIEP_TRIGGERREPEATINTERVAL 0x00000010 +#define DIEP_AXES 0x00000020 +#define DIEP_DIRECTION 0x00000040 +#define DIEP_ENVELOPE 0x00000080 +#define DIEP_TYPESPECIFICPARAMS 0x00000100 +#define DIEP_ALLPARAMS 0x000001FF +#define DIEP_START 0x20000000 +#define DIEP_NORESTART 0x40000000 +#define DIEP_NODOWNLOAD 0x80000000 +#define DIEB_NOTRIGGER 0xFFFFFFFF + +#define DIES_SOLO 0x00000001 +#define DIES_NODOWNLOAD 0x80000000 + +#define DIEGES_PLAYING 0x00000001 +#define DIEGES_EMULATED 0x00000002 + +typedef struct DIEFFESCAPE { + DWORD dwSize; + DWORD dwCommand; + LPVOID lpvInBuffer; + DWORD cbInBuffer; + LPVOID lpvOutBuffer; + DWORD cbOutBuffer; +} DIEFFESCAPE, *LPDIEFFESCAPE; + +#ifndef DIJ_RINGZERO + +#undef INTERFACE +#define INTERFACE IDirectInputEffect + +DECLARE_INTERFACE_(IDirectInputEffect, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputEffect methods ***/ + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE; + STDMETHOD(GetEffectGuid)(THIS_ LPGUID) PURE; + STDMETHOD(GetParameters)(THIS_ LPDIEFFECT,DWORD) PURE; + STDMETHOD(SetParameters)(THIS_ LPCDIEFFECT,DWORD) PURE; + STDMETHOD(Start)(THIS_ DWORD,DWORD) PURE; + STDMETHOD(Stop)(THIS) PURE; + STDMETHOD(GetEffectStatus)(THIS_ LPDWORD) PURE; + STDMETHOD(Download)(THIS) PURE; + STDMETHOD(Unload)(THIS) PURE; + STDMETHOD(Escape)(THIS_ LPDIEFFESCAPE) PURE; +}; + +typedef struct IDirectInputEffect *LPDIRECTINPUTEFFECT; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectInputEffect_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectInputEffect_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectInputEffect_Release(p) (p)->lpVtbl->Release(p) +#define IDirectInputEffect_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c) +#define IDirectInputEffect_GetEffectGuid(p,a) (p)->lpVtbl->GetEffectGuid(p,a) +#define IDirectInputEffect_GetParameters(p,a,b) (p)->lpVtbl->GetParameters(p,a,b) +#define IDirectInputEffect_SetParameters(p,a,b) (p)->lpVtbl->SetParameters(p,a,b) +#define IDirectInputEffect_Start(p,a,b) (p)->lpVtbl->Start(p,a,b) +#define IDirectInputEffect_Stop(p) (p)->lpVtbl->Stop(p) +#define IDirectInputEffect_GetEffectStatus(p,a) (p)->lpVtbl->GetEffectStatus(p,a) +#define IDirectInputEffect_Download(p) (p)->lpVtbl->Download(p) +#define IDirectInputEffect_Unload(p) (p)->lpVtbl->Unload(p) +#define IDirectInputEffect_Escape(p,a) (p)->lpVtbl->Escape(p,a) +#else +#define IDirectInputEffect_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectInputEffect_AddRef(p) (p)->AddRef() +#define IDirectInputEffect_Release(p) (p)->Release() +#define IDirectInputEffect_Initialize(p,a,b,c) (p)->Initialize(a,b,c) +#define IDirectInputEffect_GetEffectGuid(p,a) (p)->GetEffectGuid(a) +#define IDirectInputEffect_GetParameters(p,a,b) (p)->GetParameters(a,b) +#define IDirectInputEffect_SetParameters(p,a,b) (p)->SetParameters(a,b) +#define IDirectInputEffect_Start(p,a,b) (p)->Start(a,b) +#define IDirectInputEffect_Stop(p) (p)->Stop() +#define IDirectInputEffect_GetEffectStatus(p,a) (p)->GetEffectStatus(a) +#define IDirectInputEffect_Download(p) (p)->Download() +#define IDirectInputEffect_Unload(p) (p)->Unload() +#define IDirectInputEffect_Escape(p,a) (p)->Escape(a) +#endif + +#endif /* DIJ_RINGZERO */ + +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +/**************************************************************************** + * + * IDirectInputDevice + * + ****************************************************************************/ + +#define DIDEVTYPE_DEVICE 1 +#define DIDEVTYPE_MOUSE 2 +#define DIDEVTYPE_KEYBOARD 3 +#define DIDEVTYPE_JOYSTICK 4 +#define DIDEVTYPE_HID 0x00010000 + +#define DIDEVTYPEMOUSE_UNKNOWN 1 +#define DIDEVTYPEMOUSE_TRADITIONAL 2 +#define DIDEVTYPEMOUSE_FINGERSTICK 3 +#define DIDEVTYPEMOUSE_TOUCHPAD 4 +#define DIDEVTYPEMOUSE_TRACKBALL 5 + +#define DIDEVTYPEKEYBOARD_UNKNOWN 0 +#define DIDEVTYPEKEYBOARD_PCXT 1 +#define DIDEVTYPEKEYBOARD_OLIVETTI 2 +#define DIDEVTYPEKEYBOARD_PCAT 3 +#define DIDEVTYPEKEYBOARD_PCENH 4 +#define DIDEVTYPEKEYBOARD_NOKIA1050 5 +#define DIDEVTYPEKEYBOARD_NOKIA9140 6 +#define DIDEVTYPEKEYBOARD_NEC98 7 +#define DIDEVTYPEKEYBOARD_NEC98LAPTOP 8 +#define DIDEVTYPEKEYBOARD_NEC98106 9 +#define DIDEVTYPEKEYBOARD_JAPAN106 10 +#define DIDEVTYPEKEYBOARD_JAPANAX 11 +#define DIDEVTYPEKEYBOARD_J3100 12 + +#define DIDEVTYPEJOYSTICK_UNKNOWN 1 +#define DIDEVTYPEJOYSTICK_TRADITIONAL 2 +#define DIDEVTYPEJOYSTICK_FLIGHTSTICK 3 +#define DIDEVTYPEJOYSTICK_GAMEPAD 4 +#define DIDEVTYPEJOYSTICK_RUDDER 5 +#define DIDEVTYPEJOYSTICK_WHEEL 6 +#define DIDEVTYPEJOYSTICK_HEADTRACKER 7 + +#define GET_DIDEVICE_TYPE(dwDevType) LOBYTE(dwDevType) +#define GET_DIDEVICE_SUBTYPE(dwDevType) HIBYTE(dwDevType) + +#if(DIRECTINPUT_VERSION >= 0x0500) +/* This structure is defined for DirectX 3.0 compatibility */ + +typedef struct DIDEVCAPS_DX3 { + DWORD dwSize; + DWORD dwFlags; + DWORD dwDevType; + DWORD dwAxes; + DWORD dwButtons; + DWORD dwPOVs; +} DIDEVCAPS_DX3, *LPDIDEVCAPS_DX3; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +typedef struct DIDEVCAPS { + DWORD dwSize; + DWORD dwFlags; + DWORD dwDevType; + DWORD dwAxes; + DWORD dwButtons; + DWORD dwPOVs; +#if(DIRECTINPUT_VERSION >= 0x0500) + DWORD dwFFSamplePeriod; + DWORD dwFFMinTimeResolution; + DWORD dwFirmwareRevision; + DWORD dwHardwareRevision; + DWORD dwFFDriverVersion; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ +} DIDEVCAPS, *LPDIDEVCAPS; + +#define DIDC_ATTACHED 0x00000001 +#define DIDC_POLLEDDEVICE 0x00000002 +#define DIDC_EMULATED 0x00000004 +#define DIDC_POLLEDDATAFORMAT 0x00000008 +#if(DIRECTINPUT_VERSION >= 0x0500) +#define DIDC_FORCEFEEDBACK 0x00000100 +#define DIDC_FFATTACK 0x00000200 +#define DIDC_FFFADE 0x00000400 +#define DIDC_SATURATION 0x00000800 +#define DIDC_POSNEGCOEFFICIENTS 0x00001000 +#define DIDC_POSNEGSATURATION 0x00002000 +#define DIDC_DEADBAND 0x00004000 +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +#define DIDFT_ALL 0x00000000 + +#define DIDFT_RELAXIS 0x00000001 +#define DIDFT_ABSAXIS 0x00000002 +#define DIDFT_AXIS 0x00000003 + +#define DIDFT_PSHBUTTON 0x00000004 +#define DIDFT_TGLBUTTON 0x00000008 +#define DIDFT_BUTTON 0x0000000C + +#define DIDFT_POV 0x00000010 + +#define DIDFT_COLLECTION 0x00000040 +#define DIDFT_NODATA 0x00000080 + +#define DIDFT_ANYINSTANCE 0x00FFFF00 +#define DIDFT_INSTANCEMASK DIDFT_ANYINSTANCE +#define DIDFT_MAKEINSTANCE(n) ((WORD)(n) << 8) +#define DIDFT_GETTYPE(n) LOBYTE(n) +#define DIDFT_GETINSTANCE(n) LOWORD((n) >> 8) +#define DIDFT_FFACTUATOR 0x01000000 +#define DIDFT_FFEFFECTTRIGGER 0x02000000 + +#define DIDFT_ENUMCOLLECTION(n) ((WORD)(n) << 8) +#define DIDFT_NOCOLLECTION 0x00FFFF00 + + +#ifndef DIJ_RINGZERO + +typedef struct _DIOBJECTDATAFORMAT { + const GUID *pguid; + DWORD dwOfs; + DWORD dwType; + DWORD dwFlags; +} DIOBJECTDATAFORMAT, *LPDIOBJECTDATAFORMAT; +typedef const DIOBJECTDATAFORMAT *LPCDIOBJECTDATAFORMAT; + +typedef struct _DIDATAFORMAT { + DWORD dwSize; + DWORD dwObjSize; + DWORD dwFlags; + DWORD dwDataSize; + DWORD dwNumObjs; + LPDIOBJECTDATAFORMAT rgodf; +} DIDATAFORMAT, *LPDIDATAFORMAT; +typedef const DIDATAFORMAT *LPCDIDATAFORMAT; + +#define DIDF_ABSAXIS 0x00000001 +#define DIDF_RELAXIS 0x00000002 + +extern const DIDATAFORMAT c_dfDIMouse; +extern const DIDATAFORMAT c_dfDIKeyboard; +extern const DIDATAFORMAT c_dfDIJoystick; +extern const DIDATAFORMAT c_dfDIJoystick2; + +#if(DIRECTINPUT_VERSION >= 0x0500) +/* These structures are defined for DirectX 3.0 compatibility */ + +typedef struct DIDEVICEOBJECTINSTANCE_DX3A { + DWORD dwSize; + GUID guidType; + DWORD dwOfs; + DWORD dwType; + DWORD dwFlags; + CHAR tszName[MAX_PATH]; +} DIDEVICEOBJECTINSTANCE_DX3A, *LPDIDEVICEOBJECTINSTANCE_DX3A; +typedef struct DIDEVICEOBJECTINSTANCE_DX3W { + DWORD dwSize; + GUID guidType; + DWORD dwOfs; + DWORD dwType; + DWORD dwFlags; + WCHAR tszName[MAX_PATH]; +} DIDEVICEOBJECTINSTANCE_DX3W, *LPDIDEVICEOBJECTINSTANCE_DX3W; +#ifdef UNICODE +typedef DIDEVICEOBJECTINSTANCE_DX3W DIDEVICEOBJECTINSTANCE_DX3; +typedef LPDIDEVICEOBJECTINSTANCE_DX3W LPDIDEVICEOBJECTINSTANCE_DX3; +#else +typedef DIDEVICEOBJECTINSTANCE_DX3A DIDEVICEOBJECTINSTANCE_DX3; +typedef LPDIDEVICEOBJECTINSTANCE_DX3A LPDIDEVICEOBJECTINSTANCE_DX3; +#endif // UNICODE +typedef const DIDEVICEOBJECTINSTANCE_DX3A *LPCDIDEVICEOBJECTINSTANCE_DX3A; +typedef const DIDEVICEOBJECTINSTANCE_DX3W *LPCDIDEVICEOBJECTINSTANCE_DX3W; +typedef const DIDEVICEOBJECTINSTANCE_DX3 *LPCDIDEVICEOBJECTINSTANCE_DX3; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +typedef struct DIDEVICEOBJECTINSTANCEA { + DWORD dwSize; + GUID guidType; + DWORD dwOfs; + DWORD dwType; + DWORD dwFlags; + CHAR tszName[MAX_PATH]; +#if(DIRECTINPUT_VERSION >= 0x0500) + DWORD dwFFMaxForce; + DWORD dwFFForceResolution; + WORD wCollectionNumber; + WORD wDesignatorIndex; + WORD wUsagePage; + WORD wUsage; + DWORD dwDimension; + WORD wExponent; + WORD wReserved; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ +} DIDEVICEOBJECTINSTANCEA, *LPDIDEVICEOBJECTINSTANCEA; +typedef struct DIDEVICEOBJECTINSTANCEW { + DWORD dwSize; + GUID guidType; + DWORD dwOfs; + DWORD dwType; + DWORD dwFlags; + WCHAR tszName[MAX_PATH]; +#if(DIRECTINPUT_VERSION >= 0x0500) + DWORD dwFFMaxForce; + DWORD dwFFForceResolution; + WORD wCollectionNumber; + WORD wDesignatorIndex; + WORD wUsagePage; + WORD wUsage; + DWORD dwDimension; + WORD wExponent; + WORD wReserved; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ +} DIDEVICEOBJECTINSTANCEW, *LPDIDEVICEOBJECTINSTANCEW; +#ifdef UNICODE +typedef DIDEVICEOBJECTINSTANCEW DIDEVICEOBJECTINSTANCE; +typedef LPDIDEVICEOBJECTINSTANCEW LPDIDEVICEOBJECTINSTANCE; +#else +typedef DIDEVICEOBJECTINSTANCEA DIDEVICEOBJECTINSTANCE; +typedef LPDIDEVICEOBJECTINSTANCEA LPDIDEVICEOBJECTINSTANCE; +#endif // UNICODE +typedef const DIDEVICEOBJECTINSTANCEA *LPCDIDEVICEOBJECTINSTANCEA; +typedef const DIDEVICEOBJECTINSTANCEW *LPCDIDEVICEOBJECTINSTANCEW; +typedef const DIDEVICEOBJECTINSTANCE *LPCDIDEVICEOBJECTINSTANCE; + +typedef BOOL (FAR PASCAL * LPDIENUMDEVICEOBJECTSCALLBACKA)(LPCDIDEVICEOBJECTINSTANCEA, LPVOID); +typedef BOOL (FAR PASCAL * LPDIENUMDEVICEOBJECTSCALLBACKW)(LPCDIDEVICEOBJECTINSTANCEW, LPVOID); +#ifdef UNICODE +#define LPDIENUMDEVICEOBJECTSCALLBACK LPDIENUMDEVICEOBJECTSCALLBACKW +#else +#define LPDIENUMDEVICEOBJECTSCALLBACK LPDIENUMDEVICEOBJECTSCALLBACKA +#endif // !UNICODE + +#if(DIRECTINPUT_VERSION >= 0x0500) +#define DIDOI_FFACTUATOR 0x00000001 +#define DIDOI_FFEFFECTTRIGGER 0x00000002 +#define DIDOI_POLLED 0x00008000 +#define DIDOI_ASPECTPOSITION 0x00000100 +#define DIDOI_ASPECTVELOCITY 0x00000200 +#define DIDOI_ASPECTACCEL 0x00000300 +#define DIDOI_ASPECTFORCE 0x00000400 +#define DIDOI_ASPECTMASK 0x00000F00 +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +typedef struct DIPROPHEADER { + DWORD dwSize; + DWORD dwHeaderSize; + DWORD dwObj; + DWORD dwHow; +} DIPROPHEADER, *LPDIPROPHEADER; +typedef const DIPROPHEADER *LPCDIPROPHEADER; + +#define DIPH_DEVICE 0 +#define DIPH_BYOFFSET 1 +#define DIPH_BYID 2 + +typedef struct DIPROPDWORD { + DIPROPHEADER diph; + DWORD dwData; +} DIPROPDWORD, *LPDIPROPDWORD; +typedef const DIPROPDWORD *LPCDIPROPDWORD; + +typedef struct DIPROPRANGE { + DIPROPHEADER diph; + LONG lMin; + LONG lMax; +} DIPROPRANGE, *LPDIPROPRANGE; +typedef const DIPROPRANGE *LPCDIPROPRANGE; + +#define DIPROPRANGE_NOMIN ((LONG)0x80000000) +#define DIPROPRANGE_NOMAX ((LONG)0x7FFFFFFF) + +#ifdef __cplusplus +#define MAKEDIPROP(prop) (*(const GUID *)(prop)) +#else +#define MAKEDIPROP(prop) ((REFGUID)(prop)) +#endif + +#define DIPROP_BUFFERSIZE MAKEDIPROP(1) + +#define DIPROP_AXISMODE MAKEDIPROP(2) + +#define DIPROPAXISMODE_ABS 0 +#define DIPROPAXISMODE_REL 1 + +#define DIPROP_GRANULARITY MAKEDIPROP(3) + +#define DIPROP_RANGE MAKEDIPROP(4) + +#define DIPROP_DEADZONE MAKEDIPROP(5) + +#define DIPROP_SATURATION MAKEDIPROP(6) + +#define DIPROP_FFGAIN MAKEDIPROP(7) + +#define DIPROP_FFLOAD MAKEDIPROP(8) + +#define DIPROP_AUTOCENTER MAKEDIPROP(9) + +#define DIPROPAUTOCENTER_OFF 0 +#define DIPROPAUTOCENTER_ON 1 + +#define DIPROP_CALIBRATIONMODE MAKEDIPROP(10) + +#define DIPROPCALIBRATIONMODE_COOKED 0 +#define DIPROPCALIBRATIONMODE_RAW 1 + +typedef struct DIDEVICEOBJECTDATA { + DWORD dwOfs; + DWORD dwData; + DWORD dwTimeStamp; + DWORD dwSequence; +} DIDEVICEOBJECTDATA, *LPDIDEVICEOBJECTDATA; +typedef const DIDEVICEOBJECTDATA *LPCDIDEVICEOBJECTDATA; + +#define DIGDD_PEEK 0x00000001 + +#define DISEQUENCE_COMPARE(dwSequence1, cmp, dwSequence2) \ + ((int)((dwSequence1) - (dwSequence2)) cmp 0) +#define DISCL_EXCLUSIVE 0x00000001 +#define DISCL_NONEXCLUSIVE 0x00000002 +#define DISCL_FOREGROUND 0x00000004 +#define DISCL_BACKGROUND 0x00000008 + +#if(DIRECTINPUT_VERSION >= 0x0500) +/* These structures are defined for DirectX 3.0 compatibility */ + +typedef struct DIDEVICEINSTANCE_DX3A { + DWORD dwSize; + GUID guidInstance; + GUID guidProduct; + DWORD dwDevType; + CHAR tszInstanceName[MAX_PATH]; + CHAR tszProductName[MAX_PATH]; +} DIDEVICEINSTANCE_DX3A, *LPDIDEVICEINSTANCE_DX3A; +typedef struct DIDEVICEINSTANCE_DX3W { + DWORD dwSize; + GUID guidInstance; + GUID guidProduct; + DWORD dwDevType; + WCHAR tszInstanceName[MAX_PATH]; + WCHAR tszProductName[MAX_PATH]; +} DIDEVICEINSTANCE_DX3W, *LPDIDEVICEINSTANCE_DX3W; +#ifdef UNICODE +typedef DIDEVICEINSTANCE_DX3W DIDEVICEINSTANCE_DX3; +typedef LPDIDEVICEINSTANCE_DX3W LPDIDEVICEINSTANCE_DX3; +#else +typedef DIDEVICEINSTANCE_DX3A DIDEVICEINSTANCE_DX3; +typedef LPDIDEVICEINSTANCE_DX3A LPDIDEVICEINSTANCE_DX3; +#endif // UNICODE +typedef const DIDEVICEINSTANCE_DX3A *LPCDIDEVICEINSTANCE_DX3A; +typedef const DIDEVICEINSTANCE_DX3W *LPCDIDEVICEINSTANCE_DX3W; +typedef const DIDEVICEINSTANCE_DX3 *LPCDIDEVICEINSTANCE_DX3; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +typedef struct DIDEVICEINSTANCEA { + DWORD dwSize; + GUID guidInstance; + GUID guidProduct; + DWORD dwDevType; + CHAR tszInstanceName[MAX_PATH]; + CHAR tszProductName[MAX_PATH]; +#if(DIRECTINPUT_VERSION >= 0x0500) + GUID guidFFDriver; + WORD wUsagePage; + WORD wUsage; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ +} DIDEVICEINSTANCEA, *LPDIDEVICEINSTANCEA; +typedef struct DIDEVICEINSTANCEW { + DWORD dwSize; + GUID guidInstance; + GUID guidProduct; + DWORD dwDevType; + WCHAR tszInstanceName[MAX_PATH]; + WCHAR tszProductName[MAX_PATH]; +#if(DIRECTINPUT_VERSION >= 0x0500) + GUID guidFFDriver; + WORD wUsagePage; + WORD wUsage; +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ +} DIDEVICEINSTANCEW, *LPDIDEVICEINSTANCEW; +#ifdef UNICODE +typedef DIDEVICEINSTANCEW DIDEVICEINSTANCE; +typedef LPDIDEVICEINSTANCEW LPDIDEVICEINSTANCE; +#else +typedef DIDEVICEINSTANCEA DIDEVICEINSTANCE; +typedef LPDIDEVICEINSTANCEA LPDIDEVICEINSTANCE; +#endif // UNICODE +typedef const DIDEVICEINSTANCEA *LPCDIDEVICEINSTANCEA; +typedef const DIDEVICEINSTANCEW *LPCDIDEVICEINSTANCEW; +typedef const DIDEVICEINSTANCE *LPCDIDEVICEINSTANCE; + +#undef INTERFACE +#define INTERFACE IDirectInputDeviceW + +DECLARE_INTERFACE_(IDirectInputDeviceW, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputDeviceW methods ***/ + STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE; + STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKW,LPVOID,DWORD) PURE; + STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE; + STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE; + STDMETHOD(Acquire)(THIS) PURE; + STDMETHOD(Unacquire)(THIS) PURE; + STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE; + STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE; + STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE; + STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEW,DWORD,DWORD) PURE; + STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEW) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE; +}; + +typedef struct IDirectInputDeviceW *LPDIRECTINPUTDEVICEW; + +#undef INTERFACE +#define INTERFACE IDirectInputDeviceA + +DECLARE_INTERFACE_(IDirectInputDeviceA, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputDeviceA methods ***/ + STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE; + STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKA,LPVOID,DWORD) PURE; + STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE; + STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE; + STDMETHOD(Acquire)(THIS) PURE; + STDMETHOD(Unacquire)(THIS) PURE; + STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE; + STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE; + STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE; + STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEA,DWORD,DWORD) PURE; + STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEA) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE; +}; + +typedef struct IDirectInputDeviceA *LPDIRECTINPUTDEVICEA; + +#ifdef UNICODE +#define IID_IDirectInputDevice IID_IDirectInputDeviceW +#define IDirectInputDevice IDirectInputDeviceW +#define IDirectInputDeviceVtbl IDirectInputDeviceWVtbl +#else +#define IID_IDirectInputDevice IID_IDirectInputDeviceA +#define IDirectInputDevice IDirectInputDeviceA +#define IDirectInputDeviceVtbl IDirectInputDeviceAVtbl +#endif +typedef struct IDirectInputDevice *LPDIRECTINPUTDEVICE; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectInputDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectInputDevice_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectInputDevice_Release(p) (p)->lpVtbl->Release(p) +#define IDirectInputDevice_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a) +#define IDirectInputDevice_EnumObjects(p,a,b,c) (p)->lpVtbl->EnumObjects(p,a,b,c) +#define IDirectInputDevice_GetProperty(p,a,b) (p)->lpVtbl->GetProperty(p,a,b) +#define IDirectInputDevice_SetProperty(p,a,b) (p)->lpVtbl->SetProperty(p,a,b) +#define IDirectInputDevice_Acquire(p) (p)->lpVtbl->Acquire(p) +#define IDirectInputDevice_Unacquire(p) (p)->lpVtbl->Unacquire(p) +#define IDirectInputDevice_GetDeviceState(p,a,b) (p)->lpVtbl->GetDeviceState(p,a,b) +#define IDirectInputDevice_GetDeviceData(p,a,b,c,d) (p)->lpVtbl->GetDeviceData(p,a,b,c,d) +#define IDirectInputDevice_SetDataFormat(p,a) (p)->lpVtbl->SetDataFormat(p,a) +#define IDirectInputDevice_SetEventNotification(p,a) (p)->lpVtbl->SetEventNotification(p,a) +#define IDirectInputDevice_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b) +#define IDirectInputDevice_GetObjectInfo(p,a,b,c) (p)->lpVtbl->GetObjectInfo(p,a,b,c) +#define IDirectInputDevice_GetDeviceInfo(p,a) (p)->lpVtbl->GetDeviceInfo(p,a) +#define IDirectInputDevice_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b) +#define IDirectInputDevice_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c) +#else +#define IDirectInputDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectInputDevice_AddRef(p) (p)->AddRef() +#define IDirectInputDevice_Release(p) (p)->Release() +#define IDirectInputDevice_GetCapabilities(p,a) (p)->GetCapabilities(a) +#define IDirectInputDevice_EnumObjects(p,a,b,c) (p)->EnumObjects(a,b,c) +#define IDirectInputDevice_GetProperty(p,a,b) (p)->GetProperty(a,b) +#define IDirectInputDevice_SetProperty(p,a,b) (p)->SetProperty(a,b) +#define IDirectInputDevice_Acquire(p) (p)->Acquire() +#define IDirectInputDevice_Unacquire(p) (p)->Unacquire() +#define IDirectInputDevice_GetDeviceState(p,a,b) (p)->GetDeviceState(a,b) +#define IDirectInputDevice_GetDeviceData(p,a,b,c,d) (p)->GetDeviceData(a,b,c,d) +#define IDirectInputDevice_SetDataFormat(p,a) (p)->SetDataFormat(a) +#define IDirectInputDevice_SetEventNotification(p,a) (p)->SetEventNotification(a) +#define IDirectInputDevice_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b) +#define IDirectInputDevice_GetObjectInfo(p,a,b,c) (p)->GetObjectInfo(a,b,c) +#define IDirectInputDevice_GetDeviceInfo(p,a) (p)->GetDeviceInfo(a) +#define IDirectInputDevice_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b) +#define IDirectInputDevice_Initialize(p,a,b,c) (p)->Initialize(a,b,c) +#endif + +#endif /* DIJ_RINGZERO */ + + +#if(DIRECTINPUT_VERSION >= 0x0500) + +#define DISFFC_RESET 0x00000001 +#define DISFFC_STOPALL 0x00000002 +#define DISFFC_PAUSE 0x00000004 +#define DISFFC_CONTINUE 0x00000008 +#define DISFFC_SETACTUATORSON 0x00000010 +#define DISFFC_SETACTUATORSOFF 0x00000020 + +#define DIGFFS_EMPTY 0x00000001 +#define DIGFFS_STOPPED 0x00000002 +#define DIGFFS_PAUSED 0x00000004 +#define DIGFFS_ACTUATORSON 0x00000010 +#define DIGFFS_ACTUATORSOFF 0x00000020 +#define DIGFFS_POWERON 0x00000040 +#define DIGFFS_POWEROFF 0x00000080 +#define DIGFFS_SAFETYSWITCHON 0x00000100 +#define DIGFFS_SAFETYSWITCHOFF 0x00000200 +#define DIGFFS_USERFFSWITCHON 0x00000400 +#define DIGFFS_USERFFSWITCHOFF 0x00000800 +#define DIGFFS_DEVICELOST 0x80000000 + +#ifndef DIJ_RINGZERO + +typedef struct DIEFFECTINFOA { + DWORD dwSize; + GUID guid; + DWORD dwEffType; + DWORD dwStaticParams; + DWORD dwDynamicParams; + CHAR tszName[MAX_PATH]; +} DIEFFECTINFOA, *LPDIEFFECTINFOA; +typedef struct DIEFFECTINFOW { + DWORD dwSize; + GUID guid; + DWORD dwEffType; + DWORD dwStaticParams; + DWORD dwDynamicParams; + WCHAR tszName[MAX_PATH]; +} DIEFFECTINFOW, *LPDIEFFECTINFOW; +#ifdef UNICODE +typedef DIEFFECTINFOW DIEFFECTINFO; +typedef LPDIEFFECTINFOW LPDIEFFECTINFO; +#else +typedef DIEFFECTINFOA DIEFFECTINFO; +typedef LPDIEFFECTINFOA LPDIEFFECTINFO; +#endif // UNICODE +typedef const DIEFFECTINFOA *LPCDIEFFECTINFOA; +typedef const DIEFFECTINFOW *LPCDIEFFECTINFOW; +typedef const DIEFFECTINFO *LPCDIEFFECTINFO; + +typedef BOOL (FAR PASCAL * LPDIENUMEFFECTSCALLBACKA)(LPCDIEFFECTINFOA, LPVOID); +typedef BOOL (FAR PASCAL * LPDIENUMEFFECTSCALLBACKW)(LPCDIEFFECTINFOW, LPVOID); +#ifdef UNICODE +#define LPDIENUMEFFECTSCALLBACK LPDIENUMEFFECTSCALLBACKW +#else +#define LPDIENUMEFFECTSCALLBACK LPDIENUMEFFECTSCALLBACKA +#endif // !UNICODE +typedef BOOL (FAR PASCAL * LPDIENUMCREATEDEFFECTOBJECTSCALLBACK)(LPDIRECTINPUTEFFECT, LPVOID); + +#undef INTERFACE +#define INTERFACE IDirectInputDevice2W + +DECLARE_INTERFACE_(IDirectInputDevice2W, IDirectInputDeviceW) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputDeviceW methods ***/ + STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE; + STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKW,LPVOID,DWORD) PURE; + STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE; + STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE; + STDMETHOD(Acquire)(THIS) PURE; + STDMETHOD(Unacquire)(THIS) PURE; + STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE; + STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE; + STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE; + STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEW,DWORD,DWORD) PURE; + STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEW) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE; + + /*** IDirectInputDevice2W methods ***/ + STDMETHOD(CreateEffect)(THIS_ REFGUID,LPCDIEFFECT,LPDIRECTINPUTEFFECT *,LPUNKNOWN) PURE; + STDMETHOD(EnumEffects)(THIS_ LPDIENUMEFFECTSCALLBACKW,LPVOID,DWORD) PURE; + STDMETHOD(GetEffectInfo)(THIS_ LPDIEFFECTINFOW,REFGUID) PURE; + STDMETHOD(GetForceFeedbackState)(THIS_ LPDWORD) PURE; + STDMETHOD(SendForceFeedbackCommand)(THIS_ DWORD) PURE; + STDMETHOD(EnumCreatedEffectObjects)(THIS_ LPDIENUMCREATEDEFFECTOBJECTSCALLBACK,LPVOID,DWORD) PURE; + STDMETHOD(Escape)(THIS_ LPDIEFFESCAPE) PURE; + STDMETHOD(Poll)(THIS) PURE; + STDMETHOD(SendDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE; +}; + +typedef struct IDirectInputDevice2W *LPDIRECTINPUTDEVICE2W; + +#undef INTERFACE +#define INTERFACE IDirectInputDevice2A + +DECLARE_INTERFACE_(IDirectInputDevice2A, IDirectInputDeviceA) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputDeviceA methods ***/ + STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE; + STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKA,LPVOID,DWORD) PURE; + STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE; + STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE; + STDMETHOD(Acquire)(THIS) PURE; + STDMETHOD(Unacquire)(THIS) PURE; + STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE; + STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE; + STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE; + STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEA,DWORD,DWORD) PURE; + STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEA) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE; + + /*** IDirectInputDevice2A methods ***/ + STDMETHOD(CreateEffect)(THIS_ REFGUID,LPCDIEFFECT,LPDIRECTINPUTEFFECT *,LPUNKNOWN) PURE; + STDMETHOD(EnumEffects)(THIS_ LPDIENUMEFFECTSCALLBACKA,LPVOID,DWORD) PURE; + STDMETHOD(GetEffectInfo)(THIS_ LPDIEFFECTINFOA,REFGUID) PURE; + STDMETHOD(GetForceFeedbackState)(THIS_ LPDWORD) PURE; + STDMETHOD(SendForceFeedbackCommand)(THIS_ DWORD) PURE; + STDMETHOD(EnumCreatedEffectObjects)(THIS_ LPDIENUMCREATEDEFFECTOBJECTSCALLBACK,LPVOID,DWORD) PURE; + STDMETHOD(Escape)(THIS_ LPDIEFFESCAPE) PURE; + STDMETHOD(Poll)(THIS) PURE; + STDMETHOD(SendDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE; +}; + +typedef struct IDirectInputDevice2A *LPDIRECTINPUTDEVICE2A; + +#ifdef UNICODE +#define IID_IDirectInputDevice2 IID_IDirectInputDevice2W +#define IDirectInputDevice2 IDirectInputDevice2W +#define IDirectInputDevice2Vtbl IDirectInputDevice2WVtbl +#else +#define IID_IDirectInputDevice2 IID_IDirectInputDevice2A +#define IDirectInputDevice2 IDirectInputDevice2A +#define IDirectInputDevice2Vtbl IDirectInputDevice2AVtbl +#endif +typedef struct IDirectInputDevice2 *LPDIRECTINPUTDEVICE2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectInputDevice2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectInputDevice2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectInputDevice2_Release(p) (p)->lpVtbl->Release(p) +#define IDirectInputDevice2_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a) +#define IDirectInputDevice2_EnumObjects(p,a,b,c) (p)->lpVtbl->EnumObjects(p,a,b,c) +#define IDirectInputDevice2_GetProperty(p,a,b) (p)->lpVtbl->GetProperty(p,a,b) +#define IDirectInputDevice2_SetProperty(p,a,b) (p)->lpVtbl->SetProperty(p,a,b) +#define IDirectInputDevice2_Acquire(p) (p)->lpVtbl->Acquire(p) +#define IDirectInputDevice2_Unacquire(p) (p)->lpVtbl->Unacquire(p) +#define IDirectInputDevice2_GetDeviceState(p,a,b) (p)->lpVtbl->GetDeviceState(p,a,b) +#define IDirectInputDevice2_GetDeviceData(p,a,b,c,d) (p)->lpVtbl->GetDeviceData(p,a,b,c,d) +#define IDirectInputDevice2_SetDataFormat(p,a) (p)->lpVtbl->SetDataFormat(p,a) +#define IDirectInputDevice2_SetEventNotification(p,a) (p)->lpVtbl->SetEventNotification(p,a) +#define IDirectInputDevice2_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b) +#define IDirectInputDevice2_GetObjectInfo(p,a,b,c) (p)->lpVtbl->GetObjectInfo(p,a,b,c) +#define IDirectInputDevice2_GetDeviceInfo(p,a) (p)->lpVtbl->GetDeviceInfo(p,a) +#define IDirectInputDevice2_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b) +#define IDirectInputDevice2_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c) +#define IDirectInputDevice2_CreateEffect(p,a,b,c,d) (p)->lpVtbl->CreateEffect(p,a,b,c,d) +#define IDirectInputDevice2_EnumEffects(p,a,b,c) (p)->lpVtbl->EnumEffects(p,a,b,c) +#define IDirectInputDevice2_GetEffectInfo(p,a,b) (p)->lpVtbl->GetEffectInfo(p,a,b) +#define IDirectInputDevice2_GetForceFeedbackState(p,a) (p)->lpVtbl->GetForceFeedbackState(p,a) +#define IDirectInputDevice2_SendForceFeedbackCommand(p,a) (p)->lpVtbl->SendForceFeedbackCommand(p,a) +#define IDirectInputDevice2_EnumCreatedEffectObjects(p,a,b,c) (p)->lpVtbl->EnumCreatedEffectObjects(p,a,b,c) +#define IDirectInputDevice2_Escape(p,a) (p)->lpVtbl->Escape(p,a) +#define IDirectInputDevice2_Poll(p) (p)->lpVtbl->Poll(p) +#define IDirectInputDevice2_SendDeviceData(p,a,b,c,d) (p)->lpVtbl->SendDeviceData(p,a,b,c,d) +#else +#define IDirectInputDevice2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectInputDevice2_AddRef(p) (p)->AddRef() +#define IDirectInputDevice2_Release(p) (p)->Release() +#define IDirectInputDevice2_GetCapabilities(p,a) (p)->GetCapabilities(a) +#define IDirectInputDevice2_EnumObjects(p,a,b,c) (p)->EnumObjects(a,b,c) +#define IDirectInputDevice2_GetProperty(p,a,b) (p)->GetProperty(a,b) +#define IDirectInputDevice2_SetProperty(p,a,b) (p)->SetProperty(a,b) +#define IDirectInputDevice2_Acquire(p) (p)->Acquire() +#define IDirectInputDevice2_Unacquire(p) (p)->Unacquire() +#define IDirectInputDevice2_GetDeviceState(p,a,b) (p)->GetDeviceState(a,b) +#define IDirectInputDevice2_GetDeviceData(p,a,b,c,d) (p)->GetDeviceData(a,b,c,d) +#define IDirectInputDevice2_SetDataFormat(p,a) (p)->SetDataFormat(a) +#define IDirectInputDevice2_SetEventNotification(p,a) (p)->SetEventNotification(a) +#define IDirectInputDevice2_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b) +#define IDirectInputDevice2_GetObjectInfo(p,a,b,c) (p)->GetObjectInfo(a,b,c) +#define IDirectInputDevice2_GetDeviceInfo(p,a) (p)->GetDeviceInfo(a) +#define IDirectInputDevice2_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b) +#define IDirectInputDevice2_Initialize(p,a,b,c) (p)->Initialize(a,b,c) +#define IDirectInputDevice2_CreateEffect(p,a,b,c,d) (p)->CreateEffect(a,b,c,d) +#define IDirectInputDevice2_EnumEffects(p,a,b,c) (p)->EnumEffects(a,b,c) +#define IDirectInputDevice2_GetEffectInfo(p,a,b) (p)->GetEffectInfo(a,b) +#define IDirectInputDevice2_GetForceFeedbackState(p,a) (p)->GetForceFeedbackState(a) +#define IDirectInputDevice2_SendForceFeedbackCommand(p,a) (p)->SendForceFeedbackCommand(a) +#define IDirectInputDevice2_EnumCreatedEffectObjects(p,a,b,c) (p)->EnumCreatedEffectObjects(a,b,c) +#define IDirectInputDevice2_Escape(p,a) (p)->Escape(a) +#define IDirectInputDevice2_Poll(p) (p)->Poll() +#define IDirectInputDevice2_SendDeviceData(p,a,b,c,d) (p)->SendDeviceData(a,b,c,d) +#endif + +#endif /* DIJ_RINGZERO */ + +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +/**************************************************************************** + * + * Mouse + * + ****************************************************************************/ + +#ifndef DIJ_RINGZERO + +typedef struct _DIMOUSESTATE { + LONG lX; + LONG lY; + LONG lZ; + BYTE rgbButtons[4]; +} DIMOUSESTATE, *LPDIMOUSESTATE; + +#define DIMOFS_X FIELD_OFFSET(DIMOUSESTATE, lX) +#define DIMOFS_Y FIELD_OFFSET(DIMOUSESTATE, lY) +#define DIMOFS_Z FIELD_OFFSET(DIMOUSESTATE, lZ) +#define DIMOFS_BUTTON0 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 0) +#define DIMOFS_BUTTON1 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 1) +#define DIMOFS_BUTTON2 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 2) +#define DIMOFS_BUTTON3 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 3) + +#endif /* DIJ_RINGZERO */ + +/**************************************************************************** + * + * Keyboard + * + ****************************************************************************/ + +#ifndef DIJ_RINGZERO + +/**************************************************************************** + * + * DirectInput keyboard scan codes + * + ****************************************************************************/ + +#define DIK_ESCAPE 0x01 +#define DIK_1 0x02 +#define DIK_2 0x03 +#define DIK_3 0x04 +#define DIK_4 0x05 +#define DIK_5 0x06 +#define DIK_6 0x07 +#define DIK_7 0x08 +#define DIK_8 0x09 +#define DIK_9 0x0A +#define DIK_0 0x0B +#define DIK_MINUS 0x0C /* - on main keyboard */ +#define DIK_EQUALS 0x0D +#define DIK_BACK 0x0E /* backspace */ +#define DIK_TAB 0x0F +#define DIK_Q 0x10 +#define DIK_W 0x11 +#define DIK_E 0x12 +#define DIK_R 0x13 +#define DIK_T 0x14 +#define DIK_Y 0x15 +#define DIK_U 0x16 +#define DIK_I 0x17 +#define DIK_O 0x18 +#define DIK_P 0x19 +#define DIK_LBRACKET 0x1A +#define DIK_RBRACKET 0x1B +#define DIK_RETURN 0x1C /* Enter on main keyboard */ +#define DIK_LCONTROL 0x1D +#define DIK_A 0x1E +#define DIK_S 0x1F +#define DIK_D 0x20 +#define DIK_F 0x21 +#define DIK_G 0x22 +#define DIK_H 0x23 +#define DIK_J 0x24 +#define DIK_K 0x25 +#define DIK_L 0x26 +#define DIK_SEMICOLON 0x27 +#define DIK_APOSTROPHE 0x28 +#define DIK_GRAVE 0x29 /* accent grave */ +#define DIK_LSHIFT 0x2A +#define DIK_BACKSLASH 0x2B +#define DIK_Z 0x2C +#define DIK_X 0x2D +#define DIK_C 0x2E +#define DIK_V 0x2F +#define DIK_B 0x30 +#define DIK_N 0x31 +#define DIK_M 0x32 +#define DIK_COMMA 0x33 +#define DIK_PERIOD 0x34 /* . on main keyboard */ +#define DIK_SLASH 0x35 /* / on main keyboard */ +#define DIK_RSHIFT 0x36 +#define DIK_MULTIPLY 0x37 /* * on numeric keypad */ +#define DIK_LMENU 0x38 /* left Alt */ +#define DIK_SPACE 0x39 +#define DIK_CAPITAL 0x3A +#define DIK_F1 0x3B +#define DIK_F2 0x3C +#define DIK_F3 0x3D +#define DIK_F4 0x3E +#define DIK_F5 0x3F +#define DIK_F6 0x40 +#define DIK_F7 0x41 +#define DIK_F8 0x42 +#define DIK_F9 0x43 +#define DIK_F10 0x44 +#define DIK_NUMLOCK 0x45 +#define DIK_SCROLL 0x46 /* Scroll Lock */ +#define DIK_NUMPAD7 0x47 +#define DIK_NUMPAD8 0x48 +#define DIK_NUMPAD9 0x49 +#define DIK_SUBTRACT 0x4A /* - on numeric keypad */ +#define DIK_NUMPAD4 0x4B +#define DIK_NUMPAD5 0x4C +#define DIK_NUMPAD6 0x4D +#define DIK_ADD 0x4E /* + on numeric keypad */ +#define DIK_NUMPAD1 0x4F +#define DIK_NUMPAD2 0x50 +#define DIK_NUMPAD3 0x51 +#define DIK_NUMPAD0 0x52 +#define DIK_DECIMAL 0x53 /* . on numeric keypad */ +#define DIK_F11 0x57 +#define DIK_F12 0x58 + +#define DIK_F13 0x64 /* (NEC PC98) */ +#define DIK_F14 0x65 /* (NEC PC98) */ +#define DIK_F15 0x66 /* (NEC PC98) */ + +#define DIK_KANA 0x70 /* (Japanese keyboard) */ +#define DIK_CONVERT 0x79 /* (Japanese keyboard) */ +#define DIK_NOCONVERT 0x7B /* (Japanese keyboard) */ +#define DIK_YEN 0x7D /* (Japanese keyboard) */ +#define DIK_NUMPADEQUALS 0x8D /* = on numeric keypad (NEC PC98) */ +#define DIK_CIRCUMFLEX 0x90 /* (Japanese keyboard) */ +#define DIK_AT 0x91 /* (NEC PC98) */ +#define DIK_COLON 0x92 /* (NEC PC98) */ +#define DIK_UNDERLINE 0x93 /* (NEC PC98) */ +#define DIK_KANJI 0x94 /* (Japanese keyboard) */ +#define DIK_STOP 0x95 /* (NEC PC98) */ +#define DIK_AX 0x96 /* (Japan AX) */ +#define DIK_UNLABELED 0x97 /* (J3100) */ +#define DIK_NUMPADENTER 0x9C /* Enter on numeric keypad */ +#define DIK_RCONTROL 0x9D +#define DIK_NUMPADCOMMA 0xB3 /* , on numeric keypad (NEC PC98) */ +#define DIK_DIVIDE 0xB5 /* / on numeric keypad */ +#define DIK_SYSRQ 0xB7 +#define DIK_RMENU 0xB8 /* right Alt */ +#define DIK_HOME 0xC7 /* Home on arrow keypad */ +#define DIK_UP 0xC8 /* UpArrow on arrow keypad */ +#define DIK_PRIOR 0xC9 /* PgUp on arrow keypad */ +#define DIK_LEFT 0xCB /* LeftArrow on arrow keypad */ +#define DIK_RIGHT 0xCD /* RightArrow on arrow keypad */ +#define DIK_END 0xCF /* End on arrow keypad */ +#define DIK_DOWN 0xD0 /* DownArrow on arrow keypad */ +#define DIK_NEXT 0xD1 /* PgDn on arrow keypad */ +#define DIK_INSERT 0xD2 /* Insert on arrow keypad */ +#define DIK_DELETE 0xD3 /* Delete on arrow keypad */ +#define DIK_LWIN 0xDB /* Left Windows key */ +#define DIK_RWIN 0xDC /* Right Windows key */ +#define DIK_APPS 0xDD /* AppMenu key */ + +/* + * Alternate names for keys, to facilitate transition from DOS. + */ +#define DIK_BACKSPACE DIK_BACK /* backspace */ +#define DIK_NUMPADSTAR DIK_MULTIPLY /* * on numeric keypad */ +#define DIK_LALT DIK_LMENU /* left Alt */ +#define DIK_CAPSLOCK DIK_CAPITAL /* CapsLock */ +#define DIK_NUMPADMINUS DIK_SUBTRACT /* - on numeric keypad */ +#define DIK_NUMPADPLUS DIK_ADD /* + on numeric keypad */ +#define DIK_NUMPADPERIOD DIK_DECIMAL /* . on numeric keypad */ +#define DIK_NUMPADSLASH DIK_DIVIDE /* / on numeric keypad */ +#define DIK_RALT DIK_RMENU /* right Alt */ +#define DIK_UPARROW DIK_UP /* UpArrow on arrow keypad */ +#define DIK_PGUP DIK_PRIOR /* PgUp on arrow keypad */ +#define DIK_LEFTARROW DIK_LEFT /* LeftArrow on arrow keypad */ +#define DIK_RIGHTARROW DIK_RIGHT /* RightArrow on arrow keypad */ +#define DIK_DOWNARROW DIK_DOWN /* DownArrow on arrow keypad */ +#define DIK_PGDN DIK_NEXT /* PgDn on arrow keypad */ + +#endif /* DIJ_RINGZERO */ + +/**************************************************************************** + * + * Joystick + * + ****************************************************************************/ + +#ifndef DIJ_RINGZERO + +typedef struct DIJOYSTATE { + LONG lX; /* x-axis position */ + LONG lY; /* y-axis position */ + LONG lZ; /* z-axis position */ + LONG lRx; /* x-axis rotation */ + LONG lRy; /* y-axis rotation */ + LONG lRz; /* z-axis rotation */ + LONG rglSlider[2]; /* extra axes positions */ + DWORD rgdwPOV[4]; /* POV directions */ + BYTE rgbButtons[32]; /* 32 buttons */ +} DIJOYSTATE, *LPDIJOYSTATE; + +typedef struct DIJOYSTATE2 { + LONG lX; /* x-axis position */ + LONG lY; /* y-axis position */ + LONG lZ; /* z-axis position */ + LONG lRx; /* x-axis rotation */ + LONG lRy; /* y-axis rotation */ + LONG lRz; /* z-axis rotation */ + LONG rglSlider[2]; /* extra axes positions */ + DWORD rgdwPOV[4]; /* POV directions */ + BYTE rgbButtons[128]; /* 128 buttons */ + LONG lVX; /* x-axis velocity */ + LONG lVY; /* y-axis velocity */ + LONG lVZ; /* z-axis velocity */ + LONG lVRx; /* x-axis angular velocity */ + LONG lVRy; /* y-axis angular velocity */ + LONG lVRz; /* z-axis angular velocity */ + LONG rglVSlider[2]; /* extra axes velocities */ + LONG lAX; /* x-axis acceleration */ + LONG lAY; /* y-axis acceleration */ + LONG lAZ; /* z-axis acceleration */ + LONG lARx; /* x-axis angular acceleration */ + LONG lARy; /* y-axis angular acceleration */ + LONG lARz; /* z-axis angular acceleration */ + LONG rglASlider[2]; /* extra axes accelerations */ + LONG lFX; /* x-axis force */ + LONG lFY; /* y-axis force */ + LONG lFZ; /* z-axis force */ + LONG lFRx; /* x-axis torque */ + LONG lFRy; /* y-axis torque */ + LONG lFRz; /* z-axis torque */ + LONG rglFSlider[2]; /* extra axes forces */ +} DIJOYSTATE2, *LPDIJOYSTATE2; + +#define DIJOFS_X FIELD_OFFSET(DIJOYSTATE, lX) +#define DIJOFS_Y FIELD_OFFSET(DIJOYSTATE, lY) +#define DIJOFS_Z FIELD_OFFSET(DIJOYSTATE, lZ) +#define DIJOFS_RX FIELD_OFFSET(DIJOYSTATE, lRx) +#define DIJOFS_RY FIELD_OFFSET(DIJOYSTATE, lRy) +#define DIJOFS_RZ FIELD_OFFSET(DIJOYSTATE, lRz) +#define DIJOFS_SLIDER(n) (FIELD_OFFSET(DIJOYSTATE, rglSlider) + \ + (n) * sizeof(LONG)) +#define DIJOFS_POV(n) (FIELD_OFFSET(DIJOYSTATE, rgdwPOV) + \ + (n) * sizeof(DWORD)) +#define DIJOFS_BUTTON(n) (FIELD_OFFSET(DIJOYSTATE, rgbButtons) + (n)) +#define DIJOFS_BUTTON0 DIJOFS_BUTTON(0) +#define DIJOFS_BUTTON1 DIJOFS_BUTTON(1) +#define DIJOFS_BUTTON2 DIJOFS_BUTTON(2) +#define DIJOFS_BUTTON3 DIJOFS_BUTTON(3) +#define DIJOFS_BUTTON4 DIJOFS_BUTTON(4) +#define DIJOFS_BUTTON5 DIJOFS_BUTTON(5) +#define DIJOFS_BUTTON6 DIJOFS_BUTTON(6) +#define DIJOFS_BUTTON7 DIJOFS_BUTTON(7) +#define DIJOFS_BUTTON8 DIJOFS_BUTTON(8) +#define DIJOFS_BUTTON9 DIJOFS_BUTTON(9) +#define DIJOFS_BUTTON10 DIJOFS_BUTTON(10) +#define DIJOFS_BUTTON11 DIJOFS_BUTTON(11) +#define DIJOFS_BUTTON12 DIJOFS_BUTTON(12) +#define DIJOFS_BUTTON13 DIJOFS_BUTTON(13) +#define DIJOFS_BUTTON14 DIJOFS_BUTTON(14) +#define DIJOFS_BUTTON15 DIJOFS_BUTTON(15) +#define DIJOFS_BUTTON16 DIJOFS_BUTTON(16) +#define DIJOFS_BUTTON17 DIJOFS_BUTTON(17) +#define DIJOFS_BUTTON18 DIJOFS_BUTTON(18) +#define DIJOFS_BUTTON19 DIJOFS_BUTTON(19) +#define DIJOFS_BUTTON20 DIJOFS_BUTTON(20) +#define DIJOFS_BUTTON21 DIJOFS_BUTTON(21) +#define DIJOFS_BUTTON22 DIJOFS_BUTTON(22) +#define DIJOFS_BUTTON23 DIJOFS_BUTTON(23) +#define DIJOFS_BUTTON24 DIJOFS_BUTTON(24) +#define DIJOFS_BUTTON25 DIJOFS_BUTTON(25) +#define DIJOFS_BUTTON26 DIJOFS_BUTTON(26) +#define DIJOFS_BUTTON27 DIJOFS_BUTTON(27) +#define DIJOFS_BUTTON28 DIJOFS_BUTTON(28) +#define DIJOFS_BUTTON29 DIJOFS_BUTTON(29) +#define DIJOFS_BUTTON30 DIJOFS_BUTTON(30) +#define DIJOFS_BUTTON31 DIJOFS_BUTTON(31) + + +#endif /* DIJ_RINGZERO */ + +/**************************************************************************** + * + * IDirectInput + * + ****************************************************************************/ + +#ifndef DIJ_RINGZERO + +#define DIENUM_STOP 0 +#define DIENUM_CONTINUE 1 + +typedef BOOL (FAR PASCAL * LPDIENUMDEVICESCALLBACKA)(LPCDIDEVICEINSTANCEA, LPVOID); +typedef BOOL (FAR PASCAL * LPDIENUMDEVICESCALLBACKW)(LPCDIDEVICEINSTANCEW, LPVOID); +#ifdef UNICODE +#define LPDIENUMDEVICESCALLBACK LPDIENUMDEVICESCALLBACKW +#else +#define LPDIENUMDEVICESCALLBACK LPDIENUMDEVICESCALLBACKA +#endif // !UNICODE + +#define DIEDFL_ALLDEVICES 0x00000000 +#define DIEDFL_ATTACHEDONLY 0x00000001 +#if(DIRECTINPUT_VERSION >= 0x0500) +#define DIEDFL_FORCEFEEDBACK 0x00000100 +#endif /* DIRECTINPUT_VERSION >= 0x0500 */ + +#undef INTERFACE +#define INTERFACE IDirectInputW + +DECLARE_INTERFACE_(IDirectInputW, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputW methods ***/ + STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEW *,LPUNKNOWN) PURE; + STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKW,LPVOID,DWORD) PURE; + STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE; +}; + +typedef struct IDirectInputW *LPDIRECTINPUTW; + +#undef INTERFACE +#define INTERFACE IDirectInputA + +DECLARE_INTERFACE_(IDirectInputA, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputA methods ***/ + STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEA *,LPUNKNOWN) PURE; + STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKA,LPVOID,DWORD) PURE; + STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE; +}; + +typedef struct IDirectInputA *LPDIRECTINPUTA; + +#ifdef UNICODE +#define IID_IDirectInput IID_IDirectInputW +#define IDirectInput IDirectInputW +#define IDirectInputVtbl IDirectInputWVtbl +#else +#define IID_IDirectInput IID_IDirectInputA +#define IDirectInput IDirectInputA +#define IDirectInputVtbl IDirectInputAVtbl +#endif +typedef struct IDirectInput *LPDIRECTINPUT; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectInput_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectInput_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectInput_Release(p) (p)->lpVtbl->Release(p) +#define IDirectInput_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirectInput_EnumDevices(p,a,b,c,d) (p)->lpVtbl->EnumDevices(p,a,b,c,d) +#define IDirectInput_GetDeviceStatus(p,a) (p)->lpVtbl->GetDeviceStatus(p,a) +#define IDirectInput_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b) +#define IDirectInput_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#else +#define IDirectInput_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectInput_AddRef(p) (p)->AddRef() +#define IDirectInput_Release(p) (p)->Release() +#define IDirectInput_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirectInput_EnumDevices(p,a,b,c,d) (p)->EnumDevices(a,b,c,d) +#define IDirectInput_GetDeviceStatus(p,a) (p)->GetDeviceStatus(a) +#define IDirectInput_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b) +#define IDirectInput_Initialize(p,a,b) (p)->Initialize(a,b) +#endif + +#undef INTERFACE +#define INTERFACE IDirectInput2W + +DECLARE_INTERFACE_(IDirectInput2W, IDirectInputW) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputW methods ***/ + STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEW *,LPUNKNOWN) PURE; + STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKW,LPVOID,DWORD) PURE; + STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE; + + /*** IDirectInput2W methods ***/ + STDMETHOD(FindDevice)(THIS_ REFGUID,LPCWSTR,LPGUID) PURE; +}; + +typedef struct IDirectInput2W *LPDIRECTINPUT2W; + +#undef INTERFACE +#define INTERFACE IDirectInput2A + +DECLARE_INTERFACE_(IDirectInput2A, IDirectInputA) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirectInputA methods ***/ + STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEA *,LPUNKNOWN) PURE; + STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKA,LPVOID,DWORD) PURE; + STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE; + STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE; + STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE; + + /*** IDirectInput2A methods ***/ + STDMETHOD(FindDevice)(THIS_ REFGUID,LPCSTR,LPGUID) PURE; +}; + +typedef struct IDirectInput2A *LPDIRECTINPUT2A; + +#ifdef UNICODE +#define IID_IDirectInput2 IID_IDirectInput2W +#define IDirectInput2 IDirectInput2W +#define IDirectInput2Vtbl IDirectInput2WVtbl +#else +#define IID_IDirectInput2 IID_IDirectInput2A +#define IDirectInput2 IDirectInput2A +#define IDirectInput2Vtbl IDirectInput2AVtbl +#endif +typedef struct IDirectInput2 *LPDIRECTINPUT2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectInput2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectInput2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectInput2_Release(p) (p)->lpVtbl->Release(p) +#define IDirectInput2_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirectInput2_EnumDevices(p,a,b,c,d) (p)->lpVtbl->EnumDevices(p,a,b,c,d) +#define IDirectInput2_GetDeviceStatus(p,a) (p)->lpVtbl->GetDeviceStatus(p,a) +#define IDirectInput2_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b) +#define IDirectInput2_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectInput2_FindDevice(p,a,b,c) (p)->lpVtbl->FindDevice(p,a,b,c) +#else +#define IDirectInput2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectInput2_AddRef(p) (p)->AddRef() +#define IDirectInput2_Release(p) (p)->Release() +#define IDirectInput2_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirectInput2_EnumDevices(p,a,b,c,d) (p)->EnumDevices(a,b,c,d) +#define IDirectInput2_GetDeviceStatus(p,a) (p)->GetDeviceStatus(a) +#define IDirectInput2_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b) +#define IDirectInput2_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectInput2_FindDevice(p,a,b,c) (p)->FindDevice(a,b,c) +#endif + +extern HRESULT WINAPI DirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA *ppDI, LPUNKNOWN punkOuter); +extern HRESULT WINAPI DirectInputCreateW(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTW *ppDI, LPUNKNOWN punkOuter); +#ifdef UNICODE +#define DirectInputCreate DirectInputCreateW +#else +#define DirectInputCreate DirectInputCreateA +#endif // !UNICODE + +#endif /* DIJ_RINGZERO */ + + +/**************************************************************************** + * + * Return Codes + * + ****************************************************************************/ + +/* + * The operation completed successfully. + */ +#define DI_OK S_OK + +/* + * The device exists but is not currently attached. + */ +#define DI_NOTATTACHED S_FALSE + +/* + * The device buffer overflowed. Some input was lost. + */ +#define DI_BUFFEROVERFLOW S_FALSE + +/* + * The change in device properties had no effect. + */ +#define DI_PROPNOEFFECT S_FALSE + +/* + * The operation had no effect. + */ +#define DI_NOEFFECT S_FALSE + +/* + * The device is a polled device. As a result, device buffering + * will not collect any data and event notifications will not be + * signalled until GetDeviceState is called. + */ +#define DI_POLLEDDEVICE ((HRESULT)0x00000002L) + +/* + * The parameters of the effect were successfully updated by + * IDirectInputEffect::SetParameters, but the effect was not + * downloaded because the device is not exclusively acquired + * or because the DIEP_NODOWNLOAD flag was passed. + */ +#define DI_DOWNLOADSKIPPED ((HRESULT)0x00000003L) + +/* + * The parameters of the effect were successfully updated by + * IDirectInputEffect::SetParameters, but in order to change + * the parameters, the effect needed to be restarted. + */ +#define DI_EFFECTRESTARTED ((HRESULT)0x00000004L) + +/* + * The parameters of the effect were successfully updated by + * IDirectInputEffect::SetParameters, but some of them were + * beyond the capabilities of the device and were truncated. + */ +#define DI_TRUNCATED ((HRESULT)0x00000008L) + +/* + * Equal to DI_EFFECTRESTARTED | DI_TRUNCATED. + */ +#define DI_TRUNCATEDANDRESTARTED ((HRESULT)0x0000000CL) + +/* + * The application requires a newer version of DirectInput. + */ +#define DIERR_OLDDIRECTINPUTVERSION \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_OLD_WIN_VERSION) + +/* + * The application was written for an unsupported prerelease version + * of DirectInput. + */ +#define DIERR_BETADIRECTINPUTVERSION \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_RMODE_APP) + +/* + * The object could not be created due to an incompatible driver version + * or mismatched or incomplete driver components. + */ +#define DIERR_BADDRIVERVER \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BAD_DRIVER_LEVEL) + +/* + * The device or device instance or effect is not registered with DirectInput. + */ +#define DIERR_DEVICENOTREG REGDB_E_CLASSNOTREG + +/* + * The requested object does not exist. + */ +#define DIERR_NOTFOUND \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND) + +/* + * The requested object does not exist. + */ +#define DIERR_OBJECTNOTFOUND \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND) + +/* + * An invalid parameter was passed to the returning function, + * or the object was not in a state that admitted the function + * to be called. + */ +#define DIERR_INVALIDPARAM E_INVALIDARG + +/* + * The specified interface is not supported by the object + */ +#define DIERR_NOINTERFACE E_NOINTERFACE + +/* + * An undetermined error occured inside the DInput subsystem + */ +#define DIERR_GENERIC E_FAIL + +/* + * The DInput subsystem couldn't allocate sufficient memory to complete the + * caller's request. + */ +#define DIERR_OUTOFMEMORY E_OUTOFMEMORY + +/* + * The function called is not supported at this time + */ +#define DIERR_UNSUPPORTED E_NOTIMPL + +/* + * This object has not been initialized + */ +#define DIERR_NOTINITIALIZED \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_READY) + +/* + * This object is already initialized + */ +#define DIERR_ALREADYINITIALIZED \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_ALREADY_INITIALIZED) + +/* + * This object does not support aggregation + */ +#define DIERR_NOAGGREGATION CLASS_E_NOAGGREGATION + +/* + * Another app has a higher priority level, preventing this call from + * succeeding. + */ +#define DIERR_OTHERAPPHASPRIO E_ACCESSDENIED + +/* + * Access to the device has been lost. It must be re-acquired. + */ +#define DIERR_INPUTLOST \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_READ_FAULT) + +/* + * The operation cannot be performed while the device is acquired. + */ +#define DIERR_ACQUIRED \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BUSY) + +/* + * The operation cannot be performed unless the device is acquired. + */ +#define DIERR_NOTACQUIRED \ + MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_INVALID_ACCESS) + +/* + * The specified property cannot be changed. + */ +#define DIERR_READONLY E_ACCESSDENIED + +/* + * The device already has an event notification associated with it. + */ +#define DIERR_HANDLEEXISTS E_ACCESSDENIED + +/* + * Data is not yet available. + */ +#ifndef E_PENDING +#define E_PENDING 0x80070007L +#endif + +/* + * Unable to IDirectInputJoyConfig_Acquire because the user + * does not have sufficient privileges to change the joystick + * configuration. + */ +#define DIERR_INSUFFICIENTPRIVS 0x80040200L + +/* + * The device is full. + */ +#define DIERR_DEVICEFULL 0x80040201L + +/* + * Not all the requested information fit into the buffer. + */ +#define DIERR_MOREDATA 0x80040202L + +/* + * The effect is not downloaded. + */ +#define DIERR_NOTDOWNLOADED 0x80040203L + +/* + * The device cannot be reinitialized because there are still effects + * attached to it. + */ +#define DIERR_HASEFFECTS 0x80040204L + +/* + * The operation cannot be performed unless the device is acquired + * in DISCL_EXCLUSIVE mode. + */ +#define DIERR_NOTEXCLUSIVEACQUIRED 0x80040205L + +/* + * The effect could not be downloaded because essential information + * is missing. For example, no axes have been associated with the + * effect, or no type-specific information has been created. + */ +#define DIERR_INCOMPLETEEFFECT 0x80040206L + +/* + * Attempted to read buffered device data from a device that is + * not buffered. + */ +#define DIERR_NOTBUFFERED 0x80040207L + +/* + * An attempt was made to modify parameters of an effect while it is + * playing. Not all hardware devices support altering the parameters + * of an effect while it is playing. + */ +#define DIERR_EFFECTPLAYING 0x80040208L + +#ifdef __cplusplus +}; +#endif + +#endif /* __DINPUT_INCLUDED__ */ + +/**************************************************************************** + * + * Definitions for non-IDirectInput (VJoyD) features defined more recently + * than the current sdk files + * + ****************************************************************************/ + +#ifdef _INC_MMSYSTEM +#ifndef MMNOJOY + +#ifndef __VJOYDX_INCLUDED__ +#define __VJOYDX_INCLUDED__ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Flag to indicate that the dwReserved2 field of the JOYINFOEX structure + * contains mini-driver specific data to be passed by VJoyD to the mini- + * driver instead of doing a poll. + */ +#define JOY_PASSDRIVERDATA 0x10000000l + +/* + * Informs the joystick driver that the configuration has been changed + * and should be reloaded from the registery. + * dwFlags is reserved and should be set to zero + */ +WINMMAPI MMRESULT WINAPI joyConfigChanged( DWORD dwFlags ); + +/* + * Hardware Setting indicating that the device is a headtracker + */ +#define JOY_HWS_ISHEADTRACKER 0x02000000l + +/* + * Hardware Setting indicating that the VxD is used to replace + * the standard analog polling + */ +#define JOY_HWS_ISGAMEPORTDRIVER 0x04000000l + +/* + * Hardware Setting indicating that the driver needs a standard + * gameport in order to communicate with the device. + */ +#define JOY_HWS_ISANALOGPORTDRIVER 0x08000000l + +/* + * Hardware Setting indicating that VJoyD should not load this + * driver, it will be loaded externally and will register with + * VJoyD of it's own accord. + */ +#define JOY_HWS_AUTOLOAD 0x10000000l + +/* + * Hardware Setting indicating that the driver acquires any + * resources needed without needing a devnode through VJoyD. + */ +#define JOY_HWS_NODEVNODE 0x20000000l + +/* + * Hardware Setting indicating that the VxD can be used as + * a port 201h emulator. + */ +#define JOY_HWS_ISGAMEPORTEMULATOR 0x40000000l + + +/* + * Usage Setting indicating that the settings are volatile and + * should be removed if still present on a reboot. + */ +#define JOY_US_VOLATILE 0x00000008L + +#ifdef __cplusplus +}; +#endif + +#endif /* __VJOYDX_INCLUDED__ */ + +#endif /* not MMNOJOY */ +#endif /* _INC_MMSYSTEM */ + +/**************************************************************************** + * + * Definitions for non-IDirectInput (VJoyD) features defined more recently + * than the current ddk files + * + ****************************************************************************/ + +#ifndef DIJ_RINGZERO + +#ifdef _INC_MMDDK +#ifndef MMNOJOYDEV + +#ifndef __VJOYDXD_INCLUDED__ +#define __VJOYDXD_INCLUDED__ +/* + * Poll type in which the do_other field of the JOYOEMPOLLDATA + * structure contains mini-driver specific data passed from an app. + */ +#define JOY_OEMPOLL_PASSDRIVERDATA 7 + +#endif /* __VJOYDXD_INCLUDED__ */ + +#endif /* not MMNOJOYDEV */ +#endif /* _INC_MMDDK */ + +#endif /* DIJ_RINGZERO */ diff --git a/misc/builddeps/dp.win64/include/dsound.h b/misc/builddeps/dp.win64/include/dsound.h new file mode 100644 index 00000000..9f3d66f7 --- /dev/null +++ b/misc/builddeps/dp.win64/include/dsound.h @@ -0,0 +1,863 @@ +/*==========================================================================; + * + * Copyright (C) 1995,1996 Microsoft Corporation. All Rights Reserved. + * + * File: dsound.h + * Content: DirectSound include file + * + **************************************************************************/ + +#ifndef __DSOUND_INCLUDED__ +#define __DSOUND_INCLUDED__ + +#include + +#define COM_NO_WINDOWS_H +#include + +#define _FACDS 0x878 +#define MAKE_DSHRESULT(code) MAKE_HRESULT(1, _FACDS, code) + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +// Direct Sound Component GUID {47D4D946-62E8-11cf-93BC-444553540000} +DEFINE_GUID(CLSID_DirectSound, 0x47d4d946, 0x62e8, 0x11cf, 0x93, 0xbc, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0); + +// DirectSound Capture Component GUID {B0210780-89CD-11d0-AF08-00A0C925CD16} +DEFINE_GUID(CLSID_DirectSoundCapture, 0xb0210780, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); + +// +// Structures +// + +#ifdef __cplusplus +// 'struct' not 'class' per the way DECLARE_INTERFACE_ is defined +struct IDirectSound; +struct IDirectSoundBuffer; +struct IDirectSound3DListener; +struct IDirectSound3DBuffer; +struct IDirectSoundCapture; +struct IDirectSoundCaptureBuffer; +struct IDirectSoundNotify; +#endif // __cplusplus + +typedef struct IDirectSound *LPDIRECTSOUND; +typedef struct IDirectSoundBuffer *LPDIRECTSOUNDBUFFER; +typedef struct IDirectSound3DListener *LPDIRECTSOUND3DLISTENER; +typedef struct IDirectSound3DBuffer *LPDIRECTSOUND3DBUFFER; +typedef struct IDirectSoundCapture *LPDIRECTSOUNDCAPTURE; +typedef struct IDirectSoundCaptureBuffer *LPDIRECTSOUNDCAPTUREBUFFER; +typedef struct IDirectSoundNotify *LPDIRECTSOUNDNOTIFY; + +typedef struct _DSCAPS +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwMinSecondarySampleRate; + DWORD dwMaxSecondarySampleRate; + DWORD dwPrimaryBuffers; + DWORD dwMaxHwMixingAllBuffers; + DWORD dwMaxHwMixingStaticBuffers; + DWORD dwMaxHwMixingStreamingBuffers; + DWORD dwFreeHwMixingAllBuffers; + DWORD dwFreeHwMixingStaticBuffers; + DWORD dwFreeHwMixingStreamingBuffers; + DWORD dwMaxHw3DAllBuffers; + DWORD dwMaxHw3DStaticBuffers; + DWORD dwMaxHw3DStreamingBuffers; + DWORD dwFreeHw3DAllBuffers; + DWORD dwFreeHw3DStaticBuffers; + DWORD dwFreeHw3DStreamingBuffers; + DWORD dwTotalHwMemBytes; + DWORD dwFreeHwMemBytes; + DWORD dwMaxContigFreeHwMemBytes; + DWORD dwUnlockTransferRateHwBuffers; + DWORD dwPlayCpuOverheadSwBuffers; + DWORD dwReserved1; + DWORD dwReserved2; +} DSCAPS, *LPDSCAPS; + +typedef const DSCAPS *LPCDSCAPS; + +typedef struct _DSBCAPS +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwBufferBytes; + DWORD dwUnlockTransferRate; + DWORD dwPlayCpuOverhead; +} DSBCAPS, *LPDSBCAPS; + +typedef const DSBCAPS *LPCDSBCAPS; + +typedef struct _DSBUFFERDESC +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwBufferBytes; + DWORD dwReserved; + LPWAVEFORMATEX lpwfxFormat; +} DSBUFFERDESC, *LPDSBUFFERDESC; + +typedef const DSBUFFERDESC *LPCDSBUFFERDESC; + +typedef struct _DS3DBUFFER +{ + DWORD dwSize; + D3DVECTOR vPosition; + D3DVECTOR vVelocity; + DWORD dwInsideConeAngle; + DWORD dwOutsideConeAngle; + D3DVECTOR vConeOrientation; + LONG lConeOutsideVolume; + D3DVALUE flMinDistance; + D3DVALUE flMaxDistance; + DWORD dwMode; +} DS3DBUFFER, *LPDS3DBUFFER; + +typedef const DS3DBUFFER *LPCDS3DBUFFER; + +typedef struct _DS3DLISTENER +{ + DWORD dwSize; + D3DVECTOR vPosition; + D3DVECTOR vVelocity; + D3DVECTOR vOrientFront; + D3DVECTOR vOrientTop; + D3DVALUE flDistanceFactor; + D3DVALUE flRolloffFactor; + D3DVALUE flDopplerFactor; +} DS3DLISTENER, *LPDS3DLISTENER; + +typedef const DS3DLISTENER *LPCDS3DLISTENER; + +typedef struct _DSCCAPS +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwFormats; + DWORD dwChannels; +} DSCCAPS, *LPDSCCAPS; + +typedef const DSCCAPS *LPCDSCCAPS; + +typedef struct _DSCBUFFERDESC +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwBufferBytes; + DWORD dwReserved; + LPWAVEFORMATEX lpwfxFormat; +} DSCBUFFERDESC, *LPDSCBUFFERDESC; + +typedef const DSCBUFFERDESC *LPCDSCBUFFERDESC; + +typedef struct _DSCBCAPS +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwBufferBytes; + DWORD dwReserved; +} DSCBCAPS, *LPDSCBCAPS; + +typedef const DSCBCAPS *LPCDSCBCAPS; + +typedef struct _DSBPOSITIONNOTIFY +{ + DWORD dwOffset; + HANDLE hEventNotify; +} DSBPOSITIONNOTIFY, *LPDSBPOSITIONNOTIFY; + +typedef const DSBPOSITIONNOTIFY *LPCDSBPOSITIONNOTIFY; + +// +// Compatibility typedefs +// + +typedef LPDIRECTSOUND *LPLPDIRECTSOUND; +typedef LPDIRECTSOUNDBUFFER *LPLPDIRECTSOUNDBUFFER; +typedef LPDIRECTSOUND3DLISTENER *LPLPDIRECTSOUND3DLISTENER; +typedef LPDIRECTSOUND3DBUFFER *LPLPDIRECTSOUND3DBUFFER; +typedef LPDIRECTSOUNDCAPTURE *LPLPDIRECTSOUNDCAPTURE; +typedef LPDIRECTSOUNDCAPTUREBUFFER *LPLPDIRECTSOUNDCAPTUREBUFFER; +typedef LPDIRECTSOUNDNOTIFY *LPLPDIRECTSOUNDNOTIFY; +typedef LPVOID *LPLPVOID; +//typedef const WAVEFORMATEX *LPCWAVEFORMATEX; + +// +// DirectSound API +// + +typedef BOOL (CALLBACK *LPDSENUMCALLBACKW)(LPGUID, LPCWSTR, LPCWSTR, LPVOID); +typedef BOOL (CALLBACK *LPDSENUMCALLBACKA)(LPGUID, LPCSTR, LPCSTR, LPVOID); + +extern HRESULT WINAPI DirectSoundCreate(LPGUID, LPDIRECTSOUND *, LPUNKNOWN); +extern HRESULT WINAPI DirectSoundEnumerateW(LPDSENUMCALLBACKW, LPVOID); +extern HRESULT WINAPI DirectSoundEnumerateA(LPDSENUMCALLBACKA, LPVOID); + +extern HRESULT WINAPI DirectSoundCaptureCreate(LPGUID, LPDIRECTSOUNDCAPTURE *, LPUNKNOWN); +extern HRESULT WINAPI DirectSoundCaptureEnumerateW(LPDSENUMCALLBACKW, LPVOID); +extern HRESULT WINAPI DirectSoundCaptureEnumerateA(LPDSENUMCALLBACKA, LPVOID); + +#ifdef UNICODE +#define LPDSENUMCALLBACK LPDSENUMCALLBACKW +#define DirectSoundEnumerate DirectSoundEnumerateW +#define DirectSoundCaptureEnumerate DirectSoundCaptureEnumerateW +#else // UNICODE +#define LPDSENUMCALLBACK LPDSENUMCALLBACKA +#define DirectSoundEnumerate DirectSoundEnumerateA +#define DirectSoundCaptureEnumerate DirectSoundCaptureEnumerateA +#endif // UNICODE + +// +// IDirectSound +// + +DEFINE_GUID(IID_IDirectSound, 0x279AFA83, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60); + +#undef INTERFACE +#define INTERFACE IDirectSound + +DECLARE_INTERFACE_(IDirectSound, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSound methods + STDMETHOD(CreateSoundBuffer) (THIS_ LPCDSBUFFERDESC, LPDIRECTSOUNDBUFFER *, LPUNKNOWN) PURE; + STDMETHOD(GetCaps) (THIS_ LPDSCAPS) PURE; + STDMETHOD(DuplicateSoundBuffer) (THIS_ LPDIRECTSOUNDBUFFER, LPDIRECTSOUNDBUFFER *) PURE; + STDMETHOD(SetCooperativeLevel) (THIS_ HWND, DWORD) PURE; + STDMETHOD(Compact) (THIS) PURE; + STDMETHOD(GetSpeakerConfig) (THIS_ LPDWORD) PURE; + STDMETHOD(SetSpeakerConfig) (THIS_ DWORD) PURE; + STDMETHOD(Initialize) (THIS_ LPGUID) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSound_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSound_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSound_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSound_CreateSoundBuffer(p,a,b,c) (p)->lpVtbl->CreateSoundBuffer(p,a,b,c) +#define IDirectSound_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a) +#define IDirectSound_DuplicateSoundBuffer(p,a,b) (p)->lpVtbl->DuplicateSoundBuffer(p,a,b) +#define IDirectSound_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b) +#define IDirectSound_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectSound_GetSpeakerConfig(p,a) (p)->lpVtbl->GetSpeakerConfig(p,a) +#define IDirectSound_SetSpeakerConfig(p,b) (p)->lpVtbl->SetSpeakerConfig(p,b) +#define IDirectSound_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSound_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSound_AddRef(p) (p)->AddRef() +#define IDirectSound_Release(p) (p)->Release() +#define IDirectSound_CreateSoundBuffer(p,a,b,c) (p)->CreateSoundBuffer(a,b,c) +#define IDirectSound_GetCaps(p,a) (p)->GetCaps(a) +#define IDirectSound_DuplicateSoundBuffer(p,a,b) (p)->DuplicateSoundBuffer(a,b) +#define IDirectSound_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b) +#define IDirectSound_Compact(p) (p)->Compact() +#define IDirectSound_GetSpeakerConfig(p,a) (p)->GetSpeakerConfig(a) +#define IDirectSound_SetSpeakerConfig(p,b) (p)->SetSpeakerConfig(b) +#define IDirectSound_Initialize(p,a) (p)->Initialize(a) +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IDirectSoundBuffer +// + +DEFINE_GUID(IID_IDirectSoundBuffer, 0x279AFA85, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60); + +#undef INTERFACE +#define INTERFACE IDirectSoundBuffer + +DECLARE_INTERFACE_(IDirectSoundBuffer, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSoundBuffer methods + STDMETHOD(GetCaps) (THIS_ LPDSBCAPS) PURE; + STDMETHOD(GetCurrentPosition) (THIS_ LPDWORD, LPDWORD) PURE; + STDMETHOD(GetFormat) (THIS_ LPWAVEFORMATEX, DWORD, LPDWORD) PURE; + STDMETHOD(GetVolume) (THIS_ LPLONG) PURE; + STDMETHOD(GetPan) (THIS_ LPLONG) PURE; + STDMETHOD(GetFrequency) (THIS_ LPDWORD) PURE; + STDMETHOD(GetStatus) (THIS_ LPDWORD) PURE; + STDMETHOD(Initialize) (THIS_ LPDIRECTSOUND, LPCDSBUFFERDESC) PURE; + STDMETHOD(Lock) (THIS_ DWORD, DWORD, LPVOID *, LPDWORD, LPVOID *, LPDWORD, DWORD) PURE; + STDMETHOD(Play) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD(SetCurrentPosition) (THIS_ DWORD) PURE; + STDMETHOD(SetFormat) (THIS_ LPCWAVEFORMATEX) PURE; + STDMETHOD(SetVolume) (THIS_ LONG) PURE; + STDMETHOD(SetPan) (THIS_ LONG) PURE; + STDMETHOD(SetFrequency) (THIS_ DWORD) PURE; + STDMETHOD(Stop) (THIS) PURE; + STDMETHOD(Unlock) (THIS_ LPVOID, DWORD, LPVOID, DWORD) PURE; + STDMETHOD(Restore) (THIS) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSoundBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSoundBuffer_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSoundBuffer_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a) +#define IDirectSoundBuffer_GetCurrentPosition(p,a,b) (p)->lpVtbl->GetCurrentPosition(p,a,b) +#define IDirectSoundBuffer_GetFormat(p,a,b,c) (p)->lpVtbl->GetFormat(p,a,b,c) +#define IDirectSoundBuffer_GetVolume(p,a) (p)->lpVtbl->GetVolume(p,a) +#define IDirectSoundBuffer_GetPan(p,a) (p)->lpVtbl->GetPan(p,a) +#define IDirectSoundBuffer_GetFrequency(p,a) (p)->lpVtbl->GetFrequency(p,a) +#define IDirectSoundBuffer_GetStatus(p,a) (p)->lpVtbl->GetStatus(p,a) +#define IDirectSoundBuffer_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectSoundBuffer_Lock(p,a,b,c,d,e,f,g) (p)->lpVtbl->Lock(p,a,b,c,d,e,f,g) +#define IDirectSoundBuffer_Play(p,a,b,c) (p)->lpVtbl->Play(p,a,b,c) +#define IDirectSoundBuffer_SetCurrentPosition(p,a) (p)->lpVtbl->SetCurrentPosition(p,a) +#define IDirectSoundBuffer_SetFormat(p,a) (p)->lpVtbl->SetFormat(p,a) +#define IDirectSoundBuffer_SetVolume(p,a) (p)->lpVtbl->SetVolume(p,a) +#define IDirectSoundBuffer_SetPan(p,a) (p)->lpVtbl->SetPan(p,a) +#define IDirectSoundBuffer_SetFrequency(p,a) (p)->lpVtbl->SetFrequency(p,a) +#define IDirectSoundBuffer_Stop(p) (p)->lpVtbl->Stop(p) +#define IDirectSoundBuffer_Unlock(p,a,b,c,d) (p)->lpVtbl->Unlock(p,a,b,c,d) +#define IDirectSoundBuffer_Restore(p) (p)->lpVtbl->Restore(p) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSoundBuffer_AddRef(p) (p)->AddRef() +#define IDirectSoundBuffer_Release(p) (p)->Release() +#define IDirectSoundBuffer_GetCaps(p,a) (p)->GetCaps(a) +#define IDirectSoundBuffer_GetCurrentPosition(p,a,b) (p)->GetCurrentPosition(a,b) +#define IDirectSoundBuffer_GetFormat(p,a,b,c) (p)->GetFormat(a,b,c) +#define IDirectSoundBuffer_GetVolume(p,a) (p)->GetVolume(a) +#define IDirectSoundBuffer_GetPan(p,a) (p)->GetPan(a) +#define IDirectSoundBuffer_GetFrequency(p,a) (p)->GetFrequency(a) +#define IDirectSoundBuffer_GetStatus(p,a) (p)->GetStatus(a) +#define IDirectSoundBuffer_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectSoundBuffer_Lock(p,a,b,c,d,e,f,g) (p)->Lock(a,b,c,d,e,f,g) +#define IDirectSoundBuffer_Play(p,a,b,c) (p)->Play(a,b,c) +#define IDirectSoundBuffer_SetCurrentPosition(p,a) (p)->SetCurrentPosition(a) +#define IDirectSoundBuffer_SetFormat(p,a) (p)->SetFormat(a) +#define IDirectSoundBuffer_SetVolume(p,a) (p)->SetVolume(a) +#define IDirectSoundBuffer_SetPan(p,a) (p)->SetPan(a) +#define IDirectSoundBuffer_SetFrequency(p,a) (p)->SetFrequency(a) +#define IDirectSoundBuffer_Stop(p) (p)->Stop() +#define IDirectSoundBuffer_Unlock(p,a,b,c,d) (p)->Unlock(a,b,c,d) +#define IDirectSoundBuffer_Restore(p) (p)->Restore() +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IDirectSound3DListener +// + +DEFINE_GUID(IID_IDirectSound3DListener, 0x279AFA84, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60); + +#undef INTERFACE +#define INTERFACE IDirectSound3DListener + +DECLARE_INTERFACE_(IDirectSound3DListener, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSound3D methods + STDMETHOD(GetAllParameters) (THIS_ LPDS3DLISTENER) PURE; + STDMETHOD(GetDistanceFactor) (THIS_ LPD3DVALUE) PURE; + STDMETHOD(GetDopplerFactor) (THIS_ LPD3DVALUE) PURE; + STDMETHOD(GetOrientation) (THIS_ LPD3DVECTOR, LPD3DVECTOR) PURE; + STDMETHOD(GetPosition) (THIS_ LPD3DVECTOR) PURE; + STDMETHOD(GetRolloffFactor) (THIS_ LPD3DVALUE) PURE; + STDMETHOD(GetVelocity) (THIS_ LPD3DVECTOR) PURE; + STDMETHOD(SetAllParameters) (THIS_ LPCDS3DLISTENER, DWORD) PURE; + STDMETHOD(SetDistanceFactor) (THIS_ D3DVALUE, DWORD) PURE; + STDMETHOD(SetDopplerFactor) (THIS_ D3DVALUE, DWORD) PURE; + STDMETHOD(SetOrientation) (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE; + STDMETHOD(SetPosition) (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE; + STDMETHOD(SetRolloffFactor) (THIS_ D3DVALUE, DWORD) PURE; + STDMETHOD(SetVelocity) (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE; + STDMETHOD(CommitDeferredSettings) (THIS) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSound3DListener_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSound3DListener_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSound3DListener_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSound3DListener_GetAllParameters(p,a) (p)->lpVtbl->GetAllParameters(p,a) +#define IDirectSound3DListener_GetDistanceFactor(p,a) (p)->lpVtbl->GetDistanceFactor(p,a) +#define IDirectSound3DListener_GetDopplerFactor(p,a) (p)->lpVtbl->GetDopplerFactor(p,a) +#define IDirectSound3DListener_GetOrientation(p,a,b) (p)->lpVtbl->GetOrientation(p,a,b) +#define IDirectSound3DListener_GetPosition(p,a) (p)->lpVtbl->GetPosition(p,a) +#define IDirectSound3DListener_GetRolloffFactor(p,a) (p)->lpVtbl->GetRolloffFactor(p,a) +#define IDirectSound3DListener_GetVelocity(p,a) (p)->lpVtbl->GetVelocity(p,a) +#define IDirectSound3DListener_SetAllParameters(p,a,b) (p)->lpVtbl->SetAllParameters(p,a,b) +#define IDirectSound3DListener_SetDistanceFactor(p,a,b) (p)->lpVtbl->SetDistanceFactor(p,a,b) +#define IDirectSound3DListener_SetDopplerFactor(p,a,b) (p)->lpVtbl->SetDopplerFactor(p,a,b) +#define IDirectSound3DListener_SetOrientation(p,a,b,c,d,e,f,g) (p)->lpVtbl->SetOrientation(p,a,b,c,d,e,f,g) +#define IDirectSound3DListener_SetPosition(p,a,b,c,d) (p)->lpVtbl->SetPosition(p,a,b,c,d) +#define IDirectSound3DListener_SetRolloffFactor(p,a,b) (p)->lpVtbl->SetRolloffFactor(p,a,b) +#define IDirectSound3DListener_SetVelocity(p,a,b,c,d) (p)->lpVtbl->SetVelocity(p,a,b,c,d) +#define IDirectSound3DListener_CommitDeferredSettings(p) (p)->lpVtbl->CommitDeferredSettings(p) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSound3DListener_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSound3DListener_AddRef(p) (p)->AddRef() +#define IDirectSound3DListener_Release(p) (p)->Release() +#define IDirectSound3DListener_GetAllParameters(p,a) (p)->GetAllParameters(a) +#define IDirectSound3DListener_GetDistanceFactor(p,a) (p)->GetDistanceFactor(a) +#define IDirectSound3DListener_GetDopplerFactor(p,a) (p)->GetDopplerFactor(a) +#define IDirectSound3DListener_GetOrientation(p,a,b) (p)->GetOrientation(a,b) +#define IDirectSound3DListener_GetPosition(p,a) (p)->GetPosition(a) +#define IDirectSound3DListener_GetRolloffFactor(p,a) (p)->GetRolloffFactor(a) +#define IDirectSound3DListener_GetVelocity(p,a) (p)->GetVelocity(a) +#define IDirectSound3DListener_SetAllParameters(p,a,b) (p)->SetAllParameters(a,b) +#define IDirectSound3DListener_SetDistanceFactor(p,a,b) (p)->SetDistanceFactor(a,b) +#define IDirectSound3DListener_SetDopplerFactor(p,a,b) (p)->SetDopplerFactor(a,b) +#define IDirectSound3DListener_SetOrientation(p,a,b,c,d,e,f,g) (p)->SetOrientation(a,b,c,d,e,f,g) +#define IDirectSound3DListener_SetPosition(p,a,b,c,d) (p)->SetPosition(a,b,c,d) +#define IDirectSound3DListener_SetRolloffFactor(p,a,b) (p)->SetRolloffFactor(a,b) +#define IDirectSound3DListener_SetVelocity(p,a,b,c,d) (p)->SetVelocity(a,b,c,d) +#define IDirectSound3DListener_CommitDeferredSettings(p) (p)->CommitDeferredSettings() +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IDirectSound3DBuffer +// + +DEFINE_GUID(IID_IDirectSound3DBuffer, 0x279AFA86, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60); + +#undef INTERFACE +#define INTERFACE IDirectSound3DBuffer + +DECLARE_INTERFACE_(IDirectSound3DBuffer, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSoundBuffer3D methods + STDMETHOD(GetAllParameters) (THIS_ LPDS3DBUFFER) PURE; + STDMETHOD(GetConeAngles) (THIS_ LPDWORD, LPDWORD) PURE; + STDMETHOD(GetConeOrientation) (THIS_ LPD3DVECTOR) PURE; + STDMETHOD(GetConeOutsideVolume) (THIS_ LPLONG) PURE; + STDMETHOD(GetMaxDistance) (THIS_ LPD3DVALUE) PURE; + STDMETHOD(GetMinDistance) (THIS_ LPD3DVALUE) PURE; + STDMETHOD(GetMode) (THIS_ LPDWORD) PURE; + STDMETHOD(GetPosition) (THIS_ LPD3DVECTOR) PURE; + STDMETHOD(GetVelocity) (THIS_ LPD3DVECTOR) PURE; + STDMETHOD(SetAllParameters) (THIS_ LPCDS3DBUFFER, DWORD) PURE; + STDMETHOD(SetConeAngles) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD(SetConeOrientation) (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE; + STDMETHOD(SetConeOutsideVolume) (THIS_ LONG, DWORD) PURE; + STDMETHOD(SetMaxDistance) (THIS_ D3DVALUE, DWORD) PURE; + STDMETHOD(SetMinDistance) (THIS_ D3DVALUE, DWORD) PURE; + STDMETHOD(SetMode) (THIS_ DWORD, DWORD) PURE; + STDMETHOD(SetPosition) (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE; + STDMETHOD(SetVelocity) (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSound3DBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSound3DBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSound3DBuffer_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSound3DBuffer_GetAllParameters(p,a) (p)->lpVtbl->GetAllParameters(p,a) +#define IDirectSound3DBuffer_GetConeAngles(p,a,b) (p)->lpVtbl->GetConeAngles(p,a,b) +#define IDirectSound3DBuffer_GetConeOrientation(p,a) (p)->lpVtbl->GetConeOrientation(p,a) +#define IDirectSound3DBuffer_GetConeOutsideVolume(p,a) (p)->lpVtbl->GetConeOutsideVolume(p,a) +#define IDirectSound3DBuffer_GetPosition(p,a) (p)->lpVtbl->GetPosition(p,a) +#define IDirectSound3DBuffer_GetMinDistance(p,a) (p)->lpVtbl->GetMinDistance(p,a) +#define IDirectSound3DBuffer_GetMaxDistance(p,a) (p)->lpVtbl->GetMaxDistance(p,a) +#define IDirectSound3DBuffer_GetMode(p,a) (p)->lpVtbl->GetMode(p,a) +#define IDirectSound3DBuffer_GetVelocity(p,a) (p)->lpVtbl->GetVelocity(p,a) +#define IDirectSound3DBuffer_SetAllParameters(p,a,b) (p)->lpVtbl->SetAllParameters(p,a,b) +#define IDirectSound3DBuffer_SetConeAngles(p,a,b,c) (p)->lpVtbl->SetConeAngles(p,a,b,c) +#define IDirectSound3DBuffer_SetConeOrientation(p,a,b,c,d) (p)->lpVtbl->SetConeOrientation(p,a,b,c,d) +#define IDirectSound3DBuffer_SetConeOutsideVolume(p,a,b)(p)->lpVtbl->SetConeOutsideVolume(p,a,b) +#define IDirectSound3DBuffer_SetPosition(p,a,b,c,d) (p)->lpVtbl->SetPosition(p,a,b,c,d) +#define IDirectSound3DBuffer_SetMinDistance(p,a,b) (p)->lpVtbl->SetMinDistance(p,a,b) +#define IDirectSound3DBuffer_SetMaxDistance(p,a,b) (p)->lpVtbl->SetMaxDistance(p,a,b) +#define IDirectSound3DBuffer_SetMode(p,a,b) (p)->lpVtbl->SetMode(p,a,b) +#define IDirectSound3DBuffer_SetVelocity(p,a,b,c,d) (p)->lpVtbl->SetVelocity(p,a,b,c,d) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSound3DBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSound3DBuffer_AddRef(p) (p)->AddRef() +#define IDirectSound3DBuffer_Release(p) (p)->Release() +#define IDirectSound3DBuffer_GetAllParameters(p,a) (p)->GetAllParameters(a) +#define IDirectSound3DBuffer_GetConeAngles(p,a,b) (p)->GetConeAngles(a,b) +#define IDirectSound3DBuffer_GetConeOrientation(p,a) (p)->GetConeOrientation(a) +#define IDirectSound3DBuffer_GetConeOutsideVolume(p,a) (p)->GetConeOutsideVolume(a) +#define IDirectSound3DBuffer_GetPosition(p,a) (p)->GetPosition(a) +#define IDirectSound3DBuffer_GetMinDistance(p,a) (p)->GetMinDistance(a) +#define IDirectSound3DBuffer_GetMaxDistance(p,a) (p)->GetMaxDistance(a) +#define IDirectSound3DBuffer_GetMode(p,a) (p)->GetMode(a) +#define IDirectSound3DBuffer_GetVelocity(p,a) (p)->GetVelocity(a) +#define IDirectSound3DBuffer_SetAllParameters(p,a,b) (p)->SetAllParameters(a,b) +#define IDirectSound3DBuffer_SetConeAngles(p,a,b,c) (p)->SetConeAngles(a,b,c) +#define IDirectSound3DBuffer_SetConeOrientation(p,a,b,c,d) (p)->SetConeOrientation(a,b,c,d) +#define IDirectSound3DBuffer_SetConeOutsideVolume(p,a,b)(p)->SetConeOutsideVolume(a,b) +#define IDirectSound3DBuffer_SetPosition(p,a,b,c,d) (p)->SetPosition(a,b,c,d) +#define IDirectSound3DBuffer_SetMinDistance(p,a,b) (p)->SetMinDistance(a,b) +#define IDirectSound3DBuffer_SetMaxDistance(p,a,b) (p)->SetMaxDistance(a,b) +#define IDirectSound3DBuffer_SetMode(p,a,b) (p)->SetMode(a,b) +#define IDirectSound3DBuffer_SetVelocity(p,a,b,c,d) (p)->SetVelocity(a,b,c,d) +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IDirectSoundCapture +// + +DEFINE_GUID(IID_IDirectSoundCapture, 0xb0210781, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); + +#undef INTERFACE +#define INTERFACE IDirectSoundCapture + +DECLARE_INTERFACE_(IDirectSoundCapture, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSoundCapture methods + STDMETHOD(CreateCaptureBuffer) (THIS_ LPCDSCBUFFERDESC, LPDIRECTSOUNDCAPTUREBUFFER *, LPUNKNOWN) PURE; + STDMETHOD(GetCaps) (THIS_ LPDSCCAPS ) PURE; + STDMETHOD(Initialize) (THIS_ LPGUID) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundCapture_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSoundCapture_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSoundCapture_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSoundCapture_CreateCaptureBuffer(p,a,b,c) (p)->lpVtbl->CreateCaptureBuffer(p,a,b,c) +#define IDirectSoundCapture_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a) +#define IDirectSoundCapture_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundCapture_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSoundCapture_AddRef(p) (p)->AddRef() +#define IDirectSoundCapture_Release(p) (p)->Release() +#define IDirectSoundCapture_CreateCaptureBuffer(p,a,b,c) (p)->CreateCaptureBuffer(a,b,c) +#define IDirectSoundCapture_GetCaps(p,a) (p)->GetCaps(a) +#define IDirectSoundCapture_Initialize(p,a) (p)->Initialize(a) +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IDirectSoundCaptureBuffer +// + +DEFINE_GUID(IID_IDirectSoundCaptureBuffer, 0xb0210782, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); + +#undef INTERFACE +#define INTERFACE IDirectSoundCaptureBuffer + +DECLARE_INTERFACE_(IDirectSoundCaptureBuffer, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSoundCaptureBuffer methods + STDMETHOD(GetCaps) (THIS_ LPDSCBCAPS ) PURE; + STDMETHOD(GetCurrentPosition) (THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetFormat) (THIS_ LPWAVEFORMATEX, DWORD, LPDWORD ) PURE; + STDMETHOD(GetStatus) (THIS_ LPDWORD ) PURE; + STDMETHOD(Initialize) (THIS_ LPDIRECTSOUNDCAPTURE, LPCDSCBUFFERDESC) PURE; + STDMETHOD(Lock) (THIS_ DWORD, DWORD, LPVOID *, LPDWORD, LPVOID *, LPDWORD, DWORD) PURE; + STDMETHOD(Start) (THIS_ DWORD) PURE; + STDMETHOD(Stop) (THIS) PURE; + STDMETHOD(Unlock) (THIS_ LPVOID, DWORD, LPVOID, DWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundCaptureBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSoundCaptureBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSoundCaptureBuffer_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSoundCaptureBuffer_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a) +#define IDirectSoundCaptureBuffer_GetCurrentPosition(p,a,b) (p)->lpVtbl->GetCurrentPosition(p,a,b) +#define IDirectSoundCaptureBuffer_GetFormat(p,a,b,c) (p)->lpVtbl->GetFormat(p,a,b,c) +#define IDirectSoundCaptureBuffer_GetStatus(p,a) (p)->lpVtbl->GetStatus(p,a) +#define IDirectSoundCaptureBuffer_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectSoundCaptureBuffer_Lock(p,a,b,c,d,e,f,g) (p)->lpVtbl->Lock(p,a,b,c,d,e,f,g) +#define IDirectSoundCaptureBuffer_Start(p,a) (p)->lpVtbl->Start(p,a) +#define IDirectSoundCaptureBuffer_Stop(p) (p)->lpVtbl->Stop(p) +#define IDirectSoundCaptureBuffer_Unlock(p,a,b,c,d) (p)->lpVtbl->Unlock(p,a,b,c,d) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundCaptureBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSoundCaptureBuffer_AddRef(p) (p)->AddRef() +#define IDirectSoundCaptureBuffer_Release(p) (p)->Release() +#define IDirectSoundCaptureBuffer_GetCaps(p,a) (p)->GetCaps(a) +#define IDirectSoundCaptureBuffer_GetCurrentPosition(p,a,b) (p)->GetCurrentPosition(a,b) +#define IDirectSoundCaptureBuffer_GetFormat(p,a,b,c) (p)->GetFormat(a,b,c) +#define IDirectSoundCaptureBuffer_GetStatus(p,a) (p)->GetStatus(a) +#define IDirectSoundCaptureBuffer_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectSoundCaptureBuffer_Lock(p,a,b,c,d,e,f,g) (p)->Lock(a,b,c,d,e,f,g) +#define IDirectSoundCaptureBuffer_Start(p,a) (p)->Start(a) +#define IDirectSoundCaptureBuffer_Stop(p) (p)->Stop() +#define IDirectSoundCaptureBuffer_Unlock(p,a,b,c,d) (p)->Unlock(a,b,c,d) +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IDirectSoundNotify +// + +DEFINE_GUID(IID_IDirectSoundNotify, 0xb0210783, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); + +#undef INTERFACE +#define INTERFACE IDirectSoundNotify + +DECLARE_INTERFACE_(IDirectSoundNotify, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSoundNotify methods + STDMETHOD(SetNotificationPositions) (THIS_ DWORD, LPCDSBPOSITIONNOTIFY) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundNotify_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectSoundNotify_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectSoundNotify_Release(p) (p)->lpVtbl->Release(p) +#define IDirectSoundNotify_SetNotificationPositions(p,a,b) (p)->lpVtbl->SetNotificationPositions(p,a,b) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectSoundNotify_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectSoundNotify_AddRef(p) (p)->AddRef() +#define IDirectSoundNotify_Release(p) (p)->Release() +#define IDirectSoundNotify_SetNotificationPositions(p,a,b) (p)->SetNotificationPositions(a,b) +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +// +// IKsPropertySet +// + +#ifndef _IKsPropertySet_ +#define _IKsPropertySet_ + +#ifdef __cplusplus +// 'struct' not 'class' per the way DECLARE_INTERFACE_ is defined +struct IKsPropertySet; +#endif // __cplusplus + +typedef struct IKsPropertySet *LPKSPROPERTYSET; + +#define KSPROPERTY_SUPPORT_GET 0x00000001 +#define KSPROPERTY_SUPPORT_SET 0x00000002 + +DEFINE_GUID(IID_IKsPropertySet, 0x31efac30, 0x515c, 0x11d0, 0xa9, 0xaa, 0x00, 0xaa, 0x00, 0x61, 0xbe, 0x93); + +#undef INTERFACE +#define INTERFACE IKsPropertySet + +DECLARE_INTERFACE_(IKsPropertySet, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IKsPropertySet methods + STDMETHOD(Get) (THIS_ REFGUID, ULONG, LPVOID, ULONG, LPVOID, ULONG, PULONG) PURE; + STDMETHOD(Set) (THIS_ REFGUID, ULONG, LPVOID, ULONG, LPVOID, ULONG) PURE; + STDMETHOD(QuerySupport) (THIS_ REFGUID, ULONG, PULONG) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IKsPropertySet_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IKsPropertySet_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IKsPropertySet_Release(p) (p)->lpVtbl->Release(p) +#define IKsPropertySet_Get(p,a,b,c,d,e,f,g) (p)->lpVtbl->Get(p,a,b,c,d,e,f,g) +#define IKsPropertySet_Set(p,a,b,c,d,e,f) (p)->lpVtbl->Set(p,a,b,c,d,e,f) +#define IKsPropertySet_QuerySupport(p,a,b,c) (p)->lpVtbl->QuerySupport(p,a,b,c) +#else // !defined(__cplusplus) || defined(CINTERFACE) +#define IKsPropertySet_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IKsPropertySet_AddRef(p) (p)->AddRef() +#define IKsPropertySet_Release(p) (p)->Release() +#define IKsPropertySet_Get(p,a,b,c,d,e,f,g) (p)->Get(a,b,c,d,e,f,g) +#define IKsPropertySet_Set(p,a,b,c,d,e,f) (p)->Set(a,b,c,d,e,f) +#define IKsPropertySet_QuerySupport(p,a,b,c) (p)->QuerySupport(a,b,c) +#endif // !defined(__cplusplus) || defined(CINTERFACE) + +#endif // _IKsPropertySet_ + +// +// Return Codes +// + +#define DS_OK 0 + +// The call failed because resources (such as a priority level) +// were already being used by another caller. +#define DSERR_ALLOCATED MAKE_DSHRESULT(10) + +// The control (vol,pan,etc.) requested by the caller is not available. +#define DSERR_CONTROLUNAVAIL MAKE_DSHRESULT(30) + +// An invalid parameter was passed to the returning function +#define DSERR_INVALIDPARAM E_INVALIDARG + +// This call is not valid for the current state of this object +#define DSERR_INVALIDCALL MAKE_DSHRESULT(50) + +// An undetermined error occured inside the DirectSound subsystem +#define DSERR_GENERIC E_FAIL + +// The caller does not have the priority level required for the function to +// succeed. +#define DSERR_PRIOLEVELNEEDED MAKE_DSHRESULT(70) + +// Not enough free memory is available to complete the operation +#define DSERR_OUTOFMEMORY E_OUTOFMEMORY + +// The specified WAVE format is not supported +#define DSERR_BADFORMAT MAKE_DSHRESULT(100) + +// The function called is not supported at this time +#define DSERR_UNSUPPORTED E_NOTIMPL + +// No sound driver is available for use +#define DSERR_NODRIVER MAKE_DSHRESULT(120) + +// This object is already initialized +#define DSERR_ALREADYINITIALIZED MAKE_DSHRESULT(130) + +// This object does not support aggregation +#define DSERR_NOAGGREGATION CLASS_E_NOAGGREGATION + +// The buffer memory has been lost, and must be restored. +#define DSERR_BUFFERLOST MAKE_DSHRESULT(150) + +// Another app has a higher priority level, preventing this call from +// succeeding. +#define DSERR_OTHERAPPHASPRIO MAKE_DSHRESULT(160) + +// This object has not been initialized +#define DSERR_UNINITIALIZED MAKE_DSHRESULT(170) + +// The requested COM interface is not available +#define DSERR_NOINTERFACE E_NOINTERFACE + +// +// Flags +// + +#define DSCAPS_PRIMARYMONO 0x00000001 +#define DSCAPS_PRIMARYSTEREO 0x00000002 +#define DSCAPS_PRIMARY8BIT 0x00000004 +#define DSCAPS_PRIMARY16BIT 0x00000008 +#define DSCAPS_CONTINUOUSRATE 0x00000010 +#define DSCAPS_EMULDRIVER 0x00000020 +#define DSCAPS_CERTIFIED 0x00000040 +#define DSCAPS_SECONDARYMONO 0x00000100 +#define DSCAPS_SECONDARYSTEREO 0x00000200 +#define DSCAPS_SECONDARY8BIT 0x00000400 +#define DSCAPS_SECONDARY16BIT 0x00000800 + +#define DSBPLAY_LOOPING 0x00000001 + +#define DSBSTATUS_PLAYING 0x00000001 +#define DSBSTATUS_BUFFERLOST 0x00000002 +#define DSBSTATUS_LOOPING 0x00000004 + +#define DSBLOCK_FROMWRITECURSOR 0x00000001 +#define DSBLOCK_ENTIREBUFFER 0x00000002 + +#define DSSCL_NORMAL 0x00000001 +#define DSSCL_PRIORITY 0x00000002 +#define DSSCL_EXCLUSIVE 0x00000003 +#define DSSCL_WRITEPRIMARY 0x00000004 + +#define DS3DMODE_NORMAL 0x00000000 +#define DS3DMODE_HEADRELATIVE 0x00000001 +#define DS3DMODE_DISABLE 0x00000002 + +#define DS3D_IMMEDIATE 0x00000000 +#define DS3D_DEFERRED 0x00000001 + +#define DS3D_MINDISTANCEFACTOR 0.0f +#define DS3D_MAXDISTANCEFACTOR 10.0f +#define DS3D_DEFAULTDISTANCEFACTOR 1.0f + +#define DS3D_MINROLLOFFFACTOR 0.0f +#define DS3D_MAXROLLOFFFACTOR 10.0f +#define DS3D_DEFAULTROLLOFFFACTOR 1.0f + +#define DS3D_MINDOPPLERFACTOR 0.0f +#define DS3D_MAXDOPPLERFACTOR 10.0f +#define DS3D_DEFAULTDOPPLERFACTOR 1.0f + +#define DS3D_DEFAULTMINDISTANCE 1.0f +#define DS3D_DEFAULTMAXDISTANCE 1000000000.0f + +#define DS3D_MINCONEANGLE 0 +#define DS3D_MAXCONEANGLE 360 +#define DS3D_DEFAULTCONEANGLE 360 + +#define DS3D_DEFAULTCONEOUTSIDEVOLUME 0 + +#define DSBCAPS_PRIMARYBUFFER 0x00000001 +#define DSBCAPS_STATIC 0x00000002 +#define DSBCAPS_LOCHARDWARE 0x00000004 +#define DSBCAPS_LOCSOFTWARE 0x00000008 +#define DSBCAPS_CTRL3D 0x00000010 +#define DSBCAPS_CTRLFREQUENCY 0x00000020 +#define DSBCAPS_CTRLPAN 0x00000040 +#define DSBCAPS_CTRLVOLUME 0x00000080 +#define DSBCAPS_CTRLPOSITIONNOTIFY 0x00000100 +#define DSBCAPS_CTRLDEFAULT 0x000000E0 +#define DSBCAPS_CTRLALL 0x000001F0 +#define DSBCAPS_STICKYFOCUS 0x00004000 +#define DSBCAPS_GLOBALFOCUS 0x00008000 +#define DSBCAPS_GETCURRENTPOSITION2 0x00010000 +#define DSBCAPS_MUTE3DATMAXDISTANCE 0x00020000 + +#define DSCBCAPS_WAVEMAPPED 0x80000000 + +#define DSSPEAKER_HEADPHONE 0x00000001 +#define DSSPEAKER_MONO 0x00000002 +#define DSSPEAKER_QUAD 0x00000003 +#define DSSPEAKER_STEREO 0x00000004 +#define DSSPEAKER_SURROUND 0x00000005 + +#define DSSPEAKER_GEOMETRY_MIN 0x00000005 // 5 degrees +#define DSSPEAKER_GEOMETRY_NARROW 0x0000000A // 10 degrees +#define DSSPEAKER_GEOMETRY_WIDE 0x00000014 // 20 degrees +#define DSSPEAKER_GEOMETRY_MAX 0x000000B4 // 180 degrees + +#define DSSPEAKER_COMBINED(c, g) ((DWORD)(((BYTE)(c)) | ((DWORD)((BYTE)(g))) << 16)) +#define DSSPEAKER_CONFIG(a) ((BYTE)(a)) +#define DSSPEAKER_GEOMETRY(a) ((BYTE)(((DWORD)(a) >> 16) & 0x00FF)) + +#define DSCCAPS_EMULDRIVER 0x00000020 + +#define DSCBLOCK_ENTIREBUFFER 0x00000001 + +#define DSCBSTATUS_CAPTURING 0x00000001 +#define DSCBSTATUS_LOOPING 0x00000002 + +#define DSCBSTART_LOOPING 0x00000001 + +#define DSBFREQUENCY_MIN 100 +#define DSBFREQUENCY_MAX 100000 +#define DSBFREQUENCY_ORIGINAL 0 + +#define DSBPAN_LEFT -10000 +#define DSBPAN_CENTER 0 +#define DSBPAN_RIGHT 10000 + +#define DSBVOLUME_MIN -10000 +#define DSBVOLUME_MAX 0 + +#define DSBSIZE_MIN 4 +#define DSBSIZE_MAX 0x0FFFFFFF + +#define DSBPN_OFFSETSTOP 0xFFFFFFFF + +#ifdef __cplusplus +}; +#endif // __cplusplus + +#endif // __DSOUND_INCLUDED__ diff --git a/misc/builddeps/dp.win64/include/gmp.h b/misc/builddeps/dp.win64/include/gmp.h new file mode 100644 index 00000000..02b9d9f6 --- /dev/null +++ b/misc/builddeps/dp.win64/include/gmp.h @@ -0,0 +1,2280 @@ +/* Definitions for GNU multiple precision functions. -*- mode: c -*- + +Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003, +2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + +This file is part of the GNU MP Library. + +The GNU MP Library is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 3 of the License, or (at your +option) any later version. + +The GNU MP Library is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public +License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with the GNU MP Library. If not, see http://www.gnu.org/licenses/. */ + +#ifndef __GMP_H__ + +#if defined (__cplusplus) +#include /* for std::istream, std::ostream, std::string */ +#include +#endif + + +/* Instantiated by configure. */ +#if ! defined (__GMP_WITHIN_CONFIGURE) +#define __GMP_HAVE_HOST_CPU_FAMILY_power 0 +#define __GMP_HAVE_HOST_CPU_FAMILY_powerpc 0 +#define GMP_LIMB_BITS 64 +#define GMP_NAIL_BITS 0 +#endif +#define GMP_NUMB_BITS (GMP_LIMB_BITS - GMP_NAIL_BITS) +#define GMP_NUMB_MASK ((~ __GMP_CAST (mp_limb_t, 0)) >> GMP_NAIL_BITS) +#define GMP_NUMB_MAX GMP_NUMB_MASK +#define GMP_NAIL_MASK (~ GMP_NUMB_MASK) + + +/* The following (everything under ifndef __GNU_MP__) must be identical in + gmp.h and mp.h to allow both to be included in an application or during + the library build. */ +#ifndef __GNU_MP__ +#define __GNU_MP__ 5 + +#define __need_size_t /* tell gcc stddef.h we only want size_t */ +#if defined (__cplusplus) +#include /* for size_t */ +#else +#include /* for size_t */ +#endif +#undef __need_size_t + +/* Instantiated by configure. */ +#if ! defined (__GMP_WITHIN_CONFIGURE) +#define _LONG_LONG_LIMB 1 +#define __GMP_LIBGMP_DLL 1 +#endif + + +/* __STDC__ - some ANSI compilers define this only to 0, hence the use of + "defined" and not "__STDC__-0". In particular Sun workshop C 5.0 + sets __STDC__ to 0, but requires "##" for token pasting. + + _AIX - gnu ansidecl.h asserts that all known AIX compilers are ANSI but + don't always define __STDC__. + + __DECC - current versions of DEC C (5.9 for instance) for alpha are ANSI, + but don't define __STDC__ in their default mode. Don't know if old + versions might have been K&R, but let's not worry about that unless + someone is still using one. + + _mips - gnu ansidecl.h says the RISC/OS MIPS compiler is ANSI in SVR4 + mode, but doesn't define __STDC__. + + _MSC_VER - Microsoft C is ANSI, but __STDC__ is undefined unless the /Za + option is given (in which case it's 1). + + _WIN32 - tested for by gnu ansidecl.h, no doubt on the assumption that + all w32 compilers are ansi. + + Note: This same set of tests is used by gen-psqr.c and + demos/expr/expr-impl.h, so if anything needs adding, then be sure to + update those too. */ + +#if defined (__STDC__) \ + || defined (__cplusplus) \ + || defined (_AIX) \ + || defined (__DECC) \ + || (defined (__mips) && defined (_SYSTYPE_SVR4)) \ + || defined (_MSC_VER) \ + || defined (_WIN32) +#define __GMP_HAVE_CONST 1 +#define __GMP_HAVE_PROTOTYPES 1 +#define __GMP_HAVE_TOKEN_PASTE 1 +#else +#define __GMP_HAVE_CONST 0 +#define __GMP_HAVE_PROTOTYPES 0 +#define __GMP_HAVE_TOKEN_PASTE 0 +#endif + + +#if __GMP_HAVE_CONST +#define __gmp_const const +#define __gmp_signed signed +#else +#define __gmp_const +#define __gmp_signed +#endif + + +/* __GMP_DECLSPEC supports Windows DLL versions of libgmp, and is empty in + all other circumstances. + + When compiling objects for libgmp, __GMP_DECLSPEC is an export directive, + or when compiling for an application it's an import directive. The two + cases are differentiated by __GMP_WITHIN_GMP defined by the GMP Makefiles + (and not defined from an application). + + __GMP_DECLSPEC_XX is similarly used for libgmpxx. __GMP_WITHIN_GMPXX + indicates when building libgmpxx, and in that case libgmpxx functions are + exports, but libgmp functions which might get called are imports. + + libmp.la uses __GMP_DECLSPEC, just as if it were libgmp.la. libgmp and + libmp don't call each other, so there's no conflict or confusion. + + Libtool DLL_EXPORT define is not used. + + There's no attempt to support GMP built both static and DLL. Doing so + would mean applications would have to tell us which of the two is going + to be used when linking, and that seems very tedious and error prone if + using GMP by hand, and equally tedious from a package since autoconf and + automake don't give much help. + + __GMP_DECLSPEC is required on all documented global functions and + variables, the various internals in gmp-impl.h etc can be left unadorned. + But internals used by the test programs or speed measuring programs + should have __GMP_DECLSPEC, and certainly constants or variables must + have it or the wrong address will be resolved. + + In gcc __declspec can go at either the start or end of a prototype. + + In Microsoft C __declspec must go at the start, or after the type like + void __declspec(...) *foo()". There's no __dllexport or anything to + guard against someone foolish #defining dllexport. _export used to be + available, but no longer. + + In Borland C _export still exists, but needs to go after the type, like + "void _export foo();". Would have to change the __GMP_DECLSPEC syntax to + make use of that. Probably more trouble than it's worth. */ + +#if defined (__GNUC__) +#define __GMP_DECLSPEC_EXPORT __declspec(__dllexport__) +#define __GMP_DECLSPEC_IMPORT __declspec(__dllimport__) +#endif +#if defined (_MSC_VER) || defined (__BORLANDC__) +#define __GMP_DECLSPEC_EXPORT __declspec(dllexport) +#define __GMP_DECLSPEC_IMPORT __declspec(dllimport) +#endif +#ifdef __WATCOMC__ +#define __GMP_DECLSPEC_EXPORT __export +#define __GMP_DECLSPEC_IMPORT __import +#endif +#ifdef __IBMC__ +#define __GMP_DECLSPEC_EXPORT _Export +#define __GMP_DECLSPEC_IMPORT _Import +#endif + +#if __GMP_LIBGMP_DLL +#if __GMP_WITHIN_GMP +/* compiling to go into a DLL libgmp */ +#define __GMP_DECLSPEC __GMP_DECLSPEC_EXPORT +#else +/* compiling to go into an application which will link to a DLL libgmp */ +#define __GMP_DECLSPEC __GMP_DECLSPEC_IMPORT +#endif +#else +/* all other cases */ +#define __GMP_DECLSPEC +#endif + + +#ifdef __GMP_SHORT_LIMB +typedef unsigned int mp_limb_t; +typedef int mp_limb_signed_t; +#else +#ifdef _LONG_LONG_LIMB +typedef unsigned long long int mp_limb_t; +typedef long long int mp_limb_signed_t; +#else +typedef unsigned long int mp_limb_t; +typedef long int mp_limb_signed_t; +#endif +#endif +typedef unsigned long int mp_bitcnt_t; + +/* For reference, note that the name __mpz_struct gets into C++ mangled + function names, which means although the "__" suggests an internal, we + must leave this name for binary compatibility. */ +typedef struct +{ + int _mp_alloc; /* Number of *limbs* allocated and pointed + to by the _mp_d field. */ + int _mp_size; /* abs(_mp_size) is the number of limbs the + last field points to. If _mp_size is + negative this is a negative number. */ + mp_limb_t *_mp_d; /* Pointer to the limbs. */ +} __mpz_struct; + +#endif /* __GNU_MP__ */ + + +typedef __mpz_struct MP_INT; /* gmp 1 source compatibility */ +typedef __mpz_struct mpz_t[1]; + +typedef mp_limb_t * mp_ptr; +typedef __gmp_const mp_limb_t * mp_srcptr; +#if defined (_CRAY) && ! defined (_CRAYMPP) +/* plain `int' is much faster (48 bits) */ +#define __GMP_MP_SIZE_T_INT 1 +typedef int mp_size_t; +typedef int mp_exp_t; +#else +#define __GMP_MP_SIZE_T_INT 0 +typedef long int mp_size_t; +typedef long int mp_exp_t; +#endif + +typedef struct +{ + __mpz_struct _mp_num; + __mpz_struct _mp_den; +} __mpq_struct; + +typedef __mpq_struct MP_RAT; /* gmp 1 source compatibility */ +typedef __mpq_struct mpq_t[1]; + +typedef struct +{ + int _mp_prec; /* Max precision, in number of `mp_limb_t's. + Set by mpf_init and modified by + mpf_set_prec. The area pointed to by the + _mp_d field contains `prec' + 1 limbs. */ + int _mp_size; /* abs(_mp_size) is the number of limbs the + last field points to. If _mp_size is + negative this is a negative number. */ + mp_exp_t _mp_exp; /* Exponent, in the base of `mp_limb_t'. */ + mp_limb_t *_mp_d; /* Pointer to the limbs. */ +} __mpf_struct; + +/* typedef __mpf_struct MP_FLOAT; */ +typedef __mpf_struct mpf_t[1]; + +/* Available random number generation algorithms. */ +typedef enum +{ + GMP_RAND_ALG_DEFAULT = 0, + GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT /* Linear congruential. */ +} gmp_randalg_t; + +/* Random state struct. */ +typedef struct +{ + mpz_t _mp_seed; /* _mp_d member points to state of the generator. */ + gmp_randalg_t _mp_alg; /* Currently unused. */ + union { + void *_mp_lc; /* Pointer to function pointers structure. */ + } _mp_algdata; +} __gmp_randstate_struct; +typedef __gmp_randstate_struct gmp_randstate_t[1]; + +/* Types for function declarations in gmp files. */ +/* ??? Should not pollute user name space with these ??? */ +typedef __gmp_const __mpz_struct *mpz_srcptr; +typedef __mpz_struct *mpz_ptr; +typedef __gmp_const __mpf_struct *mpf_srcptr; +typedef __mpf_struct *mpf_ptr; +typedef __gmp_const __mpq_struct *mpq_srcptr; +typedef __mpq_struct *mpq_ptr; + + +/* This is not wanted in mp.h, so put it outside the __GNU_MP__ common + section. */ +#if __GMP_LIBGMP_DLL +#if __GMP_WITHIN_GMPXX +/* compiling to go into a DLL libgmpxx */ +#define __GMP_DECLSPEC_XX __GMP_DECLSPEC_EXPORT +#else +/* compiling to go into a application which will link to a DLL libgmpxx */ +#define __GMP_DECLSPEC_XX __GMP_DECLSPEC_IMPORT +#endif +#else +/* all other cases */ +#define __GMP_DECLSPEC_XX +#endif + + +#if __GMP_HAVE_PROTOTYPES +#define __GMP_PROTO(x) x +#else +#define __GMP_PROTO(x) () +#endif + +#ifndef __MPN +#if __GMP_HAVE_TOKEN_PASTE +#define __MPN(x) __gmpn_##x +#else +#define __MPN(x) __gmpn_/**/x +#endif +#endif + +/* For reference, "defined(EOF)" cannot be used here. In g++ 2.95.4, + defines EOF but not FILE. */ +#if defined (FILE) \ + || defined (H_STDIO) \ + || defined (_H_STDIO) /* AIX */ \ + || defined (_STDIO_H) /* glibc, Sun, SCO */ \ + || defined (_STDIO_H_) /* BSD, OSF */ \ + || defined (__STDIO_H) /* Borland */ \ + || defined (__STDIO_H__) /* IRIX */ \ + || defined (_STDIO_INCLUDED) /* HPUX */ \ + || defined (__dj_include_stdio_h_) /* DJGPP */ \ + || defined (_FILE_DEFINED) /* Microsoft */ \ + || defined (__STDIO__) /* Apple MPW MrC */ \ + || defined (_MSL_STDIO_H) /* Metrowerks */ \ + || defined (_STDIO_H_INCLUDED) /* QNX4 */ \ + || defined (_ISO_STDIO_ISO_H) /* Sun C++ */ +#define _GMP_H_HAVE_FILE 1 +#endif + +/* In ISO C, if a prototype involving "struct obstack *" is given without + that structure defined, then the struct is scoped down to just the + prototype, causing a conflict if it's subsequently defined for real. So + only give prototypes if we've got obstack.h. */ +#if defined (_OBSTACK_H) /* glibc */ +#define _GMP_H_HAVE_OBSTACK 1 +#endif + +/* The prototypes for gmp_vprintf etc are provided only if va_list is + available, via an application having included or . + Usually va_list is a typedef so can't be tested directly, but C99 + specifies that va_start is a macro (and it was normally a macro on past + systems too), so look for that. + + will define some sort of va_list for vprintf and vfprintf, but + let's not bother trying to use that since it's not standard and since + application uses for gmp_vprintf etc will almost certainly require the + whole or anyway. */ + +#ifdef va_start +#define _GMP_H_HAVE_VA_LIST 1 +#endif + +/* Test for gcc >= maj.min, as per __GNUC_PREREQ in glibc */ +#if defined (__GNUC__) && defined (__GNUC_MINOR__) +#define __GMP_GNUC_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +#define __GMP_GNUC_PREREQ(maj, min) 0 +#endif + +/* "pure" is in gcc 2.96 and up, see "(gcc)Function Attributes". Basically + it means a function does nothing but examine its arguments and memory + (global or via arguments) to generate a return value, but changes nothing + and has no side-effects. __GMP_NO_ATTRIBUTE_CONST_PURE lets + tune/common.c etc turn this off when trying to write timing loops. */ +#if __GMP_GNUC_PREREQ (2,96) && ! defined (__GMP_NO_ATTRIBUTE_CONST_PURE) +#define __GMP_ATTRIBUTE_PURE __attribute__ ((__pure__)) +#else +#define __GMP_ATTRIBUTE_PURE +#endif + + +/* __GMP_CAST allows us to use static_cast in C++, so our macros are clean + to "g++ -Wold-style-cast". + + Casts in "extern inline" code within an extern "C" block don't induce + these warnings, so __GMP_CAST only needs to be used on documented + macros. */ + +#ifdef __cplusplus +#define __GMP_CAST(type, expr) (static_cast (expr)) +#else +#define __GMP_CAST(type, expr) ((type) (expr)) +#endif + + +/* An empty "throw ()" means the function doesn't throw any C++ exceptions, + this can save some stack frame info in applications. + + Currently it's given only on functions which never divide-by-zero etc, + don't allocate memory, and are expected to never need to allocate memory. + This leaves open the possibility of a C++ throw from a future GMP + exceptions scheme. + + mpz_set_ui etc are omitted to leave open the lazy allocation scheme + described in doc/tasks.html. mpz_get_d etc are omitted to leave open + exceptions for float overflows. + + Note that __GMP_NOTHROW must be given on any inlines the same as on their + prototypes (for g++ at least, where they're used together). Note also + that g++ 3.0 demands that __GMP_NOTHROW is before other attributes like + __GMP_ATTRIBUTE_PURE. */ + +#if defined (__cplusplus) +#define __GMP_NOTHROW throw () +#else +#define __GMP_NOTHROW +#endif + + +/* PORTME: What other compilers have a useful "extern inline"? "static + inline" would be an acceptable substitute if the compiler (or linker) + discards unused statics. */ + + /* gcc has __inline__ in all modes, including strict ansi. Give a prototype + for an inline too, so as to correctly specify "dllimport" on windows, in + case the function is called rather than inlined. + GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 + inline semantics, unless -fgnu89-inline is used. */ +#ifdef __GNUC__ +#if (defined __GNUC_STDC_INLINE__) || (__GNUC__ == 4 && __GNUC_MINOR__ == 2) +#define __GMP_EXTERN_INLINE extern __inline__ __attribute__ ((__gnu_inline__)) +#else +#define __GMP_EXTERN_INLINE extern __inline__ +#endif +#define __GMP_INLINE_PROTOTYPES 1 +#endif + +/* DEC C (eg. version 5.9) supports "static __inline foo()", even in -std1 + strict ANSI mode. Inlining is done even when not optimizing (ie. -O0 + mode, which is the default), but an unnecessary local copy of foo is + emitted unless -O is used. "extern __inline" is accepted, but the + "extern" appears to be ignored, ie. it becomes a plain global function + but which is inlined within its file. Don't know if all old versions of + DEC C supported __inline, but as a start let's do the right thing for + current versions. */ +#ifdef __DECC +#define __GMP_EXTERN_INLINE static __inline +#endif + +/* SCO OpenUNIX 8 cc supports "static inline foo()" but not in -Xc strict + ANSI mode (__STDC__ is 1 in that mode). Inlining only actually takes + place under -O. Without -O "foo" seems to be emitted whether it's used + or not, which is wasteful. "extern inline foo()" isn't useful, the + "extern" is apparently ignored, so foo is inlined if possible but also + emitted as a global, which causes multiple definition errors when + building a shared libgmp. */ +#ifdef __SCO_VERSION__ +#if __SCO_VERSION__ > 400000000 && __STDC__ != 1 \ + && ! defined (__GMP_EXTERN_INLINE) +#define __GMP_EXTERN_INLINE static inline +#endif +#endif + +/* Microsoft's C compiler accepts __inline */ +#ifdef _MSC_VER +#define __GMP_EXTERN_INLINE __inline +#endif + +/* Recent enough Sun C compilers want "inline" */ +#if defined (__SUNPRO_C) && __SUNPRO_C >= 0x560 \ + && ! defined (__GMP_EXTERN_INLINE) +#define __GMP_EXTERN_INLINE inline +#endif + +/* Somewhat older Sun C compilers want "static inline" */ +#if defined (__SUNPRO_C) && __SUNPRO_C >= 0x540 \ + && ! defined (__GMP_EXTERN_INLINE) +#define __GMP_EXTERN_INLINE static inline +#endif + + +/* C++ always has "inline" and since it's a normal feature the linker should + discard duplicate non-inlined copies, or if it doesn't then that's a + problem for everyone, not just GMP. */ +#if defined (__cplusplus) && ! defined (__GMP_EXTERN_INLINE) +#define __GMP_EXTERN_INLINE inline +#endif + +/* Don't do any inlining within a configure run, since if the compiler ends + up emitting copies of the code into the object file it can end up + demanding the various support routines (like mpn_popcount) for linking, + making the "alloca" test and perhaps others fail. And on hppa ia64 a + pre-release gcc 3.2 was seen not respecting the "extern" in "extern + __inline__", triggering this problem too. */ +#if defined (__GMP_WITHIN_CONFIGURE) && ! __GMP_WITHIN_CONFIGURE_INLINE +#undef __GMP_EXTERN_INLINE +#endif + +/* By default, don't give a prototype when there's going to be an inline + version. Note in particular that Cray C++ objects to the combination of + prototype and inline. */ +#ifdef __GMP_EXTERN_INLINE +#ifndef __GMP_INLINE_PROTOTYPES +#define __GMP_INLINE_PROTOTYPES 0 +#endif +#else +#define __GMP_INLINE_PROTOTYPES 1 +#endif + + +#define __GMP_ABS(x) ((x) >= 0 ? (x) : -(x)) +#define __GMP_MAX(h,i) ((h) > (i) ? (h) : (i)) + +/* __GMP_USHRT_MAX is not "~ (unsigned short) 0" because short is promoted + to int by "~". */ +#define __GMP_UINT_MAX (~ (unsigned) 0) +#define __GMP_ULONG_MAX (~ (unsigned long) 0) +#define __GMP_USHRT_MAX ((unsigned short) ~0) + + +/* __builtin_expect is in gcc 3.0, and not in 2.95. */ +#if __GMP_GNUC_PREREQ (3,0) +#define __GMP_LIKELY(cond) __builtin_expect ((cond) != 0, 1) +#define __GMP_UNLIKELY(cond) __builtin_expect ((cond) != 0, 0) +#else +#define __GMP_LIKELY(cond) (cond) +#define __GMP_UNLIKELY(cond) (cond) +#endif + +#ifdef _CRAY +#define __GMP_CRAY_Pragma(str) _Pragma (str) +#else +#define __GMP_CRAY_Pragma(str) +#endif + + +/* Allow direct user access to numerator and denominator of a mpq_t object. */ +#define mpq_numref(Q) (&((Q)->_mp_num)) +#define mpq_denref(Q) (&((Q)->_mp_den)) + + +#if defined (__cplusplus) +extern "C" { +using std::FILE; +#endif + +#define mp_set_memory_functions __gmp_set_memory_functions +__GMP_DECLSPEC void mp_set_memory_functions __GMP_PROTO ((void *(*) (size_t), + void *(*) (void *, size_t, size_t), + void (*) (void *, size_t))) __GMP_NOTHROW; + +#define mp_get_memory_functions __gmp_get_memory_functions +__GMP_DECLSPEC void mp_get_memory_functions __GMP_PROTO ((void *(**) (size_t), + void *(**) (void *, size_t, size_t), + void (**) (void *, size_t))) __GMP_NOTHROW; + +#define mp_bits_per_limb __gmp_bits_per_limb +__GMP_DECLSPEC extern __gmp_const int mp_bits_per_limb; + +#define gmp_errno __gmp_errno +__GMP_DECLSPEC extern int gmp_errno; + +#define gmp_version __gmp_version +__GMP_DECLSPEC extern __gmp_const char * __gmp_const gmp_version; + + +/**************** Random number routines. ****************/ + +/* obsolete */ +#define gmp_randinit __gmp_randinit +__GMP_DECLSPEC void gmp_randinit __GMP_PROTO ((gmp_randstate_t, gmp_randalg_t, ...)); + +#define gmp_randinit_default __gmp_randinit_default +__GMP_DECLSPEC void gmp_randinit_default __GMP_PROTO ((gmp_randstate_t)); + +#define gmp_randinit_lc_2exp __gmp_randinit_lc_2exp +__GMP_DECLSPEC void gmp_randinit_lc_2exp __GMP_PROTO ((gmp_randstate_t, + mpz_srcptr, unsigned long int, + mp_bitcnt_t)); + +#define gmp_randinit_lc_2exp_size __gmp_randinit_lc_2exp_size +__GMP_DECLSPEC int gmp_randinit_lc_2exp_size __GMP_PROTO ((gmp_randstate_t, mp_bitcnt_t)); + +#define gmp_randinit_mt __gmp_randinit_mt +__GMP_DECLSPEC void gmp_randinit_mt __GMP_PROTO ((gmp_randstate_t)); + +#define gmp_randinit_set __gmp_randinit_set +__GMP_DECLSPEC void gmp_randinit_set __GMP_PROTO ((gmp_randstate_t, __gmp_const __gmp_randstate_struct *)); + +#define gmp_randseed __gmp_randseed +__GMP_DECLSPEC void gmp_randseed __GMP_PROTO ((gmp_randstate_t, mpz_srcptr)); + +#define gmp_randseed_ui __gmp_randseed_ui +__GMP_DECLSPEC void gmp_randseed_ui __GMP_PROTO ((gmp_randstate_t, unsigned long int)); + +#define gmp_randclear __gmp_randclear +__GMP_DECLSPEC void gmp_randclear __GMP_PROTO ((gmp_randstate_t)); + +#define gmp_urandomb_ui __gmp_urandomb_ui +__GMP_DECLSPEC unsigned long gmp_urandomb_ui __GMP_PROTO ((gmp_randstate_t, unsigned long)); + +#define gmp_urandomm_ui __gmp_urandomm_ui +__GMP_DECLSPEC unsigned long gmp_urandomm_ui __GMP_PROTO ((gmp_randstate_t, unsigned long)); + + +/**************** Formatted output routines. ****************/ + +#define gmp_asprintf __gmp_asprintf +__GMP_DECLSPEC int gmp_asprintf __GMP_PROTO ((char **, __gmp_const char *, ...)); + +#define gmp_fprintf __gmp_fprintf +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC int gmp_fprintf __GMP_PROTO ((FILE *, __gmp_const char *, ...)); +#endif + +#define gmp_obstack_printf __gmp_obstack_printf +#if defined (_GMP_H_HAVE_OBSTACK) +__GMP_DECLSPEC int gmp_obstack_printf __GMP_PROTO ((struct obstack *, __gmp_const char *, ...)); +#endif + +#define gmp_obstack_vprintf __gmp_obstack_vprintf +#if defined (_GMP_H_HAVE_OBSTACK) && defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_obstack_vprintf __GMP_PROTO ((struct obstack *, __gmp_const char *, va_list)); +#endif + +#define gmp_printf __gmp_printf +__GMP_DECLSPEC int gmp_printf __GMP_PROTO ((__gmp_const char *, ...)); + +#define gmp_snprintf __gmp_snprintf +__GMP_DECLSPEC int gmp_snprintf __GMP_PROTO ((char *, size_t, __gmp_const char *, ...)); + +#define gmp_sprintf __gmp_sprintf +__GMP_DECLSPEC int gmp_sprintf __GMP_PROTO ((char *, __gmp_const char *, ...)); + +#define gmp_vasprintf __gmp_vasprintf +#if defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vasprintf __GMP_PROTO ((char **, __gmp_const char *, va_list)); +#endif + +#define gmp_vfprintf __gmp_vfprintf +#if defined (_GMP_H_HAVE_FILE) && defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vfprintf __GMP_PROTO ((FILE *, __gmp_const char *, va_list)); +#endif + +#define gmp_vprintf __gmp_vprintf +#if defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vprintf __GMP_PROTO ((__gmp_const char *, va_list)); +#endif + +#define gmp_vsnprintf __gmp_vsnprintf +#if defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vsnprintf __GMP_PROTO ((char *, size_t, __gmp_const char *, va_list)); +#endif + +#define gmp_vsprintf __gmp_vsprintf +#if defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vsprintf __GMP_PROTO ((char *, __gmp_const char *, va_list)); +#endif + + +/**************** Formatted input routines. ****************/ + +#define gmp_fscanf __gmp_fscanf +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC int gmp_fscanf __GMP_PROTO ((FILE *, __gmp_const char *, ...)); +#endif + +#define gmp_scanf __gmp_scanf +__GMP_DECLSPEC int gmp_scanf __GMP_PROTO ((__gmp_const char *, ...)); + +#define gmp_sscanf __gmp_sscanf +__GMP_DECLSPEC int gmp_sscanf __GMP_PROTO ((__gmp_const char *, __gmp_const char *, ...)); + +#define gmp_vfscanf __gmp_vfscanf +#if defined (_GMP_H_HAVE_FILE) && defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vfscanf __GMP_PROTO ((FILE *, __gmp_const char *, va_list)); +#endif + +#define gmp_vscanf __gmp_vscanf +#if defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vscanf __GMP_PROTO ((__gmp_const char *, va_list)); +#endif + +#define gmp_vsscanf __gmp_vsscanf +#if defined (_GMP_H_HAVE_VA_LIST) +__GMP_DECLSPEC int gmp_vsscanf __GMP_PROTO ((__gmp_const char *, __gmp_const char *, va_list)); +#endif + + +/**************** Integer (i.e. Z) routines. ****************/ + +#define _mpz_realloc __gmpz_realloc +#define mpz_realloc __gmpz_realloc +__GMP_DECLSPEC void *_mpz_realloc __GMP_PROTO ((mpz_ptr, mp_size_t)); + +#define mpz_abs __gmpz_abs +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_abs) +__GMP_DECLSPEC void mpz_abs __GMP_PROTO ((mpz_ptr, mpz_srcptr)); +#endif + +#define mpz_add __gmpz_add +__GMP_DECLSPEC void mpz_add __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_add_ui __gmpz_add_ui +__GMP_DECLSPEC void mpz_add_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_addmul __gmpz_addmul +__GMP_DECLSPEC void mpz_addmul __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_addmul_ui __gmpz_addmul_ui +__GMP_DECLSPEC void mpz_addmul_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_and __gmpz_and +__GMP_DECLSPEC void mpz_and __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_array_init __gmpz_array_init +__GMP_DECLSPEC void mpz_array_init __GMP_PROTO ((mpz_ptr, mp_size_t, mp_size_t)); + +#define mpz_bin_ui __gmpz_bin_ui +__GMP_DECLSPEC void mpz_bin_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_bin_uiui __gmpz_bin_uiui +__GMP_DECLSPEC void mpz_bin_uiui __GMP_PROTO ((mpz_ptr, unsigned long int, unsigned long int)); + +#define mpz_cdiv_q __gmpz_cdiv_q +__GMP_DECLSPEC void mpz_cdiv_q __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_cdiv_q_2exp __gmpz_cdiv_q_2exp +__GMP_DECLSPEC void mpz_cdiv_q_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); + +#define mpz_cdiv_q_ui __gmpz_cdiv_q_ui +__GMP_DECLSPEC unsigned long int mpz_cdiv_q_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_cdiv_qr __gmpz_cdiv_qr +__GMP_DECLSPEC void mpz_cdiv_qr __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_cdiv_qr_ui __gmpz_cdiv_qr_ui +__GMP_DECLSPEC unsigned long int mpz_cdiv_qr_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_cdiv_r __gmpz_cdiv_r +__GMP_DECLSPEC void mpz_cdiv_r __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_cdiv_r_2exp __gmpz_cdiv_r_2exp +__GMP_DECLSPEC void mpz_cdiv_r_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, mp_bitcnt_t)); + +#define mpz_cdiv_r_ui __gmpz_cdiv_r_ui +__GMP_DECLSPEC unsigned long int mpz_cdiv_r_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_cdiv_ui __gmpz_cdiv_ui +__GMP_DECLSPEC unsigned long int mpz_cdiv_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; + +#define mpz_clear __gmpz_clear +__GMP_DECLSPEC void mpz_clear __GMP_PROTO ((mpz_ptr)); + +#define mpz_clears __gmpz_clears +__GMP_DECLSPEC void mpz_clears __GMP_PROTO ((mpz_ptr, ...)); + +#define mpz_clrbit __gmpz_clrbit +__GMP_DECLSPEC void mpz_clrbit __GMP_PROTO ((mpz_ptr, mp_bitcnt_t)); + +#define mpz_cmp __gmpz_cmp +__GMP_DECLSPEC int mpz_cmp __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_cmp_d __gmpz_cmp_d +__GMP_DECLSPEC int mpz_cmp_d __GMP_PROTO ((mpz_srcptr, double)) __GMP_ATTRIBUTE_PURE; + +#define _mpz_cmp_si __gmpz_cmp_si +__GMP_DECLSPEC int _mpz_cmp_si __GMP_PROTO ((mpz_srcptr, signed long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define _mpz_cmp_ui __gmpz_cmp_ui +__GMP_DECLSPEC int _mpz_cmp_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_cmpabs __gmpz_cmpabs +__GMP_DECLSPEC int mpz_cmpabs __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_cmpabs_d __gmpz_cmpabs_d +__GMP_DECLSPEC int mpz_cmpabs_d __GMP_PROTO ((mpz_srcptr, double)) __GMP_ATTRIBUTE_PURE; + +#define mpz_cmpabs_ui __gmpz_cmpabs_ui +__GMP_DECLSPEC int mpz_cmpabs_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_com __gmpz_com +__GMP_DECLSPEC void mpz_com __GMP_PROTO ((mpz_ptr, mpz_srcptr)); + +#define mpz_combit __gmpz_combit +__GMP_DECLSPEC void mpz_combit __GMP_PROTO ((mpz_ptr, mp_bitcnt_t)); + +#define mpz_congruent_p __gmpz_congruent_p +__GMP_DECLSPEC int mpz_congruent_p __GMP_PROTO ((mpz_srcptr, mpz_srcptr, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_congruent_2exp_p __gmpz_congruent_2exp_p +__GMP_DECLSPEC int mpz_congruent_2exp_p __GMP_PROTO ((mpz_srcptr, mpz_srcptr, mp_bitcnt_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_congruent_ui_p __gmpz_congruent_ui_p +__GMP_DECLSPEC int mpz_congruent_ui_p __GMP_PROTO ((mpz_srcptr, unsigned long, unsigned long)) __GMP_ATTRIBUTE_PURE; + +#define mpz_divexact __gmpz_divexact +__GMP_DECLSPEC void mpz_divexact __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_divexact_ui __gmpz_divexact_ui +__GMP_DECLSPEC void mpz_divexact_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); + +#define mpz_divisible_p __gmpz_divisible_p +__GMP_DECLSPEC int mpz_divisible_p __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_divisible_ui_p __gmpz_divisible_ui_p +__GMP_DECLSPEC int mpz_divisible_ui_p __GMP_PROTO ((mpz_srcptr, unsigned long)) __GMP_ATTRIBUTE_PURE; + +#define mpz_divisible_2exp_p __gmpz_divisible_2exp_p +__GMP_DECLSPEC int mpz_divisible_2exp_p __GMP_PROTO ((mpz_srcptr, mp_bitcnt_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_dump __gmpz_dump +__GMP_DECLSPEC void mpz_dump __GMP_PROTO ((mpz_srcptr)); + +#define mpz_export __gmpz_export +__GMP_DECLSPEC void *mpz_export __GMP_PROTO ((void *, size_t *, int, size_t, int, size_t, mpz_srcptr)); + +#define mpz_fac_ui __gmpz_fac_ui +__GMP_DECLSPEC void mpz_fac_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); + +#define mpz_fdiv_q __gmpz_fdiv_q +__GMP_DECLSPEC void mpz_fdiv_q __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_fdiv_q_2exp __gmpz_fdiv_q_2exp +__GMP_DECLSPEC void mpz_fdiv_q_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, mp_bitcnt_t)); + +#define mpz_fdiv_q_ui __gmpz_fdiv_q_ui +__GMP_DECLSPEC unsigned long int mpz_fdiv_q_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_fdiv_qr __gmpz_fdiv_qr +__GMP_DECLSPEC void mpz_fdiv_qr __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_fdiv_qr_ui __gmpz_fdiv_qr_ui +__GMP_DECLSPEC unsigned long int mpz_fdiv_qr_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_fdiv_r __gmpz_fdiv_r +__GMP_DECLSPEC void mpz_fdiv_r __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_fdiv_r_2exp __gmpz_fdiv_r_2exp +__GMP_DECLSPEC void mpz_fdiv_r_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, mp_bitcnt_t)); + +#define mpz_fdiv_r_ui __gmpz_fdiv_r_ui +__GMP_DECLSPEC unsigned long int mpz_fdiv_r_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_fdiv_ui __gmpz_fdiv_ui +__GMP_DECLSPEC unsigned long int mpz_fdiv_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; + +#define mpz_fib_ui __gmpz_fib_ui +__GMP_DECLSPEC void mpz_fib_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); + +#define mpz_fib2_ui __gmpz_fib2_ui +__GMP_DECLSPEC void mpz_fib2_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, unsigned long int)); + +#define mpz_fits_sint_p __gmpz_fits_sint_p +__GMP_DECLSPEC int mpz_fits_sint_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_fits_slong_p __gmpz_fits_slong_p +__GMP_DECLSPEC int mpz_fits_slong_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_fits_sshort_p __gmpz_fits_sshort_p +__GMP_DECLSPEC int mpz_fits_sshort_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_fits_uint_p __gmpz_fits_uint_p +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_fits_uint_p) +__GMP_DECLSPEC int mpz_fits_uint_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_fits_ulong_p __gmpz_fits_ulong_p +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_fits_ulong_p) +__GMP_DECLSPEC int mpz_fits_ulong_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_fits_ushort_p __gmpz_fits_ushort_p +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_fits_ushort_p) +__GMP_DECLSPEC int mpz_fits_ushort_p __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_gcd __gmpz_gcd +__GMP_DECLSPEC void mpz_gcd __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_gcd_ui __gmpz_gcd_ui +__GMP_DECLSPEC unsigned long int mpz_gcd_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_gcdext __gmpz_gcdext +__GMP_DECLSPEC void mpz_gcdext __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_get_d __gmpz_get_d +__GMP_DECLSPEC double mpz_get_d __GMP_PROTO ((mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_get_d_2exp __gmpz_get_d_2exp +__GMP_DECLSPEC double mpz_get_d_2exp __GMP_PROTO ((signed long int *, mpz_srcptr)); + +#define mpz_get_si __gmpz_get_si +__GMP_DECLSPEC /* signed */ long int mpz_get_si __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_get_str __gmpz_get_str +__GMP_DECLSPEC char *mpz_get_str __GMP_PROTO ((char *, int, mpz_srcptr)); + +#define mpz_get_ui __gmpz_get_ui +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_get_ui) +__GMP_DECLSPEC unsigned long int mpz_get_ui __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_getlimbn __gmpz_getlimbn +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_getlimbn) +__GMP_DECLSPEC mp_limb_t mpz_getlimbn __GMP_PROTO ((mpz_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_hamdist __gmpz_hamdist +__GMP_DECLSPEC mp_bitcnt_t mpz_hamdist __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_import __gmpz_import +__GMP_DECLSPEC void mpz_import __GMP_PROTO ((mpz_ptr, size_t, int, size_t, int, size_t, __gmp_const void *)); + +#define mpz_init __gmpz_init +__GMP_DECLSPEC void mpz_init __GMP_PROTO ((mpz_ptr)); + +#define mpz_init2 __gmpz_init2 +__GMP_DECLSPEC void mpz_init2 __GMP_PROTO ((mpz_ptr, mp_bitcnt_t)); + +#define mpz_inits __gmpz_inits +__GMP_DECLSPEC void mpz_inits __GMP_PROTO ((mpz_ptr, ...)); + +#define mpz_init_set __gmpz_init_set +__GMP_DECLSPEC void mpz_init_set __GMP_PROTO ((mpz_ptr, mpz_srcptr)); + +#define mpz_init_set_d __gmpz_init_set_d +__GMP_DECLSPEC void mpz_init_set_d __GMP_PROTO ((mpz_ptr, double)); + +#define mpz_init_set_si __gmpz_init_set_si +__GMP_DECLSPEC void mpz_init_set_si __GMP_PROTO ((mpz_ptr, signed long int)); + +#define mpz_init_set_str __gmpz_init_set_str +__GMP_DECLSPEC int mpz_init_set_str __GMP_PROTO ((mpz_ptr, __gmp_const char *, int)); + +#define mpz_init_set_ui __gmpz_init_set_ui +__GMP_DECLSPEC void mpz_init_set_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); + +#define mpz_inp_raw __gmpz_inp_raw +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpz_inp_raw __GMP_PROTO ((mpz_ptr, FILE *)); +#endif + +#define mpz_inp_str __gmpz_inp_str +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpz_inp_str __GMP_PROTO ((mpz_ptr, FILE *, int)); +#endif + +#define mpz_invert __gmpz_invert +__GMP_DECLSPEC int mpz_invert __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_ior __gmpz_ior +__GMP_DECLSPEC void mpz_ior __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_jacobi __gmpz_jacobi +__GMP_DECLSPEC int mpz_jacobi __GMP_PROTO ((mpz_srcptr, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_kronecker mpz_jacobi /* alias */ + +#define mpz_kronecker_si __gmpz_kronecker_si +__GMP_DECLSPEC int mpz_kronecker_si __GMP_PROTO ((mpz_srcptr, long)) __GMP_ATTRIBUTE_PURE; + +#define mpz_kronecker_ui __gmpz_kronecker_ui +__GMP_DECLSPEC int mpz_kronecker_ui __GMP_PROTO ((mpz_srcptr, unsigned long)) __GMP_ATTRIBUTE_PURE; + +#define mpz_si_kronecker __gmpz_si_kronecker +__GMP_DECLSPEC int mpz_si_kronecker __GMP_PROTO ((long, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_ui_kronecker __gmpz_ui_kronecker +__GMP_DECLSPEC int mpz_ui_kronecker __GMP_PROTO ((unsigned long, mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_lcm __gmpz_lcm +__GMP_DECLSPEC void mpz_lcm __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_lcm_ui __gmpz_lcm_ui +__GMP_DECLSPEC void mpz_lcm_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long)); + +#define mpz_legendre mpz_jacobi /* alias */ + +#define mpz_lucnum_ui __gmpz_lucnum_ui +__GMP_DECLSPEC void mpz_lucnum_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); + +#define mpz_lucnum2_ui __gmpz_lucnum2_ui +__GMP_DECLSPEC void mpz_lucnum2_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, unsigned long int)); + +#define mpz_millerrabin __gmpz_millerrabin +__GMP_DECLSPEC int mpz_millerrabin __GMP_PROTO ((mpz_srcptr, int)) __GMP_ATTRIBUTE_PURE; + +#define mpz_mod __gmpz_mod +__GMP_DECLSPEC void mpz_mod __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_mod_ui mpz_fdiv_r_ui /* same as fdiv_r because divisor unsigned */ + +#define mpz_mul __gmpz_mul +__GMP_DECLSPEC void mpz_mul __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_mul_2exp __gmpz_mul_2exp +__GMP_DECLSPEC void mpz_mul_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, mp_bitcnt_t)); + +#define mpz_mul_si __gmpz_mul_si +__GMP_DECLSPEC void mpz_mul_si __GMP_PROTO ((mpz_ptr, mpz_srcptr, long int)); + +#define mpz_mul_ui __gmpz_mul_ui +__GMP_DECLSPEC void mpz_mul_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_neg __gmpz_neg +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_neg) +__GMP_DECLSPEC void mpz_neg __GMP_PROTO ((mpz_ptr, mpz_srcptr)); +#endif + +#define mpz_nextprime __gmpz_nextprime +__GMP_DECLSPEC void mpz_nextprime __GMP_PROTO ((mpz_ptr, mpz_srcptr)); + +#define mpz_out_raw __gmpz_out_raw +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpz_out_raw __GMP_PROTO ((FILE *, mpz_srcptr)); +#endif + +#define mpz_out_str __gmpz_out_str +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpz_out_str __GMP_PROTO ((FILE *, int, mpz_srcptr)); +#endif + +#define mpz_perfect_power_p __gmpz_perfect_power_p +__GMP_DECLSPEC int mpz_perfect_power_p __GMP_PROTO ((mpz_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpz_perfect_square_p __gmpz_perfect_square_p +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_perfect_square_p) +__GMP_DECLSPEC int mpz_perfect_square_p __GMP_PROTO ((mpz_srcptr)) __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_popcount __gmpz_popcount +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_popcount) +__GMP_DECLSPEC mp_bitcnt_t mpz_popcount __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_pow_ui __gmpz_pow_ui +__GMP_DECLSPEC void mpz_pow_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_powm __gmpz_powm +__GMP_DECLSPEC void mpz_powm __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_powm_sec __gmpz_powm_sec +__GMP_DECLSPEC void mpz_powm_sec __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_powm_ui __gmpz_powm_ui +__GMP_DECLSPEC void mpz_powm_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr)); + +#define mpz_probab_prime_p __gmpz_probab_prime_p +__GMP_DECLSPEC int mpz_probab_prime_p __GMP_PROTO ((mpz_srcptr, int)) __GMP_ATTRIBUTE_PURE; + +#define mpz_random __gmpz_random +__GMP_DECLSPEC void mpz_random __GMP_PROTO ((mpz_ptr, mp_size_t)); + +#define mpz_random2 __gmpz_random2 +__GMP_DECLSPEC void mpz_random2 __GMP_PROTO ((mpz_ptr, mp_size_t)); + +#define mpz_realloc2 __gmpz_realloc2 +__GMP_DECLSPEC void mpz_realloc2 __GMP_PROTO ((mpz_ptr, mp_bitcnt_t)); + +#define mpz_remove __gmpz_remove +__GMP_DECLSPEC unsigned long int mpz_remove __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_root __gmpz_root +__GMP_DECLSPEC int mpz_root __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_rootrem __gmpz_rootrem +__GMP_DECLSPEC void mpz_rootrem __GMP_PROTO ((mpz_ptr,mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_rrandomb __gmpz_rrandomb +__GMP_DECLSPEC void mpz_rrandomb __GMP_PROTO ((mpz_ptr, gmp_randstate_t, mp_bitcnt_t)); + +#define mpz_scan0 __gmpz_scan0 +__GMP_DECLSPEC mp_bitcnt_t mpz_scan0 __GMP_PROTO ((mpz_srcptr, mp_bitcnt_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_scan1 __gmpz_scan1 +__GMP_DECLSPEC mp_bitcnt_t mpz_scan1 __GMP_PROTO ((mpz_srcptr, mp_bitcnt_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_set __gmpz_set +__GMP_DECLSPEC void mpz_set __GMP_PROTO ((mpz_ptr, mpz_srcptr)); + +#define mpz_set_d __gmpz_set_d +__GMP_DECLSPEC void mpz_set_d __GMP_PROTO ((mpz_ptr, double)); + +#define mpz_set_f __gmpz_set_f +__GMP_DECLSPEC void mpz_set_f __GMP_PROTO ((mpz_ptr, mpf_srcptr)); + +#define mpz_set_q __gmpz_set_q +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_set_q) +__GMP_DECLSPEC void mpz_set_q __GMP_PROTO ((mpz_ptr, mpq_srcptr)); +#endif + +#define mpz_set_si __gmpz_set_si +__GMP_DECLSPEC void mpz_set_si __GMP_PROTO ((mpz_ptr, signed long int)); + +#define mpz_set_str __gmpz_set_str +__GMP_DECLSPEC int mpz_set_str __GMP_PROTO ((mpz_ptr, __gmp_const char *, int)); + +#define mpz_set_ui __gmpz_set_ui +__GMP_DECLSPEC void mpz_set_ui __GMP_PROTO ((mpz_ptr, unsigned long int)); + +#define mpz_setbit __gmpz_setbit +__GMP_DECLSPEC void mpz_setbit __GMP_PROTO ((mpz_ptr, mp_bitcnt_t)); + +#define mpz_size __gmpz_size +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpz_size) +__GMP_DECLSPEC size_t mpz_size __GMP_PROTO ((mpz_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpz_sizeinbase __gmpz_sizeinbase +__GMP_DECLSPEC size_t mpz_sizeinbase __GMP_PROTO ((mpz_srcptr, int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_sqrt __gmpz_sqrt +__GMP_DECLSPEC void mpz_sqrt __GMP_PROTO ((mpz_ptr, mpz_srcptr)); + +#define mpz_sqrtrem __gmpz_sqrtrem +__GMP_DECLSPEC void mpz_sqrtrem __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr)); + +#define mpz_sub __gmpz_sub +__GMP_DECLSPEC void mpz_sub __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_sub_ui __gmpz_sub_ui +__GMP_DECLSPEC void mpz_sub_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_ui_sub __gmpz_ui_sub +__GMP_DECLSPEC void mpz_ui_sub __GMP_PROTO ((mpz_ptr, unsigned long int, mpz_srcptr)); + +#define mpz_submul __gmpz_submul +__GMP_DECLSPEC void mpz_submul __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_submul_ui __gmpz_submul_ui +__GMP_DECLSPEC void mpz_submul_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_swap __gmpz_swap +__GMP_DECLSPEC void mpz_swap __GMP_PROTO ((mpz_ptr, mpz_ptr)) __GMP_NOTHROW; + +#define mpz_tdiv_ui __gmpz_tdiv_ui +__GMP_DECLSPEC unsigned long int mpz_tdiv_ui __GMP_PROTO ((mpz_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; + +#define mpz_tdiv_q __gmpz_tdiv_q +__GMP_DECLSPEC void mpz_tdiv_q __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_tdiv_q_2exp __gmpz_tdiv_q_2exp +__GMP_DECLSPEC void mpz_tdiv_q_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, mp_bitcnt_t)); + +#define mpz_tdiv_q_ui __gmpz_tdiv_q_ui +__GMP_DECLSPEC unsigned long int mpz_tdiv_q_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_tdiv_qr __gmpz_tdiv_qr +__GMP_DECLSPEC void mpz_tdiv_qr __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_tdiv_qr_ui __gmpz_tdiv_qr_ui +__GMP_DECLSPEC unsigned long int mpz_tdiv_qr_ui __GMP_PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_tdiv_r __gmpz_tdiv_r +__GMP_DECLSPEC void mpz_tdiv_r __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + +#define mpz_tdiv_r_2exp __gmpz_tdiv_r_2exp +__GMP_DECLSPEC void mpz_tdiv_r_2exp __GMP_PROTO ((mpz_ptr, mpz_srcptr, mp_bitcnt_t)); + +#define mpz_tdiv_r_ui __gmpz_tdiv_r_ui +__GMP_DECLSPEC unsigned long int mpz_tdiv_r_ui __GMP_PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); + +#define mpz_tstbit __gmpz_tstbit +__GMP_DECLSPEC int mpz_tstbit __GMP_PROTO ((mpz_srcptr, mp_bitcnt_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpz_ui_pow_ui __gmpz_ui_pow_ui +__GMP_DECLSPEC void mpz_ui_pow_ui __GMP_PROTO ((mpz_ptr, unsigned long int, unsigned long int)); + +#define mpz_urandomb __gmpz_urandomb +__GMP_DECLSPEC void mpz_urandomb __GMP_PROTO ((mpz_ptr, gmp_randstate_t, mp_bitcnt_t)); + +#define mpz_urandomm __gmpz_urandomm +__GMP_DECLSPEC void mpz_urandomm __GMP_PROTO ((mpz_ptr, gmp_randstate_t, mpz_srcptr)); + +#define mpz_xor __gmpz_xor +#define mpz_eor __gmpz_xor +__GMP_DECLSPEC void mpz_xor __GMP_PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); + + +/**************** Rational (i.e. Q) routines. ****************/ + +#define mpq_abs __gmpq_abs +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpq_abs) +__GMP_DECLSPEC void mpq_abs __GMP_PROTO ((mpq_ptr, mpq_srcptr)); +#endif + +#define mpq_add __gmpq_add +__GMP_DECLSPEC void mpq_add __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); + +#define mpq_canonicalize __gmpq_canonicalize +__GMP_DECLSPEC void mpq_canonicalize __GMP_PROTO ((mpq_ptr)); + +#define mpq_clear __gmpq_clear +__GMP_DECLSPEC void mpq_clear __GMP_PROTO ((mpq_ptr)); + +#define mpq_clears __gmpq_clears +__GMP_DECLSPEC void mpq_clears __GMP_PROTO ((mpq_ptr, ...)); + +#define mpq_cmp __gmpq_cmp +__GMP_DECLSPEC int mpq_cmp __GMP_PROTO ((mpq_srcptr, mpq_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define _mpq_cmp_si __gmpq_cmp_si +__GMP_DECLSPEC int _mpq_cmp_si __GMP_PROTO ((mpq_srcptr, long, unsigned long)) __GMP_ATTRIBUTE_PURE; + +#define _mpq_cmp_ui __gmpq_cmp_ui +__GMP_DECLSPEC int _mpq_cmp_ui __GMP_PROTO ((mpq_srcptr, unsigned long int, unsigned long int)) __GMP_ATTRIBUTE_PURE; + +#define mpq_div __gmpq_div +__GMP_DECLSPEC void mpq_div __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); + +#define mpq_div_2exp __gmpq_div_2exp +__GMP_DECLSPEC void mpq_div_2exp __GMP_PROTO ((mpq_ptr, mpq_srcptr, mp_bitcnt_t)); + +#define mpq_equal __gmpq_equal +__GMP_DECLSPEC int mpq_equal __GMP_PROTO ((mpq_srcptr, mpq_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpq_get_num __gmpq_get_num +__GMP_DECLSPEC void mpq_get_num __GMP_PROTO ((mpz_ptr, mpq_srcptr)); + +#define mpq_get_den __gmpq_get_den +__GMP_DECLSPEC void mpq_get_den __GMP_PROTO ((mpz_ptr, mpq_srcptr)); + +#define mpq_get_d __gmpq_get_d +__GMP_DECLSPEC double mpq_get_d __GMP_PROTO ((mpq_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpq_get_str __gmpq_get_str +__GMP_DECLSPEC char *mpq_get_str __GMP_PROTO ((char *, int, mpq_srcptr)); + +#define mpq_init __gmpq_init +__GMP_DECLSPEC void mpq_init __GMP_PROTO ((mpq_ptr)); + +#define mpq_inits __gmpq_inits +__GMP_DECLSPEC void mpq_inits __GMP_PROTO ((mpq_ptr, ...)); + +#define mpq_inp_str __gmpq_inp_str +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpq_inp_str __GMP_PROTO ((mpq_ptr, FILE *, int)); +#endif + +#define mpq_inv __gmpq_inv +__GMP_DECLSPEC void mpq_inv __GMP_PROTO ((mpq_ptr, mpq_srcptr)); + +#define mpq_mul __gmpq_mul +__GMP_DECLSPEC void mpq_mul __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); + +#define mpq_mul_2exp __gmpq_mul_2exp +__GMP_DECLSPEC void mpq_mul_2exp __GMP_PROTO ((mpq_ptr, mpq_srcptr, mp_bitcnt_t)); + +#define mpq_neg __gmpq_neg +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpq_neg) +__GMP_DECLSPEC void mpq_neg __GMP_PROTO ((mpq_ptr, mpq_srcptr)); +#endif + +#define mpq_out_str __gmpq_out_str +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpq_out_str __GMP_PROTO ((FILE *, int, mpq_srcptr)); +#endif + +#define mpq_set __gmpq_set +__GMP_DECLSPEC void mpq_set __GMP_PROTO ((mpq_ptr, mpq_srcptr)); + +#define mpq_set_d __gmpq_set_d +__GMP_DECLSPEC void mpq_set_d __GMP_PROTO ((mpq_ptr, double)); + +#define mpq_set_den __gmpq_set_den +__GMP_DECLSPEC void mpq_set_den __GMP_PROTO ((mpq_ptr, mpz_srcptr)); + +#define mpq_set_f __gmpq_set_f +__GMP_DECLSPEC void mpq_set_f __GMP_PROTO ((mpq_ptr, mpf_srcptr)); + +#define mpq_set_num __gmpq_set_num +__GMP_DECLSPEC void mpq_set_num __GMP_PROTO ((mpq_ptr, mpz_srcptr)); + +#define mpq_set_si __gmpq_set_si +__GMP_DECLSPEC void mpq_set_si __GMP_PROTO ((mpq_ptr, signed long int, unsigned long int)); + +#define mpq_set_str __gmpq_set_str +__GMP_DECLSPEC int mpq_set_str __GMP_PROTO ((mpq_ptr, __gmp_const char *, int)); + +#define mpq_set_ui __gmpq_set_ui +__GMP_DECLSPEC void mpq_set_ui __GMP_PROTO ((mpq_ptr, unsigned long int, unsigned long int)); + +#define mpq_set_z __gmpq_set_z +__GMP_DECLSPEC void mpq_set_z __GMP_PROTO ((mpq_ptr, mpz_srcptr)); + +#define mpq_sub __gmpq_sub +__GMP_DECLSPEC void mpq_sub __GMP_PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); + +#define mpq_swap __gmpq_swap +__GMP_DECLSPEC void mpq_swap __GMP_PROTO ((mpq_ptr, mpq_ptr)) __GMP_NOTHROW; + + +/**************** Float (i.e. F) routines. ****************/ + +#define mpf_abs __gmpf_abs +__GMP_DECLSPEC void mpf_abs __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_add __gmpf_add +__GMP_DECLSPEC void mpf_add __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); + +#define mpf_add_ui __gmpf_add_ui +__GMP_DECLSPEC void mpf_add_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); +#define mpf_ceil __gmpf_ceil +__GMP_DECLSPEC void mpf_ceil __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_clear __gmpf_clear +__GMP_DECLSPEC void mpf_clear __GMP_PROTO ((mpf_ptr)); + +#define mpf_clears __gmpf_clears +__GMP_DECLSPEC void mpf_clears __GMP_PROTO ((mpf_ptr, ...)); + +#define mpf_cmp __gmpf_cmp +__GMP_DECLSPEC int mpf_cmp __GMP_PROTO ((mpf_srcptr, mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_cmp_d __gmpf_cmp_d +__GMP_DECLSPEC int mpf_cmp_d __GMP_PROTO ((mpf_srcptr, double)) __GMP_ATTRIBUTE_PURE; + +#define mpf_cmp_si __gmpf_cmp_si +__GMP_DECLSPEC int mpf_cmp_si __GMP_PROTO ((mpf_srcptr, signed long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_cmp_ui __gmpf_cmp_ui +__GMP_DECLSPEC int mpf_cmp_ui __GMP_PROTO ((mpf_srcptr, unsigned long int)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_div __gmpf_div +__GMP_DECLSPEC void mpf_div __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); + +#define mpf_div_2exp __gmpf_div_2exp +__GMP_DECLSPEC void mpf_div_2exp __GMP_PROTO ((mpf_ptr, mpf_srcptr, mp_bitcnt_t)); + +#define mpf_div_ui __gmpf_div_ui +__GMP_DECLSPEC void mpf_div_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); + +#define mpf_dump __gmpf_dump +__GMP_DECLSPEC void mpf_dump __GMP_PROTO ((mpf_srcptr)); + +#define mpf_eq __gmpf_eq +__GMP_DECLSPEC int mpf_eq __GMP_PROTO ((mpf_srcptr, mpf_srcptr, unsigned long int)) __GMP_ATTRIBUTE_PURE; + +#define mpf_fits_sint_p __gmpf_fits_sint_p +__GMP_DECLSPEC int mpf_fits_sint_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_fits_slong_p __gmpf_fits_slong_p +__GMP_DECLSPEC int mpf_fits_slong_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_fits_sshort_p __gmpf_fits_sshort_p +__GMP_DECLSPEC int mpf_fits_sshort_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_fits_uint_p __gmpf_fits_uint_p +__GMP_DECLSPEC int mpf_fits_uint_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_fits_ulong_p __gmpf_fits_ulong_p +__GMP_DECLSPEC int mpf_fits_ulong_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_fits_ushort_p __gmpf_fits_ushort_p +__GMP_DECLSPEC int mpf_fits_ushort_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_floor __gmpf_floor +__GMP_DECLSPEC void mpf_floor __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_get_d __gmpf_get_d +__GMP_DECLSPEC double mpf_get_d __GMP_PROTO ((mpf_srcptr)) __GMP_ATTRIBUTE_PURE; + +#define mpf_get_d_2exp __gmpf_get_d_2exp +__GMP_DECLSPEC double mpf_get_d_2exp __GMP_PROTO ((signed long int *, mpf_srcptr)); + +#define mpf_get_default_prec __gmpf_get_default_prec +__GMP_DECLSPEC mp_bitcnt_t mpf_get_default_prec __GMP_PROTO ((void)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_get_prec __gmpf_get_prec +__GMP_DECLSPEC mp_bitcnt_t mpf_get_prec __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_get_si __gmpf_get_si +__GMP_DECLSPEC long mpf_get_si __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_get_str __gmpf_get_str +__GMP_DECLSPEC char *mpf_get_str __GMP_PROTO ((char *, mp_exp_t *, int, size_t, mpf_srcptr)); + +#define mpf_get_ui __gmpf_get_ui +__GMP_DECLSPEC unsigned long mpf_get_ui __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_init __gmpf_init +__GMP_DECLSPEC void mpf_init __GMP_PROTO ((mpf_ptr)); + +#define mpf_init2 __gmpf_init2 +__GMP_DECLSPEC void mpf_init2 __GMP_PROTO ((mpf_ptr, mp_bitcnt_t)); + +#define mpf_inits __gmpf_inits +__GMP_DECLSPEC void mpf_inits __GMP_PROTO ((mpf_ptr, ...)); + +#define mpf_init_set __gmpf_init_set +__GMP_DECLSPEC void mpf_init_set __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_init_set_d __gmpf_init_set_d +__GMP_DECLSPEC void mpf_init_set_d __GMP_PROTO ((mpf_ptr, double)); + +#define mpf_init_set_si __gmpf_init_set_si +__GMP_DECLSPEC void mpf_init_set_si __GMP_PROTO ((mpf_ptr, signed long int)); + +#define mpf_init_set_str __gmpf_init_set_str +__GMP_DECLSPEC int mpf_init_set_str __GMP_PROTO ((mpf_ptr, __gmp_const char *, int)); + +#define mpf_init_set_ui __gmpf_init_set_ui +__GMP_DECLSPEC void mpf_init_set_ui __GMP_PROTO ((mpf_ptr, unsigned long int)); + +#define mpf_inp_str __gmpf_inp_str +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpf_inp_str __GMP_PROTO ((mpf_ptr, FILE *, int)); +#endif + +#define mpf_integer_p __gmpf_integer_p +__GMP_DECLSPEC int mpf_integer_p __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_mul __gmpf_mul +__GMP_DECLSPEC void mpf_mul __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); + +#define mpf_mul_2exp __gmpf_mul_2exp +__GMP_DECLSPEC void mpf_mul_2exp __GMP_PROTO ((mpf_ptr, mpf_srcptr, mp_bitcnt_t)); + +#define mpf_mul_ui __gmpf_mul_ui +__GMP_DECLSPEC void mpf_mul_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); + +#define mpf_neg __gmpf_neg +__GMP_DECLSPEC void mpf_neg __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_out_str __gmpf_out_str +#ifdef _GMP_H_HAVE_FILE +__GMP_DECLSPEC size_t mpf_out_str __GMP_PROTO ((FILE *, int, size_t, mpf_srcptr)); +#endif + +#define mpf_pow_ui __gmpf_pow_ui +__GMP_DECLSPEC void mpf_pow_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); + +#define mpf_random2 __gmpf_random2 +__GMP_DECLSPEC void mpf_random2 __GMP_PROTO ((mpf_ptr, mp_size_t, mp_exp_t)); + +#define mpf_reldiff __gmpf_reldiff +__GMP_DECLSPEC void mpf_reldiff __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); + +#define mpf_set __gmpf_set +__GMP_DECLSPEC void mpf_set __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_set_d __gmpf_set_d +__GMP_DECLSPEC void mpf_set_d __GMP_PROTO ((mpf_ptr, double)); + +#define mpf_set_default_prec __gmpf_set_default_prec +__GMP_DECLSPEC void mpf_set_default_prec __GMP_PROTO ((mp_bitcnt_t)) __GMP_NOTHROW; + +#define mpf_set_prec __gmpf_set_prec +__GMP_DECLSPEC void mpf_set_prec __GMP_PROTO ((mpf_ptr, mp_bitcnt_t)); + +#define mpf_set_prec_raw __gmpf_set_prec_raw +__GMP_DECLSPEC void mpf_set_prec_raw __GMP_PROTO ((mpf_ptr, mp_bitcnt_t)) __GMP_NOTHROW; + +#define mpf_set_q __gmpf_set_q +__GMP_DECLSPEC void mpf_set_q __GMP_PROTO ((mpf_ptr, mpq_srcptr)); + +#define mpf_set_si __gmpf_set_si +__GMP_DECLSPEC void mpf_set_si __GMP_PROTO ((mpf_ptr, signed long int)); + +#define mpf_set_str __gmpf_set_str +__GMP_DECLSPEC int mpf_set_str __GMP_PROTO ((mpf_ptr, __gmp_const char *, int)); + +#define mpf_set_ui __gmpf_set_ui +__GMP_DECLSPEC void mpf_set_ui __GMP_PROTO ((mpf_ptr, unsigned long int)); + +#define mpf_set_z __gmpf_set_z +__GMP_DECLSPEC void mpf_set_z __GMP_PROTO ((mpf_ptr, mpz_srcptr)); + +#define mpf_size __gmpf_size +__GMP_DECLSPEC size_t mpf_size __GMP_PROTO ((mpf_srcptr)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpf_sqrt __gmpf_sqrt +__GMP_DECLSPEC void mpf_sqrt __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_sqrt_ui __gmpf_sqrt_ui +__GMP_DECLSPEC void mpf_sqrt_ui __GMP_PROTO ((mpf_ptr, unsigned long int)); + +#define mpf_sub __gmpf_sub +__GMP_DECLSPEC void mpf_sub __GMP_PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); + +#define mpf_sub_ui __gmpf_sub_ui +__GMP_DECLSPEC void mpf_sub_ui __GMP_PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); + +#define mpf_swap __gmpf_swap +__GMP_DECLSPEC void mpf_swap __GMP_PROTO ((mpf_ptr, mpf_ptr)) __GMP_NOTHROW; + +#define mpf_trunc __gmpf_trunc +__GMP_DECLSPEC void mpf_trunc __GMP_PROTO ((mpf_ptr, mpf_srcptr)); + +#define mpf_ui_div __gmpf_ui_div +__GMP_DECLSPEC void mpf_ui_div __GMP_PROTO ((mpf_ptr, unsigned long int, mpf_srcptr)); + +#define mpf_ui_sub __gmpf_ui_sub +__GMP_DECLSPEC void mpf_ui_sub __GMP_PROTO ((mpf_ptr, unsigned long int, mpf_srcptr)); + +#define mpf_urandomb __gmpf_urandomb +__GMP_DECLSPEC void mpf_urandomb __GMP_PROTO ((mpf_t, gmp_randstate_t, mp_bitcnt_t)); + + +/************ Low level positive-integer (i.e. N) routines. ************/ + +/* This is ugly, but we need to make user calls reach the prefixed function. */ + +#define mpn_add __MPN(add) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_add) +__GMP_DECLSPEC mp_limb_t mpn_add __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t)); +#endif + +#define mpn_add_1 __MPN(add_1) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_add_1) +__GMP_DECLSPEC mp_limb_t mpn_add_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)) __GMP_NOTHROW; +#endif + +#define mpn_add_n __MPN(add_n) +__GMP_DECLSPEC mp_limb_t mpn_add_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); + +#define mpn_addmul_1 __MPN(addmul_1) +__GMP_DECLSPEC mp_limb_t mpn_addmul_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); + +#define mpn_cmp __MPN(cmp) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_cmp) +__GMP_DECLSPEC int mpn_cmp __GMP_PROTO ((mp_srcptr, mp_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; +#endif + +#define mpn_divexact_by3(dst,src,size) \ + mpn_divexact_by3c (dst, src, size, __GMP_CAST (mp_limb_t, 0)) + +#define mpn_divexact_by3c __MPN(divexact_by3c) +__GMP_DECLSPEC mp_limb_t mpn_divexact_by3c __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); + +#define mpn_divmod_1(qp,np,nsize,dlimb) \ + mpn_divrem_1 (qp, __GMP_CAST (mp_size_t, 0), np, nsize, dlimb) + +#define mpn_divrem __MPN(divrem) +__GMP_DECLSPEC mp_limb_t mpn_divrem __GMP_PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t)); + +#define mpn_divrem_1 __MPN(divrem_1) +__GMP_DECLSPEC mp_limb_t mpn_divrem_1 __GMP_PROTO ((mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t)); + +#define mpn_divrem_2 __MPN(divrem_2) +__GMP_DECLSPEC mp_limb_t mpn_divrem_2 __GMP_PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr)); + +#define mpn_gcd __MPN(gcd) +__GMP_DECLSPEC mp_size_t mpn_gcd __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t)); + +#define mpn_gcd_1 __MPN(gcd_1) +__GMP_DECLSPEC mp_limb_t mpn_gcd_1 __GMP_PROTO ((mp_srcptr, mp_size_t, mp_limb_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_gcdext_1 __MPN(gcdext_1) +__GMP_DECLSPEC mp_limb_t mpn_gcdext_1 __GMP_PROTO ((mp_limb_signed_t *, mp_limb_signed_t *, mp_limb_t, mp_limb_t)); + +#define mpn_gcdext __MPN(gcdext) +__GMP_DECLSPEC mp_size_t mpn_gcdext __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t)); + +#define mpn_get_str __MPN(get_str) +__GMP_DECLSPEC size_t mpn_get_str __GMP_PROTO ((unsigned char *, int, mp_ptr, mp_size_t)); + +#define mpn_hamdist __MPN(hamdist) +__GMP_DECLSPEC mp_bitcnt_t mpn_hamdist __GMP_PROTO ((mp_srcptr, mp_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpn_lshift __MPN(lshift) +__GMP_DECLSPEC mp_limb_t mpn_lshift __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int)); + +#define mpn_mod_1 __MPN(mod_1) +__GMP_DECLSPEC mp_limb_t mpn_mod_1 __GMP_PROTO ((mp_srcptr, mp_size_t, mp_limb_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_mul __MPN(mul) +__GMP_DECLSPEC mp_limb_t mpn_mul __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t)); + +#define mpn_mul_1 __MPN(mul_1) +__GMP_DECLSPEC mp_limb_t mpn_mul_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); + +#define mpn_mul_n __MPN(mul_n) +__GMP_DECLSPEC void mpn_mul_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); + +#define mpn_sqr __MPN(sqr) +__GMP_DECLSPEC void mpn_sqr __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t)); + +#define mpn_neg __MPN(neg) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_neg) +__GMP_DECLSPEC mp_limb_t mpn_neg __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t)); +#endif + +#define mpn_com __MPN(com) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_com) +__GMP_DECLSPEC void mpn_com __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t)); +#endif + +#define mpn_perfect_square_p __MPN(perfect_square_p) +__GMP_DECLSPEC int mpn_perfect_square_p __GMP_PROTO ((mp_srcptr, mp_size_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_perfect_power_p __MPN(perfect_power_p) +__GMP_DECLSPEC int mpn_perfect_power_p __GMP_PROTO ((mp_srcptr, mp_size_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_popcount __MPN(popcount) +__GMP_DECLSPEC mp_bitcnt_t mpn_popcount __GMP_PROTO ((mp_srcptr, mp_size_t)) __GMP_NOTHROW __GMP_ATTRIBUTE_PURE; + +#define mpn_pow_1 __MPN(pow_1) +__GMP_DECLSPEC mp_size_t mpn_pow_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr)); + +/* undocumented now, but retained here for upward compatibility */ +#define mpn_preinv_mod_1 __MPN(preinv_mod_1) +__GMP_DECLSPEC mp_limb_t mpn_preinv_mod_1 __GMP_PROTO ((mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_random __MPN(random) +__GMP_DECLSPEC void mpn_random __GMP_PROTO ((mp_ptr, mp_size_t)); + +#define mpn_random2 __MPN(random2) +__GMP_DECLSPEC void mpn_random2 __GMP_PROTO ((mp_ptr, mp_size_t)); + +#define mpn_rshift __MPN(rshift) +__GMP_DECLSPEC mp_limb_t mpn_rshift __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int)); + +#define mpn_scan0 __MPN(scan0) +__GMP_DECLSPEC mp_bitcnt_t mpn_scan0 __GMP_PROTO ((mp_srcptr, mp_bitcnt_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_scan1 __MPN(scan1) +__GMP_DECLSPEC mp_bitcnt_t mpn_scan1 __GMP_PROTO ((mp_srcptr, mp_bitcnt_t)) __GMP_ATTRIBUTE_PURE; + +#define mpn_set_str __MPN(set_str) +__GMP_DECLSPEC mp_size_t mpn_set_str __GMP_PROTO ((mp_ptr, __gmp_const unsigned char *, size_t, int)); + +#define mpn_sqrtrem __MPN(sqrtrem) +__GMP_DECLSPEC mp_size_t mpn_sqrtrem __GMP_PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t)); + +#define mpn_sub __MPN(sub) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_sub) +__GMP_DECLSPEC mp_limb_t mpn_sub __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t)); +#endif + +#define mpn_sub_1 __MPN(sub_1) +#if __GMP_INLINE_PROTOTYPES || defined (__GMP_FORCE_mpn_sub_1) +__GMP_DECLSPEC mp_limb_t mpn_sub_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)) __GMP_NOTHROW; +#endif + +#define mpn_sub_n __MPN(sub_n) +__GMP_DECLSPEC mp_limb_t mpn_sub_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); + +#define mpn_submul_1 __MPN(submul_1) +__GMP_DECLSPEC mp_limb_t mpn_submul_1 __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); + +#define mpn_tdiv_qr __MPN(tdiv_qr) +__GMP_DECLSPEC void mpn_tdiv_qr __GMP_PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t)); + +#define mpn_and_n __MPN(and_n) +__GMP_DECLSPEC void mpn_and_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_andn_n __MPN(andn_n) +__GMP_DECLSPEC void mpn_andn_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_nand_n __MPN(nand_n) +__GMP_DECLSPEC void mpn_nand_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_ior_n __MPN(ior_n) +__GMP_DECLSPEC void mpn_ior_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_iorn_n __MPN(iorn_n) +__GMP_DECLSPEC void mpn_iorn_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_nior_n __MPN(nior_n) +__GMP_DECLSPEC void mpn_nior_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_xor_n __MPN(xor_n) +__GMP_DECLSPEC void mpn_xor_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); +#define mpn_xnor_n __MPN(xnor_n) +__GMP_DECLSPEC void mpn_xnor_n __GMP_PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); + +#define mpn_copyi __MPN(copyi) +__GMP_DECLSPEC void mpn_copyi __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t)); +#define mpn_copyd __MPN(copyd) +__GMP_DECLSPEC void mpn_copyd __GMP_PROTO ((mp_ptr, mp_srcptr, mp_size_t)); +#define mpn_zero __MPN(zero) +__GMP_DECLSPEC void mpn_zero __GMP_PROTO ((mp_ptr, mp_size_t)); + +/**************** mpz inlines ****************/ + +/* The following are provided as inlines where possible, but always exist as + library functions too, for binary compatibility. + + Within gmp itself this inlining generally isn't relied on, since it + doesn't get done for all compilers, whereas if something is worth + inlining then it's worth arranging always. + + There are two styles of inlining here. When the same bit of code is + wanted for the inline as for the library version, then __GMP_FORCE_foo + arranges for that code to be emitted and the __GMP_EXTERN_INLINE + directive suppressed, eg. mpz_fits_uint_p. When a different bit of code + is wanted for the inline than for the library version, then + __GMP_FORCE_foo arranges the inline to be suppressed, eg. mpz_abs. */ + +#if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpz_abs) +__GMP_EXTERN_INLINE void +mpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u) +{ + if (__gmp_w != __gmp_u) + mpz_set (__gmp_w, __gmp_u); + __gmp_w->_mp_size = __GMP_ABS (__gmp_w->_mp_size); +} +#endif + +#if GMP_NAIL_BITS == 0 +#define __GMPZ_FITS_UTYPE_P(z,maxval) \ + mp_size_t __gmp_n = z->_mp_size; \ + mp_ptr __gmp_p = z->_mp_d; \ + return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= maxval)); +#else +#define __GMPZ_FITS_UTYPE_P(z,maxval) \ + mp_size_t __gmp_n = z->_mp_size; \ + mp_ptr __gmp_p = z->_mp_d; \ + return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= maxval) \ + || (__gmp_n == 2 && __gmp_p[1] <= ((mp_limb_t) maxval >> GMP_NUMB_BITS))); +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_fits_uint_p) +#if ! defined (__GMP_FORCE_mpz_fits_uint_p) +__GMP_EXTERN_INLINE +#endif +int +mpz_fits_uint_p (mpz_srcptr __gmp_z) __GMP_NOTHROW +{ + __GMPZ_FITS_UTYPE_P (__gmp_z, __GMP_UINT_MAX); +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_fits_ulong_p) +#if ! defined (__GMP_FORCE_mpz_fits_ulong_p) +__GMP_EXTERN_INLINE +#endif +int +mpz_fits_ulong_p (mpz_srcptr __gmp_z) __GMP_NOTHROW +{ + __GMPZ_FITS_UTYPE_P (__gmp_z, __GMP_ULONG_MAX); +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_fits_ushort_p) +#if ! defined (__GMP_FORCE_mpz_fits_ushort_p) +__GMP_EXTERN_INLINE +#endif +int +mpz_fits_ushort_p (mpz_srcptr __gmp_z) __GMP_NOTHROW +{ + __GMPZ_FITS_UTYPE_P (__gmp_z, __GMP_USHRT_MAX); +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_get_ui) +#if ! defined (__GMP_FORCE_mpz_get_ui) +__GMP_EXTERN_INLINE +#endif +unsigned long +mpz_get_ui (mpz_srcptr __gmp_z) __GMP_NOTHROW +{ + mp_ptr __gmp_p = __gmp_z->_mp_d; + mp_size_t __gmp_n = __gmp_z->_mp_size; + mp_limb_t __gmp_l = __gmp_p[0]; + /* This is a "#if" rather than a plain "if" so as to avoid gcc warnings + about "<< GMP_NUMB_BITS" exceeding the type size, and to avoid Borland + C++ 6.0 warnings about condition always true for something like + "__GMP_ULONG_MAX < GMP_NUMB_MASK". */ +#if GMP_NAIL_BITS == 0 || defined (_LONG_LONG_LIMB) + /* limb==long and no nails, or limb==longlong, one limb is enough */ + return (__gmp_n != 0 ? __gmp_l : 0); +#else + /* limb==long and nails, need two limbs when available */ + __gmp_n = __GMP_ABS (__gmp_n); + if (__gmp_n <= 1) + return (__gmp_n != 0 ? __gmp_l : 0); + else + return __gmp_l + (__gmp_p[1] << GMP_NUMB_BITS); +#endif +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_getlimbn) +#if ! defined (__GMP_FORCE_mpz_getlimbn) +__GMP_EXTERN_INLINE +#endif +mp_limb_t +mpz_getlimbn (mpz_srcptr __gmp_z, mp_size_t __gmp_n) __GMP_NOTHROW +{ + mp_limb_t __gmp_result = 0; + if (__GMP_LIKELY (__gmp_n >= 0 && __gmp_n < __GMP_ABS (__gmp_z->_mp_size))) + __gmp_result = __gmp_z->_mp_d[__gmp_n]; + return __gmp_result; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpz_neg) +__GMP_EXTERN_INLINE void +mpz_neg (mpz_ptr __gmp_w, mpz_srcptr __gmp_u) +{ + if (__gmp_w != __gmp_u) + mpz_set (__gmp_w, __gmp_u); + __gmp_w->_mp_size = - __gmp_w->_mp_size; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_perfect_square_p) +#if ! defined (__GMP_FORCE_mpz_perfect_square_p) +__GMP_EXTERN_INLINE +#endif +int +mpz_perfect_square_p (mpz_srcptr __gmp_a) +{ + mp_size_t __gmp_asize; + int __gmp_result; + + __gmp_asize = __gmp_a->_mp_size; + __gmp_result = (__gmp_asize >= 0); /* zero is a square, negatives are not */ + if (__GMP_LIKELY (__gmp_asize > 0)) + __gmp_result = mpn_perfect_square_p (__gmp_a->_mp_d, __gmp_asize); + return __gmp_result; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_popcount) +#if ! defined (__GMP_FORCE_mpz_popcount) +__GMP_EXTERN_INLINE +#endif +mp_bitcnt_t +mpz_popcount (mpz_srcptr __gmp_u) __GMP_NOTHROW +{ + mp_size_t __gmp_usize; + mp_bitcnt_t __gmp_result; + + __gmp_usize = __gmp_u->_mp_size; + __gmp_result = (__gmp_usize < 0 ? __GMP_ULONG_MAX : 0); + if (__GMP_LIKELY (__gmp_usize > 0)) + __gmp_result = mpn_popcount (__gmp_u->_mp_d, __gmp_usize); + return __gmp_result; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_set_q) +#if ! defined (__GMP_FORCE_mpz_set_q) +__GMP_EXTERN_INLINE +#endif +void +mpz_set_q (mpz_ptr __gmp_w, mpq_srcptr __gmp_u) +{ + mpz_tdiv_q (__gmp_w, mpq_numref (__gmp_u), mpq_denref (__gmp_u)); +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpz_size) +#if ! defined (__GMP_FORCE_mpz_size) +__GMP_EXTERN_INLINE +#endif +size_t +mpz_size (mpz_srcptr __gmp_z) __GMP_NOTHROW +{ + return __GMP_ABS (__gmp_z->_mp_size); +} +#endif + + +/**************** mpq inlines ****************/ + +#if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpq_abs) +__GMP_EXTERN_INLINE void +mpq_abs (mpq_ptr __gmp_w, mpq_srcptr __gmp_u) +{ + if (__gmp_w != __gmp_u) + mpq_set (__gmp_w, __gmp_u); + __gmp_w->_mp_num._mp_size = __GMP_ABS (__gmp_w->_mp_num._mp_size); +} +#endif + +#if defined (__GMP_EXTERN_INLINE) && ! defined (__GMP_FORCE_mpq_neg) +__GMP_EXTERN_INLINE void +mpq_neg (mpq_ptr __gmp_w, mpq_srcptr __gmp_u) +{ + if (__gmp_w != __gmp_u) + mpq_set (__gmp_w, __gmp_u); + __gmp_w->_mp_num._mp_size = - __gmp_w->_mp_num._mp_size; +} +#endif + + +/**************** mpn inlines ****************/ + +/* The comments with __GMPN_ADD_1 below apply here too. + + The test for FUNCTION returning 0 should predict well. If it's assumed + {yp,ysize} will usually have a random number of bits then the high limb + won't be full and a carry out will occur a good deal less than 50% of the + time. + + ysize==0 isn't a documented feature, but is used internally in a few + places. + + Producing cout last stops it using up a register during the main part of + the calculation, though gcc (as of 3.0) on an "if (mpn_add (...))" + doesn't seem able to move the true and false legs of the conditional up + to the two places cout is generated. */ + +#define __GMPN_AORS(cout, wp, xp, xsize, yp, ysize, FUNCTION, TEST) \ + do { \ + mp_size_t __gmp_i; \ + mp_limb_t __gmp_x; \ + \ + /* ASSERT ((ysize) >= 0); */ \ + /* ASSERT ((xsize) >= (ysize)); */ \ + /* ASSERT (MPN_SAME_OR_SEPARATE2_P (wp, xsize, xp, xsize)); */ \ + /* ASSERT (MPN_SAME_OR_SEPARATE2_P (wp, xsize, yp, ysize)); */ \ + \ + __gmp_i = (ysize); \ + if (__gmp_i != 0) \ + { \ + if (FUNCTION (wp, xp, yp, __gmp_i)) \ + { \ + do \ + { \ + if (__gmp_i >= (xsize)) \ + { \ + (cout) = 1; \ + goto __gmp_done; \ + } \ + __gmp_x = (xp)[__gmp_i]; \ + } \ + while (TEST); \ + } \ + } \ + if ((wp) != (xp)) \ + __GMPN_COPY_REST (wp, xp, xsize, __gmp_i); \ + (cout) = 0; \ + __gmp_done: \ + ; \ + } while (0) + +#define __GMPN_ADD(cout, wp, xp, xsize, yp, ysize) \ + __GMPN_AORS (cout, wp, xp, xsize, yp, ysize, mpn_add_n, \ + (((wp)[__gmp_i++] = (__gmp_x + 1) & GMP_NUMB_MASK) == 0)) +#define __GMPN_SUB(cout, wp, xp, xsize, yp, ysize) \ + __GMPN_AORS (cout, wp, xp, xsize, yp, ysize, mpn_sub_n, \ + (((wp)[__gmp_i++] = (__gmp_x - 1) & GMP_NUMB_MASK), __gmp_x == 0)) + + +/* The use of __gmp_i indexing is designed to ensure a compile time src==dst + remains nice and clear to the compiler, so that __GMPN_COPY_REST can + disappear, and the load/add/store gets a chance to become a + read-modify-write on CISC CPUs. + + Alternatives: + + Using a pair of pointers instead of indexing would be possible, but gcc + isn't able to recognise compile-time src==dst in that case, even when the + pointers are incremented more or less together. Other compilers would + very likely have similar difficulty. + + gcc could use "if (__builtin_constant_p(src==dst) && src==dst)" or + similar to detect a compile-time src==dst. This works nicely on gcc + 2.95.x, it's not good on gcc 3.0 where __builtin_constant_p(p==p) seems + to be always false, for a pointer p. But the current code form seems + good enough for src==dst anyway. + + gcc on x86 as usual doesn't give particularly good flags handling for the + carry/borrow detection. It's tempting to want some multi instruction asm + blocks to help it, and this was tried, but in truth there's only a few + instructions to save and any gain is all too easily lost by register + juggling setting up for the asm. */ + +#if GMP_NAIL_BITS == 0 +#define __GMPN_AORS_1(cout, dst, src, n, v, OP, CB) \ + do { \ + mp_size_t __gmp_i; \ + mp_limb_t __gmp_x, __gmp_r; \ + \ + /* ASSERT ((n) >= 1); */ \ + /* ASSERT (MPN_SAME_OR_SEPARATE_P (dst, src, n)); */ \ + \ + __gmp_x = (src)[0]; \ + __gmp_r = __gmp_x OP (v); \ + (dst)[0] = __gmp_r; \ + if (CB (__gmp_r, __gmp_x, (v))) \ + { \ + (cout) = 1; \ + for (__gmp_i = 1; __gmp_i < (n);) \ + { \ + __gmp_x = (src)[__gmp_i]; \ + __gmp_r = __gmp_x OP 1; \ + (dst)[__gmp_i] = __gmp_r; \ + ++__gmp_i; \ + if (!CB (__gmp_r, __gmp_x, 1)) \ + { \ + if ((src) != (dst)) \ + __GMPN_COPY_REST (dst, src, n, __gmp_i); \ + (cout) = 0; \ + break; \ + } \ + } \ + } \ + else \ + { \ + if ((src) != (dst)) \ + __GMPN_COPY_REST (dst, src, n, 1); \ + (cout) = 0; \ + } \ + } while (0) +#endif + +#if GMP_NAIL_BITS >= 1 +#define __GMPN_AORS_1(cout, dst, src, n, v, OP, CB) \ + do { \ + mp_size_t __gmp_i; \ + mp_limb_t __gmp_x, __gmp_r; \ + \ + /* ASSERT ((n) >= 1); */ \ + /* ASSERT (MPN_SAME_OR_SEPARATE_P (dst, src, n)); */ \ + \ + __gmp_x = (src)[0]; \ + __gmp_r = __gmp_x OP (v); \ + (dst)[0] = __gmp_r & GMP_NUMB_MASK; \ + if (__gmp_r >> GMP_NUMB_BITS != 0) \ + { \ + (cout) = 1; \ + for (__gmp_i = 1; __gmp_i < (n);) \ + { \ + __gmp_x = (src)[__gmp_i]; \ + __gmp_r = __gmp_x OP 1; \ + (dst)[__gmp_i] = __gmp_r & GMP_NUMB_MASK; \ + ++__gmp_i; \ + if (__gmp_r >> GMP_NUMB_BITS == 0) \ + { \ + if ((src) != (dst)) \ + __GMPN_COPY_REST (dst, src, n, __gmp_i); \ + (cout) = 0; \ + break; \ + } \ + } \ + } \ + else \ + { \ + if ((src) != (dst)) \ + __GMPN_COPY_REST (dst, src, n, 1); \ + (cout) = 0; \ + } \ + } while (0) +#endif + +#define __GMPN_ADDCB(r,x,y) ((r) < (y)) +#define __GMPN_SUBCB(r,x,y) ((x) < (y)) + +#define __GMPN_ADD_1(cout, dst, src, n, v) \ + __GMPN_AORS_1(cout, dst, src, n, v, +, __GMPN_ADDCB) +#define __GMPN_SUB_1(cout, dst, src, n, v) \ + __GMPN_AORS_1(cout, dst, src, n, v, -, __GMPN_SUBCB) + + +/* Compare {xp,size} and {yp,size}, setting "result" to positive, zero or + negative. size==0 is allowed. On random data usually only one limb will + need to be examined to get a result, so it's worth having it inline. */ +#define __GMPN_CMP(result, xp, yp, size) \ + do { \ + mp_size_t __gmp_i; \ + mp_limb_t __gmp_x, __gmp_y; \ + \ + /* ASSERT ((size) >= 0); */ \ + \ + (result) = 0; \ + __gmp_i = (size); \ + while (--__gmp_i >= 0) \ + { \ + __gmp_x = (xp)[__gmp_i]; \ + __gmp_y = (yp)[__gmp_i]; \ + if (__gmp_x != __gmp_y) \ + { \ + /* Cannot use __gmp_x - __gmp_y, may overflow an "int" */ \ + (result) = (__gmp_x > __gmp_y ? 1 : -1); \ + break; \ + } \ + } \ + } while (0) + + +#if defined (__GMPN_COPY) && ! defined (__GMPN_COPY_REST) +#define __GMPN_COPY_REST(dst, src, size, start) \ + do { \ + /* ASSERT ((start) >= 0); */ \ + /* ASSERT ((start) <= (size)); */ \ + __GMPN_COPY ((dst)+(start), (src)+(start), (size)-(start)); \ + } while (0) +#endif + +/* Copy {src,size} to {dst,size}, starting at "start". This is designed to + keep the indexing dst[j] and src[j] nice and simple for __GMPN_ADD_1, + __GMPN_ADD, etc. */ +#if ! defined (__GMPN_COPY_REST) +#define __GMPN_COPY_REST(dst, src, size, start) \ + do { \ + mp_size_t __gmp_j; \ + /* ASSERT ((size) >= 0); */ \ + /* ASSERT ((start) >= 0); */ \ + /* ASSERT ((start) <= (size)); */ \ + /* ASSERT (MPN_SAME_OR_SEPARATE_P (dst, src, size)); */ \ + __GMP_CRAY_Pragma ("_CRI ivdep"); \ + for (__gmp_j = (start); __gmp_j < (size); __gmp_j++) \ + (dst)[__gmp_j] = (src)[__gmp_j]; \ + } while (0) +#endif + +/* Enhancement: Use some of the smarter code from gmp-impl.h. Maybe use + mpn_copyi if there's a native version, and if we don't mind demanding + binary compatibility for it (on targets which use it). */ + +#if ! defined (__GMPN_COPY) +#define __GMPN_COPY(dst, src, size) __GMPN_COPY_REST (dst, src, size, 0) +#endif + + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_add) +#if ! defined (__GMP_FORCE_mpn_add) +__GMP_EXTERN_INLINE +#endif +mp_limb_t +mpn_add (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize) +{ + mp_limb_t __gmp_c; + __GMPN_ADD (__gmp_c, __gmp_wp, __gmp_xp, __gmp_xsize, __gmp_yp, __gmp_ysize); + return __gmp_c; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_add_1) +#if ! defined (__GMP_FORCE_mpn_add_1) +__GMP_EXTERN_INLINE +#endif +mp_limb_t +mpn_add_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) __GMP_NOTHROW +{ + mp_limb_t __gmp_c; + __GMPN_ADD_1 (__gmp_c, __gmp_dst, __gmp_src, __gmp_size, __gmp_n); + return __gmp_c; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_cmp) +#if ! defined (__GMP_FORCE_mpn_cmp) +__GMP_EXTERN_INLINE +#endif +int +mpn_cmp (mp_srcptr __gmp_xp, mp_srcptr __gmp_yp, mp_size_t __gmp_size) __GMP_NOTHROW +{ + int __gmp_result; + __GMPN_CMP (__gmp_result, __gmp_xp, __gmp_yp, __gmp_size); + return __gmp_result; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_sub) +#if ! defined (__GMP_FORCE_mpn_sub) +__GMP_EXTERN_INLINE +#endif +mp_limb_t +mpn_sub (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize) +{ + mp_limb_t __gmp_c; + __GMPN_SUB (__gmp_c, __gmp_wp, __gmp_xp, __gmp_xsize, __gmp_yp, __gmp_ysize); + return __gmp_c; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_sub_1) +#if ! defined (__GMP_FORCE_mpn_sub_1) +__GMP_EXTERN_INLINE +#endif +mp_limb_t +mpn_sub_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) __GMP_NOTHROW +{ + mp_limb_t __gmp_c; + __GMPN_SUB_1 (__gmp_c, __gmp_dst, __gmp_src, __gmp_size, __gmp_n); + return __gmp_c; +} +#endif + +#if defined (__GMP_EXTERN_INLINE) || defined (__GMP_FORCE_mpn_neg) +#if ! defined (__GMP_FORCE_mpn_neg) +__GMP_EXTERN_INLINE +#endif +mp_limb_t +mpn_neg (mp_ptr __gmp_rp, mp_srcptr __gmp_up, mp_size_t __gmp_n) +{ + mp_limb_t __gmp_ul, __gmp_cy; + __gmp_cy = 0; + do { + __gmp_ul = *__gmp_up++; + *__gmp_rp++ = -__gmp_ul - __gmp_cy; + __gmp_cy |= __gmp_ul != 0; + } while (--__gmp_n != 0); + return __gmp_cy; +} +#endif + +#if defined (__cplusplus) +} +#endif + + +/* Allow faster testing for negative, zero, and positive. */ +#define mpz_sgn(Z) ((Z)->_mp_size < 0 ? -1 : (Z)->_mp_size > 0) +#define mpf_sgn(F) ((F)->_mp_size < 0 ? -1 : (F)->_mp_size > 0) +#define mpq_sgn(Q) ((Q)->_mp_num._mp_size < 0 ? -1 : (Q)->_mp_num._mp_size > 0) + +/* When using GCC, optimize certain common comparisons. */ +#if defined (__GNUC__) && __GNUC__ >= 2 +#define mpz_cmp_ui(Z,UI) \ + (__builtin_constant_p (UI) && (UI) == 0 \ + ? mpz_sgn (Z) : _mpz_cmp_ui (Z,UI)) +#define mpz_cmp_si(Z,SI) \ + (__builtin_constant_p (SI) && (SI) == 0 ? mpz_sgn (Z) \ + : __builtin_constant_p (SI) && (SI) > 0 \ + ? _mpz_cmp_ui (Z, __GMP_CAST (unsigned long int, SI)) \ + : _mpz_cmp_si (Z,SI)) +#define mpq_cmp_ui(Q,NUI,DUI) \ + (__builtin_constant_p (NUI) && (NUI) == 0 \ + ? mpq_sgn (Q) : _mpq_cmp_ui (Q,NUI,DUI)) +#define mpq_cmp_si(q,n,d) \ + (__builtin_constant_p ((n) >= 0) && (n) >= 0 \ + ? mpq_cmp_ui (q, __GMP_CAST (unsigned long, n), d) \ + : _mpq_cmp_si (q, n, d)) +#else +#define mpz_cmp_ui(Z,UI) _mpz_cmp_ui (Z,UI) +#define mpz_cmp_si(Z,UI) _mpz_cmp_si (Z,UI) +#define mpq_cmp_ui(Q,NUI,DUI) _mpq_cmp_ui (Q,NUI,DUI) +#define mpq_cmp_si(q,n,d) _mpq_cmp_si(q,n,d) +#endif + + +/* Using "&" rather than "&&" means these can come out branch-free. Every + mpz_t has at least one limb allocated, so fetching the low limb is always + allowed. */ +#define mpz_odd_p(z) (((z)->_mp_size != 0) & __GMP_CAST (int, (z)->_mp_d[0])) +#define mpz_even_p(z) (! mpz_odd_p (z)) + + +/**************** C++ routines ****************/ + +#ifdef __cplusplus +__GMP_DECLSPEC_XX std::ostream& operator<< (std::ostream &, mpz_srcptr); +__GMP_DECLSPEC_XX std::ostream& operator<< (std::ostream &, mpq_srcptr); +__GMP_DECLSPEC_XX std::ostream& operator<< (std::ostream &, mpf_srcptr); +__GMP_DECLSPEC_XX std::istream& operator>> (std::istream &, mpz_ptr); +__GMP_DECLSPEC_XX std::istream& operator>> (std::istream &, mpq_ptr); +__GMP_DECLSPEC_XX std::istream& operator>> (std::istream &, mpf_ptr); +#endif + + +/* Source-level compatibility with GMP 2 and earlier. */ +#define mpn_divmod(qp,np,nsize,dp,dsize) \ + mpn_divrem (qp, __GMP_CAST (mp_size_t, 0), np, nsize, dp, dsize) + +/* Source-level compatibility with GMP 1. */ +#define mpz_mdiv mpz_fdiv_q +#define mpz_mdivmod mpz_fdiv_qr +#define mpz_mmod mpz_fdiv_r +#define mpz_mdiv_ui mpz_fdiv_q_ui +#define mpz_mdivmod_ui(q,r,n,d) \ + (((r) == 0) ? mpz_fdiv_q_ui (q,n,d) : mpz_fdiv_qr_ui (q,r,n,d)) +#define mpz_mmod_ui(r,n,d) \ + (((r) == 0) ? mpz_fdiv_ui (n,d) : mpz_fdiv_r_ui (r,n,d)) + +/* Useful synonyms, but not quite compatible with GMP 1. */ +#define mpz_div mpz_fdiv_q +#define mpz_divmod mpz_fdiv_qr +#define mpz_div_ui mpz_fdiv_q_ui +#define mpz_divmod_ui mpz_fdiv_qr_ui +#define mpz_div_2exp mpz_fdiv_q_2exp +#define mpz_mod_2exp mpz_fdiv_r_2exp + +enum +{ + GMP_ERROR_NONE = 0, + GMP_ERROR_UNSUPPORTED_ARGUMENT = 1, + GMP_ERROR_DIVISION_BY_ZERO = 2, + GMP_ERROR_SQRT_OF_NEGATIVE = 4, + GMP_ERROR_INVALID_ARGUMENT = 8 +}; + +/* Define CC and CFLAGS which were used to build this version of GMP */ +#define __GMP_CC "x86_64-w64-mingw32-gcc" +#define __GMP_CFLAGS "-O2 -pedantic -m64 -std=gnu99 -mtune=k8 -march=k8" + +/* Major version number is the value of __GNU_MP__ too, above and in mp.h. */ +#define __GNU_MP_VERSION 5 +#define __GNU_MP_VERSION_MINOR 0 +#define __GNU_MP_VERSION_PATCHLEVEL 1 +#define __GMP_MP_RELEASE (__GNU_MP_VERSION * 10000 + __GNU_MP_VERSION_MINOR * 100 + __GNU_MP_VERSION_PATCHLEVEL) + +#define __GMP_H__ +#endif /* __GMP_H__ */ diff --git a/misc/builddeps/dp.win64/lib/libgmp.dll.a b/misc/builddeps/dp.win64/lib/libgmp.dll.a new file mode 100755 index 0000000000000000000000000000000000000000..1744e9b6b7764d06fd71064e50d7acf904e7b9cf GIT binary patch literal 327030 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 N%{;dZepHe1{{gS%hsXc` literal 0 HcmV?d00001 diff --git a/misc/builddeps/dp.win64/lib/libgmp.la b/misc/builddeps/dp.win64/lib/libgmp.la new file mode 100755 index 00000000..1240f174 --- /dev/null +++ b/misc/builddeps/dp.win64/lib/libgmp.la @@ -0,0 +1,41 @@ +# libgmp.la - a libtool library file +# Generated by ltmain.sh (GNU libtool) 2.2.6b +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='../bin/libgmp-10.dll' + +# Names of this library. +library_names='libgmp.dll.a' + +# The name of the static archive. +old_library='' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs='' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libgmp. +current=10 +age=0 +revision=1 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/tmp/gmp/lib' diff --git a/misc/builddeps/dp.win64/share/info/dir b/misc/builddeps/dp.win64/share/info/dir new file mode 100644 index 00000000..e54d6902 --- /dev/null +++ b/misc/builddeps/dp.win64/share/info/dir @@ -0,0 +1,18 @@ +This is the file .../info/dir, which contains the +topmost node of the Info hierarchy, called (dir)Top. +The first time you invoke Info you start off looking at this node. + +File: dir, Node: Top This is the top of the INFO tree + + This (the Directory node) gives a menu of major topics. + Typing "q" exits, "?" lists all Info commands, "d" returns here, + "h" gives a primer for first-timers, + "mEmacs" visits the Emacs manual, etc. + + In Emacs, you can click mouse button 2 on a menu item or cross reference + to select it. + +* Menu: + +GNU libraries +* gmp: (gmp). GNU Multiple Precision Arithmetic Library. diff --git a/misc/builddeps/dp.win64/share/info/gmp.info b/misc/builddeps/dp.win64/share/info/gmp.info new file mode 100644 index 00000000..d65ab795 --- /dev/null +++ b/misc/builddeps/dp.win64/share/info/gmp.info @@ -0,0 +1,178 @@ +This is ../../gmp/doc/gmp.info, produced by makeinfo version 4.8 from +../../gmp/doc/gmp.texi. + + This manual describes how to install and use the GNU multiple +precision arithmetic library, version 5.0.1. + + Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, +2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free +Software Foundation, Inc. + + Permission is granted to copy, distribute and/or modify this +document under the terms of the GNU Free Documentation License, Version +1.3 or any later version published by the Free Software Foundation; +with no Invariant Sections, with the Front-Cover Texts being "A GNU +Manual", and with the Back-Cover Texts being "You have freedom to copy +and modify this GNU Manual, like GNU software". A copy of the license +is included in *Note GNU Free Documentation License::. + +INFO-DIR-SECTION GNU libraries +START-INFO-DIR-ENTRY +* gmp: (gmp). GNU Multiple Precision Arithmetic Library. +END-INFO-DIR-ENTRY + + +Indirect: +gmp.info-1: 981 +gmp.info-2: 300864 + +Tag Table: +(Indirect) +Node: Top981 +Node: Copying3211 +Node: Introduction to GMP5062 +Node: Installing GMP7773 +Node: Build Options8505 +Node: ABI and ISA24573 +Node: Notes for Package Builds34251 +Node: Notes for Particular Systems37338 +Node: Known Build Problems43895 +Node: Performance optimization47429 +Node: GMP Basics48563 +Node: Headers and Libraries49211 +Node: Nomenclature and Types50635 +Node: Function Classes52632 +Node: Variable Conventions54325 +Node: Parameter Conventions55934 +Node: Memory Management57990 +Node: Reentrancy59118 +Node: Useful Macros and Constants60991 +Node: Compatibility with older versions61989 +Node: Demonstration Programs62950 +Node: Efficiency64815 +Node: Debugging72439 +Node: Profiling78997 +Node: Autoconf82988 +Node: Emacs84767 +Node: Reporting Bugs85373 +Node: Integer Functions87916 +Node: Initializing Integers88692 +Node: Assigning Integers90839 +Node: Simultaneous Integer Init & Assign92426 +Node: Converting Integers94051 +Node: Integer Arithmetic96973 +Node: Integer Division98559 +Node: Integer Exponentiation104869 +Node: Integer Roots106309 +Node: Number Theoretic Functions107983 +Node: Integer Comparisons114126 +Node: Integer Logic and Bit Fiddling115504 +Node: I/O of Integers118051 +Node: Integer Random Numbers120935 +Node: Integer Import and Export123546 +Node: Miscellaneous Integer Functions127556 +Node: Integer Special Functions129416 +Node: Rational Number Functions132503 +Node: Initializing Rationals133696 +Node: Rational Conversions136157 +Node: Rational Arithmetic137888 +Node: Comparing Rationals139192 +Node: Applying Integer Functions140559 +Node: I/O of Rationals142042 +Node: Floating-point Functions143902 +Node: Initializing Floats146787 +Node: Assigning Floats150874 +Node: Simultaneous Float Init & Assign153441 +Node: Converting Floats154969 +Node: Float Arithmetic158217 +Node: Float Comparison160230 +Node: I/O of Floats161811 +Node: Miscellaneous Float Functions164409 +Node: Low-level Functions166303 +Node: Random Number Functions190437 +Node: Random State Initialization191505 +Node: Random State Seeding194363 +Node: Random State Miscellaneous195752 +Node: Formatted Output196393 +Node: Formatted Output Strings196638 +Node: Formatted Output Functions201852 +Node: C++ Formatted Output205927 +Node: Formatted Input208609 +Node: Formatted Input Strings208845 +Node: Formatted Input Functions213497 +Node: C++ Formatted Input216466 +Node: C++ Class Interface218369 +Node: C++ Interface General219370 +Node: C++ Interface Integers222440 +Node: C++ Interface Rationals225871 +Node: C++ Interface Floats229548 +Node: C++ Interface Random Numbers234830 +Node: C++ Interface Limitations237236 +Node: BSD Compatible Functions240056 +Node: Custom Allocation244767 +Node: Language Bindings249085 +Node: Algorithms253038 +Node: Multiplication Algorithms253738 +Node: Basecase Multiplication254710 +Node: Karatsuba Multiplication256618 +Node: Toom 3-Way Multiplication260243 +Node: Toom 4-Way Multiplication266657 +Node: FFT Multiplication268029 +Node: Other Multiplication273365 +Node: Unbalanced Multiplication275839 +Node: Division Algorithms276627 +Node: Single Limb Division277006 +Node: Basecase Division279897 +Node: Divide and Conquer Division281100 +Node: Block-Wise Barrett Division283169 +Node: Exact Division283821 +Node: Exact Remainder286986 +Node: Small Quotient Division289213 +Node: Greatest Common Divisor Algorithms290811 +Node: Binary GCD291108 +Node: Lehmer's Algorithm293957 +Node: Subquadratic GCD296177 +Node: Extended GCD298636 +Node: Jacobi Symbol299948 +Node: Powering Algorithms300864 +Node: Normal Powering Algorithm301127 +Node: Modular Powering Algorithm301655 +Node: Root Extraction Algorithms302435 +Node: Square Root Algorithm302750 +Node: Nth Root Algorithm304891 +Node: Perfect Square Algorithm305676 +Node: Perfect Power Algorithm307762 +Node: Radix Conversion Algorithms308383 +Node: Binary to Radix308759 +Node: Radix to Binary312688 +Node: Other Algorithms314776 +Node: Prime Testing Algorithm315128 +Node: Factorial Algorithm316312 +Node: Binomial Coefficients Algorithm317715 +Node: Fibonacci Numbers Algorithm318609 +Node: Lucas Numbers Algorithm321083 +Node: Random Number Algorithms321804 +Node: Assembly Coding323925 +Node: Assembly Code Organisation324885 +Node: Assembly Basics325852 +Node: Assembly Carry Propagation327002 +Node: Assembly Cache Handling328833 +Node: Assembly Functional Units330994 +Node: Assembly Floating Point332607 +Node: Assembly SIMD Instructions336385 +Node: Assembly Software Pipelining337367 +Node: Assembly Loop Unrolling338429 +Node: Assembly Writing Guide340644 +Node: Internals343409 +Node: Integer Internals343921 +Node: Rational Internals346177 +Node: Float Internals347415 +Node: Raw Output Internals354829 +Node: C++ Interface Internals356023 +Node: Contributors359309 +Node: References364267 +Node: GNU Free Documentation License369925 +Node: Concept Index395094 +Node: Function Index441276 + +End Tag Table diff --git a/misc/builddeps/dp.win64/share/info/gmp.info-1 b/misc/builddeps/dp.win64/share/info/gmp.info-1 new file mode 100644 index 00000000..d1360599 --- /dev/null +++ b/misc/builddeps/dp.win64/share/info/gmp.info-1 @@ -0,0 +1,7084 @@ +This is ../../gmp/doc/gmp.info, produced by makeinfo version 4.8 from +../../gmp/doc/gmp.texi. + + This manual describes how to install and use the GNU multiple +precision arithmetic library, version 5.0.1. + + Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, +2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free +Software Foundation, Inc. + + Permission is granted to copy, distribute and/or modify this +document under the terms of the GNU Free Documentation License, Version +1.3 or any later version published by the Free Software Foundation; +with no Invariant Sections, with the Front-Cover Texts being "A GNU +Manual", and with the Back-Cover Texts being "You have freedom to copy +and modify this GNU Manual, like GNU software". A copy of the license +is included in *Note GNU Free Documentation License::. + +INFO-DIR-SECTION GNU libraries +START-INFO-DIR-ENTRY +* gmp: (gmp). GNU Multiple Precision Arithmetic Library. +END-INFO-DIR-ENTRY + + +File: gmp.info, Node: Top, Next: Copying, Prev: (dir), Up: (dir) + +GNU MP +****** + + This manual describes how to install and use the GNU multiple +precision arithmetic library, version 5.0.1. + + Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, +2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free +Software Foundation, Inc. + + Permission is granted to copy, distribute and/or modify this +document under the terms of the GNU Free Documentation License, Version +1.3 or any later version published by the Free Software Foundation; +with no Invariant Sections, with the Front-Cover Texts being "A GNU +Manual", and with the Back-Cover Texts being "You have freedom to copy +and modify this GNU Manual, like GNU software". A copy of the license +is included in *Note GNU Free Documentation License::. + + +* Menu: + +* Copying:: GMP Copying Conditions (LGPL). +* Introduction to GMP:: Brief introduction to GNU MP. +* Installing GMP:: How to configure and compile the GMP library. +* GMP Basics:: What every GMP user should know. +* Reporting Bugs:: How to usefully report bugs. +* Integer Functions:: Functions for arithmetic on signed integers. +* Rational Number Functions:: Functions for arithmetic on rational numbers. +* Floating-point Functions:: Functions for arithmetic on floats. +* Low-level Functions:: Fast functions for natural numbers. +* Random Number Functions:: Functions for generating random numbers. +* Formatted Output:: `printf' style output. +* Formatted Input:: `scanf' style input. +* C++ Class Interface:: Class wrappers around GMP types. +* BSD Compatible Functions:: All functions found in BSD MP. +* Custom Allocation:: How to customize the internal allocation. +* Language Bindings:: Using GMP from other languages. +* Algorithms:: What happens behind the scenes. +* Internals:: How values are represented behind the scenes. + +* Contributors:: Who brings you this library? +* References:: Some useful papers and books to read. +* GNU Free Documentation License:: +* Concept Index:: +* Function Index:: + + +File: gmp.info, Node: Copying, Next: Introduction to GMP, Prev: Top, Up: Top + +GNU MP Copying Conditions +************************* + +This library is "free"; this means that everyone is free to use it and +free to redistribute it on a free basis. The library is not in the +public domain; it is copyrighted and there are restrictions on its +distribution, but these restrictions are designed to permit everything +that a good cooperating citizen would want to do. What is not allowed +is to try to prevent others from further sharing any version of this +library that they might get from you. + + Specifically, we want to make sure that you have the right to give +away copies of the library, that you receive source code or else can +get it if you want it, that you can change this library or use pieces +of it in new free programs, and that you know you can do these things. + + To make sure that everyone has such rights, we have to forbid you to +deprive anyone else of these rights. For example, if you distribute +copies of the GNU MP library, you must give the recipients all the +rights that you have. You must make sure that they, too, receive or +can get the source code. And you must tell them their rights. + + Also, for our own protection, we must make certain that everyone +finds out that there is no warranty for the GNU MP library. If it is +modified by someone else and passed on, we want their recipients to +know that what they have is not what we distributed, so that any +problems introduced by others will not reflect on our reputation. + + The precise conditions of the license for the GNU MP library are +found in the Lesser General Public License version 3 that accompanies +the source code, see `COPYING.LIB'. Certain demonstration programs are +provided under the terms of the plain General Public License version 3, +see `COPYING'. + + +File: gmp.info, Node: Introduction to GMP, Next: Installing GMP, Prev: Copying, Up: Top + +1 Introduction to GNU MP +************************ + +GNU MP is a portable library written in C for arbitrary precision +arithmetic on integers, rational numbers, and floating-point numbers. +It aims to provide the fastest possible arithmetic for all applications +that need higher precision than is directly supported by the basic C +types. + + Many applications use just a few hundred bits of precision; but some +applications may need thousands or even millions of bits. GMP is +designed to give good performance for both, by choosing algorithms +based on the sizes of the operands, and by carefully keeping the +overhead at a minimum. + + The speed of GMP is achieved by using fullwords as the basic +arithmetic type, by using sophisticated algorithms, by including +carefully optimized assembly code for the most common inner loops for +many different CPUs, and by a general emphasis on speed (as opposed to +simplicity or elegance). + + There is assembly code for these CPUs: ARM, DEC Alpha 21064, 21164, +and 21264, AMD 29000, AMD K6, K6-2, Athlon, and Athlon64, Hitachi +SuperH and SH-2, HPPA 1.0, 1.1 and 2.0, Intel Pentium, Pentium +Pro/II/III, Pentium 4, generic x86, Intel IA-64, i960, Motorola +MC68000, MC68020, MC88100, and MC88110, Motorola/IBM PowerPC 32 and 64, +National NS32000, IBM POWER, MIPS R3000, R4000, SPARCv7, SuperSPARC, +generic SPARCv8, UltraSPARC, DEC VAX, and Zilog Z8000. Some +optimizations also for Cray vector systems, Clipper, IBM ROMP (RT), and +Pyramid AP/XP. + +For up-to-date information on GMP, please see the GMP web pages at + + `http://gmplib.org/' + +The latest version of the library is available at + + `ftp://ftp.gnu.org/gnu/gmp/' + + Many sites around the world mirror `ftp.gnu.org', please use a mirror +near you, see `http://www.gnu.org/order/ftp.html' for a full list. + + There are three public mailing lists of interest. One for release +announcements, one for general questions and discussions about usage of +the GMP library and one for bug reports. For more information, see + + `http://gmplib.org/mailman/listinfo/'. + + The proper place for bug reports is . See +*Note Reporting Bugs:: for information about reporting bugs. + + +1.1 How to use this Manual +========================== + +Everyone should read *Note GMP Basics::. If you need to install the +library yourself, then read *Note Installing GMP::. If you have a +system with multiple ABIs, then read *Note ABI and ISA::, for the +compiler options that must be used on applications. + + The rest of the manual can be used for later reference, although it +is probably a good idea to glance through it. + + +File: gmp.info, Node: Installing GMP, Next: GMP Basics, Prev: Introduction to GMP, Up: Top + +2 Installing GMP +**************** + +GMP has an autoconf/automake/libtool based configuration system. On a +Unix-like system a basic build can be done with + + ./configure + make + +Some self-tests can be run with + + make check + +And you can install (under `/usr/local' by default) with + + make install + + If you experience problems, please report them to +. See *Note Reporting Bugs::, for information on +what to include in useful bug reports. + +* Menu: + +* Build Options:: +* ABI and ISA:: +* Notes for Package Builds:: +* Notes for Particular Systems:: +* Known Build Problems:: +* Performance optimization:: + + +File: gmp.info, Node: Build Options, Next: ABI and ISA, Prev: Installing GMP, Up: Installing GMP + +2.1 Build Options +================= + +All the usual autoconf configure options are available, run `./configure +--help' for a summary. The file `INSTALL.autoconf' has some generic +installation information too. + +Tools + `configure' requires various Unix-like tools. See *Note Notes for + Particular Systems::, for some options on non-Unix systems. + + It might be possible to build without the help of `configure', + certainly all the code is there, but unfortunately you'll be on + your own. + +Build Directory + To compile in a separate build directory, `cd' to that directory, + and prefix the configure command with the path to the GMP source + directory. For example + + cd /my/build/dir + /my/sources/gmp-5.0.1/configure + + Not all `make' programs have the necessary features (`VPATH') to + support this. In particular, SunOS and Slowaris `make' have bugs + that make them unable to build in a separate directory. Use GNU + `make' instead. + +`--prefix' and `--exec-prefix' + The `--prefix' option can be used in the normal way to direct GMP + to install under a particular tree. The default is `/usr/local'. + + `--exec-prefix' can be used to direct architecture-dependent files + like `libgmp.a' to a different location. This can be used to share + architecture-independent parts like the documentation, but + separate the dependent parts. Note however that `gmp.h' and + `mp.h' are architecture-dependent since they encode certain + aspects of `libgmp', so it will be necessary to ensure both + `$prefix/include' and `$exec_prefix/include' are available to the + compiler. + +`--disable-shared', `--disable-static' + By default both shared and static libraries are built (where + possible), but one or other can be disabled. Shared libraries + result in smaller executables and permit code sharing between + separate running processes, but on some CPUs are slightly slower, + having a small cost on each function call. + +Native Compilation, `--build=CPU-VENDOR-OS' + For normal native compilation, the system can be specified with + `--build'. By default `./configure' uses the output from running + `./config.guess'. On some systems `./config.guess' can determine + the exact CPU type, on others it will be necessary to give it + explicitly. For example, + + ./configure --build=ultrasparc-sun-solaris2.7 + + In all cases the `OS' part is important, since it controls how + libtool generates shared libraries. Running `./config.guess' is + the simplest way to see what it should be, if you don't know + already. + +Cross Compilation, `--host=CPU-VENDOR-OS' + When cross-compiling, the system used for compiling is given by + `--build' and the system where the library will run is given by + `--host'. For example when using a FreeBSD Athlon system to build + GNU/Linux m68k binaries, + + ./configure --build=athlon-pc-freebsd3.5 --host=m68k-mac-linux-gnu + + Compiler tools are sought first with the host system type as a + prefix. For example `m68k-mac-linux-gnu-ranlib' is tried, then + plain `ranlib'. This makes it possible for a set of + cross-compiling tools to co-exist with native tools. The prefix + is the argument to `--host', and this can be an alias, such as + `m68k-linux'. But note that tools don't have to be setup this + way, it's enough to just have a `PATH' with a suitable + cross-compiling `cc' etc. + + Compiling for a different CPU in the same family as the build + system is a form of cross-compilation, though very possibly this + would merely be special options on a native compiler. In any case + `./configure' avoids depending on being able to run code on the + build system, which is important when creating binaries for a + newer CPU since they very possibly won't run on the build system. + + In all cases the compiler must be able to produce an executable + (of whatever format) from a standard C `main'. Although only + object files will go to make up `libgmp', `./configure' uses + linking tests for various purposes, such as determining what + functions are available on the host system. + + Currently a warning is given unless an explicit `--build' is used + when cross-compiling, because it may not be possible to correctly + guess the build system type if the `PATH' has only a + cross-compiling `cc'. + + Note that the `--target' option is not appropriate for GMP. It's + for use when building compiler tools, with `--host' being where + they will run, and `--target' what they'll produce code for. + Ordinary programs or libraries like GMP are only interested in the + `--host' part, being where they'll run. (Some past versions of + GMP used `--target' incorrectly.) + +CPU types + In general, if you want a library that runs as fast as possible, + you should configure GMP for the exact CPU type your system uses. + However, this may mean the binaries won't run on older members of + the family, and might run slower on other members, older or newer. + The best idea is always to build GMP for the exact machine type + you intend to run it on. + + The following CPUs have specific support. See `configure.in' for + details of what code and compiler options they select. + + * Alpha: alpha, alphaev5, alphaev56, alphapca56, alphapca57, + alphaev6, alphaev67, alphaev68 alphaev7 + + * Cray: c90, j90, t90, sv1 + + * HPPA: hppa1.0, hppa1.1, hppa2.0, hppa2.0n, hppa2.0w, hppa64 + + * IA-64: ia64, itanium, itanium2 + + * MIPS: mips, mips3, mips64 + + * Motorola: m68k, m68000, m68010, m68020, m68030, m68040, + m68060, m68302, m68360, m88k, m88110 + + * POWER: power, power1, power2, power2sc + + * PowerPC: powerpc, powerpc64, powerpc401, powerpc403, + powerpc405, powerpc505, powerpc601, powerpc602, powerpc603, + powerpc603e, powerpc604, powerpc604e, powerpc620, powerpc630, + powerpc740, powerpc7400, powerpc7450, powerpc750, powerpc801, + powerpc821, powerpc823, powerpc860, powerpc970 + + * SPARC: sparc, sparcv8, microsparc, supersparc, sparcv9, + ultrasparc, ultrasparc2, ultrasparc2i, ultrasparc3, sparc64 + + * x86 family: i386, i486, i586, pentium, pentiummmx, pentiumpro, + pentium2, pentium3, pentium4, k6, k62, k63, athlon, amd64, + viac3, viac32 + + * Other: a29k, arm, clipper, i960, ns32k, pyramid, sh, sh2, vax, + z8k + + CPUs not listed will use generic C code. + +Generic C Build + If some of the assembly code causes problems, or if otherwise + desired, the generic C code can be selected with CPU `none'. For + example, + + ./configure --host=none-unknown-freebsd3.5 + + Note that this will run quite slowly, but it should be portable + and should at least make it possible to get something running if + all else fails. + +Fat binary, `--enable-fat' + Using `--enable-fat' selects a "fat binary" build on x86, where + optimized low level subroutines are chosen at runtime according to + the CPU detected. This means more code, but gives good + performance on all x86 chips. (This option might become available + for more architectures in the future.) + +`ABI' + On some systems GMP supports multiple ABIs (application binary + interfaces), meaning data type sizes and calling conventions. By + default GMP chooses the best ABI available, but a particular ABI + can be selected. For example + + ./configure --host=mips64-sgi-irix6 ABI=n32 + + See *Note ABI and ISA::, for the available choices on relevant + CPUs, and what applications need to do. + +`CC', `CFLAGS' + By default the C compiler used is chosen from among some likely + candidates, with `gcc' normally preferred if it's present. The + usual `CC=whatever' can be passed to `./configure' to choose + something different. + + For various systems, default compiler flags are set based on the + CPU and compiler. The usual `CFLAGS="-whatever"' can be passed to + `./configure' to use something different or to set good flags for + systems GMP doesn't otherwise know. + + The `CC' and `CFLAGS' used are printed during `./configure', and + can be found in each generated `Makefile'. This is the easiest way + to check the defaults when considering changing or adding + something. + + Note that when `CC' and `CFLAGS' are specified on a system + supporting multiple ABIs it's important to give an explicit + `ABI=whatever', since GMP can't determine the ABI just from the + flags and won't be able to select the correct assembly code. + + If just `CC' is selected then normal default `CFLAGS' for that + compiler will be used (if GMP recognises it). For example + `CC=gcc' can be used to force the use of GCC, with default flags + (and default ABI). + +`CPPFLAGS' + Any flags like `-D' defines or `-I' includes required by the + preprocessor should be set in `CPPFLAGS' rather than `CFLAGS'. + Compiling is done with both `CPPFLAGS' and `CFLAGS', but + preprocessing uses just `CPPFLAGS'. This distinction is because + most preprocessors won't accept all the flags the compiler does. + Preprocessing is done separately in some configure tests, and in + the `ansi2knr' support for K&R compilers. + +`CC_FOR_BUILD' + Some build-time programs are compiled and run to generate + host-specific data tables. `CC_FOR_BUILD' is the compiler used + for this. It doesn't need to be in any particular ABI or mode, it + merely needs to generate executables that can run. The default is + to try the selected `CC' and some likely candidates such as `cc' + and `gcc', looking for something that works. + + No flags are used with `CC_FOR_BUILD' because a simple invocation + like `cc foo.c' should be enough. If some particular options are + required they can be included as for instance `CC_FOR_BUILD="cc + -whatever"'. + +C++ Support, `--enable-cxx' + C++ support in GMP can be enabled with `--enable-cxx', in which + case a C++ compiler will be required. As a convenience + `--enable-cxx=detect' can be used to enable C++ support only if a + compiler can be found. The C++ support consists of a library + `libgmpxx.la' and header file `gmpxx.h' (*note Headers and + Libraries::). + + A separate `libgmpxx.la' has been adopted rather than having C++ + objects within `libgmp.la' in order to ensure dynamic linked C + programs aren't bloated by a dependency on the C++ standard + library, and to avoid any chance that the C++ compiler could be + required when linking plain C programs. + + `libgmpxx.la' will use certain internals from `libgmp.la' and can + only be expected to work with `libgmp.la' from the same GMP + version. Future changes to the relevant internals will be + accompanied by renaming, so a mismatch will cause unresolved + symbols rather than perhaps mysterious misbehaviour. + + In general `libgmpxx.la' will be usable only with the C++ compiler + that built it, since name mangling and runtime support are usually + incompatible between different compilers. + +`CXX', `CXXFLAGS' + When C++ support is enabled, the C++ compiler and its flags can be + set with variables `CXX' and `CXXFLAGS' in the usual way. The + default for `CXX' is the first compiler that works from a list of + likely candidates, with `g++' normally preferred when available. + The default for `CXXFLAGS' is to try `CFLAGS', `CFLAGS' without + `-g', then for `g++' either `-g -O2' or `-O2', or for other + compilers `-g' or nothing. Trying `CFLAGS' this way is convenient + when using `gcc' and `g++' together, since the flags for `gcc' will + usually suit `g++'. + + It's important that the C and C++ compilers match, meaning their + startup and runtime support routines are compatible and that they + generate code in the same ABI (if there's a choice of ABIs on the + system). `./configure' isn't currently able to check these things + very well itself, so for that reason `--disable-cxx' is the + default, to avoid a build failure due to a compiler mismatch. + Perhaps this will change in the future. + + Incidentally, it's normally not good enough to set `CXX' to the + same as `CC'. Although `gcc' for instance recognises `foo.cc' as + C++ code, only `g++' will invoke the linker the right way when + building an executable or shared library from C++ object files. + +Temporary Memory, `--enable-alloca=' + GMP allocates temporary workspace using one of the following three + methods, which can be selected with for instance + `--enable-alloca=malloc-reentrant'. + + * `alloca' - C library or compiler builtin. + + * `malloc-reentrant' - the heap, in a re-entrant fashion. + + * `malloc-notreentrant' - the heap, with global variables. + + For convenience, the following choices are also available. + `--disable-alloca' is the same as `no'. + + * `yes' - a synonym for `alloca'. + + * `no' - a synonym for `malloc-reentrant'. + + * `reentrant' - `alloca' if available, otherwise + `malloc-reentrant'. This is the default. + + * `notreentrant' - `alloca' if available, otherwise + `malloc-notreentrant'. + + `alloca' is reentrant and fast, and is recommended. It actually + allocates just small blocks on the stack; larger ones use + malloc-reentrant. + + `malloc-reentrant' is, as the name suggests, reentrant and thread + safe, but `malloc-notreentrant' is faster and should be used if + reentrancy is not required. + + The two malloc methods in fact use the memory allocation functions + selected by `mp_set_memory_functions', these being `malloc' and + friends by default. *Note Custom Allocation::. + + An additional choice `--enable-alloca=debug' is available, to help + when debugging memory related problems (*note Debugging::). + +FFT Multiplication, `--disable-fft' + By default multiplications are done using Karatsuba, 3-way Toom, + and Fermat FFT. The FFT is only used on large to very large + operands and can be disabled to save code size if desired. + +Berkeley MP, `--enable-mpbsd' + The Berkeley MP compatibility library (`libmp') and header file + (`mp.h') are built and installed only if `--enable-mpbsd' is used. + *Note BSD Compatible Functions::. + +Assertion Checking, `--enable-assert' + This option enables some consistency checking within the library. + This can be of use while debugging, *note Debugging::. + +Execution Profiling, `--enable-profiling=prof/gprof/instrument' + Enable profiling support, in one of various styles, *note + Profiling::. + +`MPN_PATH' + Various assembly versions of each mpn subroutines are provided. + For a given CPU, a search is made though a path to choose a + version of each. For example `sparcv8' has + + MPN_PATH="sparc32/v8 sparc32 generic" + + which means look first for v8 code, then plain sparc32 (which is + v7), and finally fall back on generic C. Knowledgeable users with + special requirements can specify a different path. Normally this + is completely unnecessary. + +Documentation + The source for the document you're now reading is `doc/gmp.texi', + in Texinfo format, see *Note Texinfo: (texinfo)Top. + + Info format `doc/gmp.info' is included in the distribution. The + usual automake targets are available to make PostScript, DVI, PDF + and HTML (these will require various TeX and Texinfo tools). + + DocBook and XML can be generated by the Texinfo `makeinfo' program + too, see *Note Options for `makeinfo': (texinfo)makeinfo options. + + Some supplementary notes can also be found in the `doc' + subdirectory. + + + +File: gmp.info, Node: ABI and ISA, Next: Notes for Package Builds, Prev: Build Options, Up: Installing GMP + +2.2 ABI and ISA +=============== + +ABI (Application Binary Interface) refers to the calling conventions +between functions, meaning what registers are used and what sizes the +various C data types are. ISA (Instruction Set Architecture) refers to +the instructions and registers a CPU has available. + + Some 64-bit ISA CPUs have both a 64-bit ABI and a 32-bit ABI +defined, the latter for compatibility with older CPUs in the family. +GMP supports some CPUs like this in both ABIs. In fact within GMP +`ABI' means a combination of chip ABI, plus how GMP chooses to use it. +For example in some 32-bit ABIs, GMP may support a limb as either a +32-bit `long' or a 64-bit `long long'. + + By default GMP chooses the best ABI available for a given system, +and this generally gives significantly greater speed. But an ABI can +be chosen explicitly to make GMP compatible with other libraries, or +particular application requirements. For example, + + ./configure ABI=32 + + In all cases it's vital that all object code used in a given program +is compiled for the same ABI. + + Usually a limb is implemented as a `long'. When a `long long' limb +is used this is encoded in the generated `gmp.h'. This is convenient +for applications, but it does mean that `gmp.h' will vary, and can't be +just copied around. `gmp.h' remains compiler independent though, since +all compilers for a particular ABI will be expected to use the same +limb type. + + Currently no attempt is made to follow whatever conventions a system +has for installing library or header files built for a particular ABI. +This will probably only matter when installing multiple builds of GMP, +and it might be as simple as configuring with a special `libdir', or it +might require more than that. Note that builds for different ABIs need +to done separately, with a fresh `./configure' and `make' each. + + +AMD64 (`x86_64') + On AMD64 systems supporting both 32-bit and 64-bit modes for + applications, the following ABI choices are available. + + `ABI=64' + The 64-bit ABI uses 64-bit limbs and pointers and makes full + use of the chip architecture. This is the default. + Applications will usually not need special compiler flags, + but for reference the option is + + gcc -m64 + + `ABI=32' + The 32-bit ABI is the usual i386 conventions. This will be + slower, and is not recommended except for inter-operating + with other code not yet 64-bit capable. Applications must be + compiled with + + gcc -m32 + + (In GCC 2.95 and earlier there's no `-m32' option, it's the + only mode.) + + +HPPA 2.0 (`hppa2.0*', `hppa64') + + `ABI=2.0w' + The 2.0w ABI uses 64-bit limbs and pointers and is available + on HP-UX 11 or up. Applications must be compiled with + + gcc [built for 2.0w] + cc +DD64 + + `ABI=2.0n' + The 2.0n ABI means the 32-bit HPPA 1.0 ABI and all its normal + calling conventions, but with 64-bit instructions permitted + within functions. GMP uses a 64-bit `long long' for a limb. + This ABI is available on hppa64 GNU/Linux and on HP-UX 10 or + higher. Applications must be compiled with + + gcc [built for 2.0n] + cc +DA2.0 +e + + Note that current versions of GCC (eg. 3.2) don't generate + 64-bit instructions for `long long' operations and so may be + slower than for 2.0w. (The GMP assembly code is the same + though.) + + `ABI=1.0' + HPPA 2.0 CPUs can run all HPPA 1.0 and 1.1 code in the 32-bit + HPPA 1.0 ABI. No special compiler options are needed for + applications. + + All three ABIs are available for CPU types `hppa2.0w', `hppa2.0' + and `hppa64', but for CPU type `hppa2.0n' only 2.0n or 1.0 are + considered. + + Note that GCC on HP-UX has no options to choose between 2.0n and + 2.0w modes, unlike HP `cc'. Instead it must be built for one or + the other ABI. GMP will detect how it was built, and skip to the + corresponding `ABI'. + + +IA-64 under HP-UX (`ia64*-*-hpux*', `itanium*-*-hpux*') + HP-UX supports two ABIs for IA-64. GMP performance is the same in + both. + + `ABI=32' + In the 32-bit ABI, pointers, `int's and `long's are 32 bits + and GMP uses a 64 bit `long long' for a limb. Applications + can be compiled without any special flags since this ABI is + the default in both HP C and GCC, but for reference the flags + are + + gcc -milp32 + cc +DD32 + + `ABI=64' + In the 64-bit ABI, `long's and pointers are 64 bits and GMP + uses a `long' for a limb. Applications must be compiled with + + gcc -mlp64 + cc +DD64 + + On other IA-64 systems, GNU/Linux for instance, `ABI=64' is the + only choice. + + +MIPS under IRIX 6 (`mips*-*-irix[6789]') + IRIX 6 always has a 64-bit MIPS 3 or better CPU, and supports ABIs + o32, n32, and 64. n32 or 64 are recommended, and GMP performance + will be the same in each. The default is n32. + + `ABI=o32' + The o32 ABI is 32-bit pointers and integers, and no 64-bit + operations. GMP will be slower than in n32 or 64, this + option only exists to support old compilers, eg. GCC 2.7.2. + Applications can be compiled with no special flags on an old + compiler, or on a newer compiler with + + gcc -mabi=32 + cc -32 + + `ABI=n32' + The n32 ABI is 32-bit pointers and integers, but with a + 64-bit limb using a `long long'. Applications must be + compiled with + + gcc -mabi=n32 + cc -n32 + + `ABI=64' + The 64-bit ABI is 64-bit pointers and integers. Applications + must be compiled with + + gcc -mabi=64 + cc -64 + + Note that MIPS GNU/Linux, as of kernel version 2.2, doesn't have + the necessary support for n32 or 64 and so only gets a 32-bit limb + and the MIPS 2 code. + + +PowerPC 64 (`powerpc64', `powerpc620', `powerpc630', `powerpc970', `power4', `power5') + + `ABI=aix64' + The AIX 64 ABI uses 64-bit limbs and pointers and is the + default on PowerPC 64 `*-*-aix*' systems. Applications must + be compiled with + + gcc -maix64 + xlc -q64 + + `ABI=mode64' + The `mode64' ABI uses 64-bit limbs and pointers, and is the + default on 64-bit GNU/Linux, BSD, and Mac OS X/Darwin + systems. Applications must be compiled with + + gcc -m64 + + `ABI=mode32' + The `mode32' ABI uses a 64-bit `long long' limb but with the + chip still in 32-bit mode and using 32-bit calling + conventions. This is the default on for systems where the + true 64-bit ABIs are unavailable. No special compiler + options are needed for applications. + + `ABI=32' + This is the basic 32-bit PowerPC ABI, with a 32-bit limb. No + special compiler options are needed for applications. + + GMP speed is greatest in `aix64' and `mode32'. In `ABI=32' only + the 32-bit ISA is used and this doesn't make full use of a 64-bit + chip. On a suitable system we could perhaps use more of the ISA, + but there are no plans to do so. + + +Sparc V9 (`sparc64', `sparcv9', `ultrasparc*') + + `ABI=64' + The 64-bit V9 ABI is available on the various BSD sparc64 + ports, recent versions of Sparc64 GNU/Linux, and Solaris 2.7 + and up (when the kernel is in 64-bit mode). GCC 3.2 or + higher, or Sun `cc' is required. On GNU/Linux, depending on + the default `gcc' mode, applications must be compiled with + + gcc -m64 + + On Solaris applications must be compiled with + + gcc -m64 -mptr64 -Wa,-xarch=v9 -mcpu=v9 + cc -xarch=v9 + + On the BSD sparc64 systems no special options are required, + since 64-bits is the only ABI available. + + `ABI=32' + For the basic 32-bit ABI, GMP still uses as much of the V9 + ISA as it can. In the Sun documentation this combination is + known as "v8plus". On GNU/Linux, depending on the default + `gcc' mode, applications may need to be compiled with + + gcc -m32 + + On Solaris, no special compiler options are required for + applications, though using something like the following is + recommended. (`gcc' 2.8 and earlier only support `-mv8' + though.) + + gcc -mv8plus + cc -xarch=v8plus + + GMP speed is greatest in `ABI=64', so it's the default where + available. The speed is partly because there are extra registers + available and partly because 64-bits is considered the more + important case and has therefore had better code written for it. + + Don't be confused by the names of the `-m' and `-x' compiler + options, they're called `arch' but effectively control both ABI + and ISA. + + On Solaris 2.6 and earlier, only `ABI=32' is available since the + kernel doesn't save all registers. + + On Solaris 2.7 with the kernel in 32-bit mode, a normal native + build will reject `ABI=64' because the resulting executables won't + run. `ABI=64' can still be built if desired by making it look + like a cross-compile, for example + + ./configure --build=none --host=sparcv9-sun-solaris2.7 ABI=64 + + +File: gmp.info, Node: Notes for Package Builds, Next: Notes for Particular Systems, Prev: ABI and ISA, Up: Installing GMP + +2.3 Notes for Package Builds +============================ + +GMP should present no great difficulties for packaging in a binary +distribution. + + Libtool is used to build the library and `-version-info' is set +appropriately, having started from `3:0:0' in GMP 3.0 (*note Library +interface versions: (libtool)Versioning.). + + The GMP 4 series will be upwardly binary compatible in each release +and will be upwardly binary compatible with all of the GMP 3 series. +Additional function interfaces may be added in each release, so on +systems where libtool versioning is not fully checked by the loader an +auxiliary mechanism may be needed to express that a dynamic linked +application depends on a new enough GMP. + + An auxiliary mechanism may also be needed to express that +`libgmpxx.la' (from `--enable-cxx', *note Build Options::) requires +`libgmp.la' from the same GMP version, since this is not done by the +libtool versioning, nor otherwise. A mismatch will result in +unresolved symbols from the linker, or perhaps the loader. + + When building a package for a CPU family, care should be taken to use +`--host' (or `--build') to choose the least common denominator among +the CPUs which might use the package. For example this might mean plain +`sparc' (meaning V7) for SPARCs. + + For x86s, `--enable-fat' sets things up for a fat binary build, +making a runtime selection of optimized low level routines. This is a +good choice for packaging to run on a range of x86 chips. + + Users who care about speed will want GMP built for their exact CPU +type, to make best use of the available optimizations. Providing a way +to suitably rebuild a package may be useful. This could be as simple +as making it possible for a user to omit `--build' (and `--host') so +`./config.guess' will detect the CPU. But a way to manually specify a +`--build' will be wanted for systems where `./config.guess' is inexact. + + On systems with multiple ABIs, a packaged build will need to decide +which among the choices is to be provided, see *Note ABI and ISA::. A +given run of `./configure' etc will only build one ABI. If a second +ABI is also required then a second run of `./configure' etc must be +made, starting from a clean directory tree (`make distclean'). + + As noted under "ABI and ISA", currently no attempt is made to follow +system conventions for install locations that vary with ABI, such as +`/usr/lib/sparcv9' for `ABI=64' as opposed to `/usr/lib' for `ABI=32'. +A package build can override `libdir' and other standard variables as +necessary. + + Note that `gmp.h' is a generated file, and will be architecture and +ABI dependent. When attempting to install two ABIs simultaneously it +will be important that an application compile gets the correct `gmp.h' +for its desired ABI. If compiler include paths don't vary with ABI +options then it might be necessary to create a `/usr/include/gmp.h' +which tests preprocessor symbols and chooses the correct actual `gmp.h'. + + +File: gmp.info, Node: Notes for Particular Systems, Next: Known Build Problems, Prev: Notes for Package Builds, Up: Installing GMP + +2.4 Notes for Particular Systems +================================ + +AIX 3 and 4 + On systems `*-*-aix[34]*' shared libraries are disabled by + default, since some versions of the native `ar' fail on the + convenience libraries used. A shared build can be attempted with + + ./configure --enable-shared --disable-static + + Note that the `--disable-static' is necessary because in a shared + build libtool makes `libgmp.a' a symlink to `libgmp.so', + apparently for the benefit of old versions of `ld' which only + recognise `.a', but unfortunately this is done even if a fully + functional `ld' is available. + +ARM + On systems `arm*-*-*', versions of GCC up to and including 2.95.3 + have a bug in unsigned division, giving wrong results for some + operands. GMP `./configure' will demand GCC 2.95.4 or later. + +Compaq C++ + Compaq C++ on OSF 5.1 has two flavours of `iostream', a standard + one and an old pre-standard one (see `man iostream_intro'). GMP + can only use the standard one, which unfortunately is not the + default but must be selected by defining `__USE_STD_IOSTREAM'. + Configure with for instance + + ./configure --enable-cxx CPPFLAGS=-D__USE_STD_IOSTREAM + +Floating Point Mode + On some systems, the hardware floating point has a control mode + which can set all operations to be done in a particular precision, + for instance single, double or extended on x86 systems (x87 + floating point). The GMP functions involving a `double' cannot be + expected to operate to their full precision when the hardware is + in single precision mode. Of course this affects all code, + including application code, not just GMP. + +MS-DOS and MS Windows + On an MS-DOS system DJGPP can be used to build GMP, and on an MS + Windows system Cygwin, DJGPP and MINGW can be used. All three are + excellent ports of GCC and the various GNU tools. + + `http://www.cygwin.com/' + `http://www.delorie.com/djgpp/' + `http://www.mingw.org/' + + Microsoft also publishes an Interix "Services for Unix" which can + be used to build GMP on Windows (with a normal `./configure'), but + it's not free software. + +MS Windows DLLs + On systems `*-*-cygwin*', `*-*-mingw*' and `*-*-pw32*' by default + GMP builds only a static library, but a DLL can be built instead + using + + ./configure --disable-static --enable-shared + + Static and DLL libraries can't both be built, since certain export + directives in `gmp.h' must be different. + + A MINGW DLL build of GMP can be used with Microsoft C. Libtool + doesn't install a `.lib' format import library, but it can be + created with MS `lib' as follows, and copied to the install + directory. Similarly for `libmp' and `libgmpxx'. + + cd .libs + lib /def:libgmp-3.dll.def /out:libgmp-3.lib + + MINGW uses the C runtime library `msvcrt.dll' for I/O, so + applications wanting to use the GMP I/O routines must be compiled + with `cl /MD' to do the same. If one of the other C runtime + library choices provided by MS C is desired then the suggestion is + to use the GMP string functions and confine I/O to the application. + +Motorola 68k CPU Types + `m68k' is taken to mean 68000. `m68020' or higher will give a + performance boost on applicable CPUs. `m68360' can be used for + CPU32 series chips. `m68302' can be used for "Dragonball" series + chips, though this is merely a synonym for `m68000'. + +OpenBSD 2.6 + `m4' in this release of OpenBSD has a bug in `eval' that makes it + unsuitable for `.asm' file processing. `./configure' will detect + the problem and either abort or choose another m4 in the `PATH'. + The bug is fixed in OpenBSD 2.7, so either upgrade or use GNU m4. + +Power CPU Types + In GMP, CPU types `power*' and `powerpc*' will each use + instructions not available on the other, so it's important to + choose the right one for the CPU that will be used. Currently GMP + has no assembly code support for using just the common instruction + subset. To get executables that run on both, the current + suggestion is to use the generic C code (CPU `none'), possibly + with appropriate compiler options (like `-mcpu=common' for `gcc'). + CPU `rs6000' (which is not a CPU but a family of workstations) is + accepted by `config.sub', but is currently equivalent to `none'. + +Sparc CPU Types + `sparcv8' or `supersparc' on relevant systems will give a + significant performance increase over the V7 code selected by plain + `sparc'. + +Sparc App Regs + The GMP assembly code for both 32-bit and 64-bit Sparc clobbers the + "application registers" `g2', `g3' and `g4', the same way that the + GCC default `-mapp-regs' does (*note SPARC Options: (gcc)SPARC + Options.). + + This makes that code unsuitable for use with the special V9 + `-mcmodel=embmedany' (which uses `g4' as a data segment pointer), + and for applications wanting to use those registers for special + purposes. In these cases the only suggestion currently is to + build GMP with CPU `none' to avoid the assembly code. + +SunOS 4 + `/usr/bin/m4' lacks various features needed to process `.asm' + files, and instead `./configure' will automatically use + `/usr/5bin/m4', which we believe is always available (if not then + use GNU m4). + +x86 CPU Types + `i586', `pentium' or `pentiummmx' code is good for its intended P5 + Pentium chips, but quite slow when run on Intel P6 class chips + (PPro, P-II, P-III). `i386' is a better choice when making + binaries that must run on both. + +x86 MMX and SSE2 Code + If the CPU selected has MMX code but the assembler doesn't support + it, a warning is given and non-MMX code is used instead. This + will be an inferior build, since the MMX code that's present is + there because it's faster than the corresponding plain integer + code. The same applies to SSE2. + + Old versions of `gas' don't support MMX instructions, in particular + version 1.92.3 that comes with FreeBSD 2.2.8 or the more recent + OpenBSD 3.1 doesn't. + + Solaris 2.6 and 2.7 `as' generate incorrect object code for + register to register `movq' instructions, and so can't be used for + MMX code. Install a recent `gas' if MMX code is wanted on these + systems. + + +File: gmp.info, Node: Known Build Problems, Next: Performance optimization, Prev: Notes for Particular Systems, Up: Installing GMP + +2.5 Known Build Problems +======================== + +You might find more up-to-date information at `http://gmplib.org/'. + +Compiler link options + The version of libtool currently in use rather aggressively strips + compiler options when linking a shared library. This will + hopefully be relaxed in the future, but for now if this is a + problem the suggestion is to create a little script to hide them, + and for instance configure with + + ./configure CC=gcc-with-my-options + +DJGPP (`*-*-msdosdjgpp*') + The DJGPP port of `bash' 2.03 is unable to run the `configure' + script, it exits silently, having died writing a preamble to + `config.log'. Use `bash' 2.04 or higher. + + `make all' was found to run out of memory during the final + `libgmp.la' link on one system tested, despite having 64Mb + available. Running `make libgmp.la' directly helped, perhaps + recursing into the various subdirectories uses up memory. + +GNU binutils `strip' prior to 2.12 + `strip' from GNU binutils 2.11 and earlier should not be used on + the static libraries `libgmp.a' and `libmp.a' since it will + discard all but the last of multiple archive members with the same + name, like the three versions of `init.o' in `libgmp.a'. Binutils + 2.12 or higher can be used successfully. + + The shared libraries `libgmp.so' and `libmp.so' are not affected by + this and any version of `strip' can be used on them. + +`make' syntax error + On certain versions of SCO OpenServer 5 and IRIX 6.5 the native + `make' is unable to handle the long dependencies list for + `libgmp.la'. The symptom is a "syntax error" on the following + line of the top-level `Makefile'. + + libgmp.la: $(libgmp_la_OBJECTS) $(libgmp_la_DEPENDENCIES) + + Either use GNU Make, or as a workaround remove + `$(libgmp_la_DEPENDENCIES)' from that line (which will make the + initial build work, but if any recompiling is done `libgmp.la' + might not be rebuilt). + +MacOS X (`*-*-darwin*') + Libtool currently only knows how to create shared libraries on + MacOS X using the native `cc' (which is a modified GCC), not a + plain GCC. A static-only build should work though + (`--disable-shared'). + +NeXT prior to 3.3 + The system compiler on old versions of NeXT was a massacred and + old GCC, even if it called itself `cc'. This compiler cannot be + used to build GMP, you need to get a real GCC, and install that. + (NeXT may have fixed this in release 3.3 of their system.) + +POWER and PowerPC + Bugs in GCC 2.7.2 (and 2.6.3) mean it can't be used to compile GMP + on POWER or PowerPC. If you want to use GCC for these machines, + get GCC 2.7.2.1 (or later). + +Sequent Symmetry + Use the GNU assembler instead of the system assembler, since the + latter has serious bugs. + +Solaris 2.6 + The system `sed' prints an error "Output line too long" when + libtool builds `libgmp.la'. This doesn't seem to cause any + obvious ill effects, but GNU `sed' is recommended, to avoid any + doubt. + +Sparc Solaris 2.7 with gcc 2.95.2 in `ABI=32' + A shared library build of GMP seems to fail in this combination, + it builds but then fails the tests, apparently due to some + incorrect data relocations within `gmp_randinit_lc_2exp_size'. + The exact cause is unknown, `--disable-shared' is recommended. + + +File: gmp.info, Node: Performance optimization, Prev: Known Build Problems, Up: Installing GMP + +2.6 Performance optimization +============================ + +For optimal performance, build GMP for the exact CPU type of the target +computer, see *Note Build Options::. + + Unlike what is the case for most other programs, the compiler +typically doesn't matter much, since GMP uses assembly language for the +most critical operation. + + In particular for long-running GMP applications, and applications +demanding extremely large numbers, building and running the `tuneup' +program in the `tune' subdirectory, can be important. For example, + + cd tune + make tuneup + ./tuneup + + will generate better contents for the `gmp-mparam.h' parameter file. + + To use the results, put the output in the file file indicated in the +`Parameters for ...' header. Then recompile from scratch. + + The `tuneup' program takes one useful parameter, `-f NNN', which +instructs the program how long to check FFT multiply parameters. If +you're going to use GMP for extremely large numbers, you may want to +run `tuneup' with a large NNN value. + + +File: gmp.info, Node: GMP Basics, Next: Reporting Bugs, Prev: Installing GMP, Up: Top + +3 GMP Basics +************ + +*Using functions, macros, data types, etc. not documented in this +manual is strongly discouraged. If you do so your application is +guaranteed to be incompatible with future versions of GMP.* + +* Menu: + +* Headers and Libraries:: +* Nomenclature and Types:: +* Function Classes:: +* Variable Conventions:: +* Parameter Conventions:: +* Memory Management:: +* Reentrancy:: +* Useful Macros and Constants:: +* Compatibility with older versions:: +* Demonstration Programs:: +* Efficiency:: +* Debugging:: +* Profiling:: +* Autoconf:: +* Emacs:: + + +File: gmp.info, Node: Headers and Libraries, Next: Nomenclature and Types, Prev: GMP Basics, Up: GMP Basics + +3.1 Headers and Libraries +========================= + +All declarations needed to use GMP are collected in the include file +`gmp.h'. It is designed to work with both C and C++ compilers. + + #include + + Note however that prototypes for GMP functions with `FILE *' +parameters are only provided if `' is included too. + + #include + #include + + Likewise `' (or `') is required for prototypes +with `va_list' parameters, such as `gmp_vprintf'. And `' +for prototypes with `struct obstack' parameters, such as +`gmp_obstack_printf', when available. + + All programs using GMP must link against the `libgmp' library. On a +typical Unix-like system this can be done with `-lgmp', for example + + gcc myprogram.c -lgmp + + GMP C++ functions are in a separate `libgmpxx' library. This is +built and installed if C++ support has been enabled (*note Build +Options::). For example, + + g++ mycxxprog.cc -lgmpxx -lgmp + + GMP is built using Libtool and an application can use that to link +if desired, *note GNU Libtool: (libtool)Top. + + If GMP has been installed to a non-standard location then it may be +necessary to use `-I' and `-L' compiler options to point to the right +directories, and some sort of run-time path for a shared library. + + +File: gmp.info, Node: Nomenclature and Types, Next: Function Classes, Prev: Headers and Libraries, Up: GMP Basics + +3.2 Nomenclature and Types +========================== + +In this manual, "integer" usually means a multiple precision integer, as +defined by the GMP library. The C data type for such integers is +`mpz_t'. Here are some examples of how to declare such integers: + + mpz_t sum; + + struct foo { mpz_t x, y; }; + + mpz_t vec[20]; + + "Rational number" means a multiple precision fraction. The C data +type for these fractions is `mpq_t'. For example: + + mpq_t quotient; + + "Floating point number" or "Float" for short, is an arbitrary +precision mantissa with a limited precision exponent. The C data type +for such objects is `mpf_t'. For example: + + mpf_t fp; + + The floating point functions accept and return exponents in the C +type `mp_exp_t'. Currently this is usually a `long', but on some +systems it's an `int' for efficiency. + + A "limb" means the part of a multi-precision number that fits in a +single machine word. (We chose this word because a limb of the human +body is analogous to a digit, only larger, and containing several +digits.) Normally a limb is 32 or 64 bits. The C data type for a limb +is `mp_limb_t'. + + Counts of limbs of a multi-precision number represented in the C type +`mp_size_t'. Currently this is normally a `long', but on some systems +it's an `int' for efficiency, and on some systems it will be `long +long' in the future. + + Counts of bits of a multi-precision number are represented in the C +type `mp_bitcnt_t'. Currently this is always an `unsigned long', but on +some systems it will be an `unsigned long long' in the future . + + "Random state" means an algorithm selection and current state data. +The C data type for such objects is `gmp_randstate_t'. For example: + + gmp_randstate_t rstate; + + Also, in general `mp_bitcnt_t' is used for bit counts and ranges, and +`size_t' is used for byte or character counts. + + +File: gmp.info, Node: Function Classes, Next: Variable Conventions, Prev: Nomenclature and Types, Up: GMP Basics + +3.3 Function Classes +==================== + +There are six classes of functions in the GMP library: + + 1. Functions for signed integer arithmetic, with names beginning with + `mpz_'. The associated type is `mpz_t'. There are about 150 + functions in this class. (*note Integer Functions::) + + 2. Functions for rational number arithmetic, with names beginning with + `mpq_'. The associated type is `mpq_t'. There are about 40 + functions in this class, but the integer functions can be used for + arithmetic on the numerator and denominator separately. (*note + Rational Number Functions::) + + 3. Functions for floating-point arithmetic, with names beginning with + `mpf_'. The associated type is `mpf_t'. There are about 60 + functions is this class. (*note Floating-point Functions::) + + 4. Functions compatible with Berkeley MP, such as `itom', `madd', and + `mult'. The associated type is `MINT'. (*note BSD Compatible + Functions::) + + 5. Fast low-level functions that operate on natural numbers. These + are used by the functions in the preceding groups, and you can + also call them directly from very time-critical user programs. + These functions' names begin with `mpn_'. The associated type is + array of `mp_limb_t'. There are about 30 (hard-to-use) functions + in this class. (*note Low-level Functions::) + + 6. Miscellaneous functions. Functions for setting up custom + allocation and functions for generating random numbers. (*note + Custom Allocation::, and *note Random Number Functions::) + + +File: gmp.info, Node: Variable Conventions, Next: Parameter Conventions, Prev: Function Classes, Up: GMP Basics + +3.4 Variable Conventions +======================== + +GMP functions generally have output arguments before input arguments. +This notation is by analogy with the assignment operator. The BSD MP +compatibility functions are exceptions, having the output arguments +last. + + GMP lets you use the same variable for both input and output in one +call. For example, the main function for integer multiplication, +`mpz_mul', can be used to square `x' and put the result back in `x' with + + mpz_mul (x, x, x); + + Before you can assign to a GMP variable, you need to initialize it +by calling one of the special initialization functions. When you're +done with a variable, you need to clear it out, using one of the +functions for that purpose. Which function to use depends on the type +of variable. See the chapters on integer functions, rational number +functions, and floating-point functions for details. + + A variable should only be initialized once, or at least cleared +between each initialization. After a variable has been initialized, it +may be assigned to any number of times. + + For efficiency reasons, avoid excessive initializing and clearing. +In general, initialize near the start of a function and clear near the +end. For example, + + void + foo (void) + { + mpz_t n; + int i; + mpz_init (n); + for (i = 1; i < 100; i++) + { + mpz_mul (n, ...); + mpz_fdiv_q (n, ...); + ... + } + mpz_clear (n); + } + + +File: gmp.info, Node: Parameter Conventions, Next: Memory Management, Prev: Variable Conventions, Up: GMP Basics + +3.5 Parameter Conventions +========================= + +When a GMP variable is used as a function parameter, it's effectively a +call-by-reference, meaning if the function stores a value there it will +change the original in the caller. Parameters which are input-only can +be designated `const' to provoke a compiler error or warning on +attempting to modify them. + + When a function is going to return a GMP result, it should designate +a parameter that it sets, like the library functions do. More than one +value can be returned by having more than one output parameter, again +like the library functions. A `return' of an `mpz_t' etc doesn't +return the object, only a pointer, and this is almost certainly not +what's wanted. + + Here's an example accepting an `mpz_t' parameter, doing a +calculation, and storing the result to the indicated parameter. + + void + foo (mpz_t result, const mpz_t param, unsigned long n) + { + unsigned long i; + mpz_mul_ui (result, param, n); + for (i = 1; i < n; i++) + mpz_add_ui (result, result, i*7); + } + + int + main (void) + { + mpz_t r, n; + mpz_init (r); + mpz_init_set_str (n, "123456", 0); + foo (r, n, 20L); + gmp_printf ("%Zd\n", r); + return 0; + } + + `foo' works even if the mainline passes the same variable for +`param' and `result', just like the library functions. But sometimes +it's tricky to make that work, and an application might not want to +bother supporting that sort of thing. + + For interest, the GMP types `mpz_t' etc are implemented as +one-element arrays of certain structures. This is why declaring a +variable creates an object with the fields GMP needs, but then using it +as a parameter passes a pointer to the object. Note that the actual +fields in each `mpz_t' etc are for internal use only and should not be +accessed directly by code that expects to be compatible with future GMP +releases. + + +File: gmp.info, Node: Memory Management, Next: Reentrancy, Prev: Parameter Conventions, Up: GMP Basics + +3.6 Memory Management +===================== + +The GMP types like `mpz_t' are small, containing only a couple of sizes, +and pointers to allocated data. Once a variable is initialized, GMP +takes care of all space allocation. Additional space is allocated +whenever a variable doesn't have enough. + + `mpz_t' and `mpq_t' variables never reduce their allocated space. +Normally this is the best policy, since it avoids frequent reallocation. +Applications that need to return memory to the heap at some particular +point can use `mpz_realloc2', or clear variables no longer needed. + + `mpf_t' variables, in the current implementation, use a fixed amount +of space, determined by the chosen precision and allocated at +initialization, so their size doesn't change. + + All memory is allocated using `malloc' and friends by default, but +this can be changed, see *Note Custom Allocation::. Temporary memory +on the stack is also used (via `alloca'), but this can be changed at +build-time if desired, see *Note Build Options::. + + +File: gmp.info, Node: Reentrancy, Next: Useful Macros and Constants, Prev: Memory Management, Up: GMP Basics + +3.7 Reentrancy +============== + +GMP is reentrant and thread-safe, with some exceptions: + + * If configured with `--enable-alloca=malloc-notreentrant' (or with + `--enable-alloca=notreentrant' when `alloca' is not available), + then naturally GMP is not reentrant. + + * `mpf_set_default_prec' and `mpf_init' use a global variable for the + selected precision. `mpf_init2' can be used instead, and in the + C++ interface an explicit precision to the `mpf_class' constructor. + + * `mpz_random' and the other old random number functions use a global + random state and are hence not reentrant. The newer random number + functions that accept a `gmp_randstate_t' parameter can be used + instead. + + * `gmp_randinit' (obsolete) returns an error indication through a + global variable, which is not thread safe. Applications are + advised to use `gmp_randinit_default' or `gmp_randinit_lc_2exp' + instead. + + * `mp_set_memory_functions' uses global variables to store the + selected memory allocation functions. + + * If the memory allocation functions set by a call to + `mp_set_memory_functions' (or `malloc' and friends by default) are + not reentrant, then GMP will not be reentrant either. + + * If the standard I/O functions such as `fwrite' are not reentrant + then the GMP I/O functions using them will not be reentrant either. + + * It's safe for two threads to read from the same GMP variable + simultaneously, but it's not safe for one to read while the + another might be writing, nor for two threads to write + simultaneously. It's not safe for two threads to generate a + random number from the same `gmp_randstate_t' simultaneously, + since this involves an update of that variable. + + +File: gmp.info, Node: Useful Macros and Constants, Next: Compatibility with older versions, Prev: Reentrancy, Up: GMP Basics + +3.8 Useful Macros and Constants +=============================== + + -- Global Constant: const int mp_bits_per_limb + The number of bits per limb. + + -- Macro: __GNU_MP_VERSION + -- Macro: __GNU_MP_VERSION_MINOR + -- Macro: __GNU_MP_VERSION_PATCHLEVEL + The major and minor GMP version, and patch level, respectively, as + integers. For GMP i.j, these numbers will be i, j, and 0, + respectively. For GMP i.j.k, these numbers will be i, j, and k, + respectively. + + -- Global Constant: const char * const gmp_version + The GMP version number, as a null-terminated string, in the form + "i.j.k". This release is "5.0.1". Note that the format "i.j" was + used when k was zero was used before version 4.3.0. + + -- Macro: __GMP_CC + -- Macro: __GMP_CFLAGS + The compiler and compiler flags, respectively, used when compiling + GMP, as strings. + + +File: gmp.info, Node: Compatibility with older versions, Next: Demonstration Programs, Prev: Useful Macros and Constants, Up: GMP Basics + +3.9 Compatibility with older versions +===================================== + +This version of GMP is upwardly binary compatible with all 4.x and 3.x +versions, and upwardly compatible at the source level with all 2.x +versions, with the following exceptions. + + * `mpn_gcd' had its source arguments swapped as of GMP 3.0, for + consistency with other `mpn' functions. + + * `mpf_get_prec' counted precision slightly differently in GMP 3.0 + and 3.0.1, but in 3.1 reverted to the 2.x style. + + There are a number of compatibility issues between GMP 1 and GMP 2 +that of course also apply when porting applications from GMP 1 to GMP +4. Please see the GMP 2 manual for details. + + The Berkeley MP compatibility library (*note BSD Compatible +Functions::) is source and binary compatible with the standard `libmp'. + + +File: gmp.info, Node: Demonstration Programs, Next: Efficiency, Prev: Compatibility with older versions, Up: GMP Basics + +3.10 Demonstration programs +=========================== + +The `demos' subdirectory has some sample programs using GMP. These +aren't built or installed, but there's a `Makefile' with rules for them. +For instance, + + make pexpr + ./pexpr 68^975+10 + +The following programs are provided + + * `pexpr' is an expression evaluator, the program used on the GMP + web page. + + * The `calc' subdirectory has a similar but simpler evaluator using + `lex' and `yacc'. + + * The `expr' subdirectory is yet another expression evaluator, a + library designed for ease of use within a C program. See + `demos/expr/README' for more information. + + * `factorize' is a Pollard-Rho factorization program. + + * `isprime' is a command-line interface to the `mpz_probab_prime_p' + function. + + * `primes' counts or lists primes in an interval, using a sieve. + + * `qcn' is an example use of `mpz_kronecker_ui' to estimate quadratic + class numbers. + + * The `perl' subdirectory is a comprehensive perl interface to GMP. + See `demos/perl/INSTALL' for more information. Documentation is + in POD format in `demos/perl/GMP.pm'. + + As an aside, consideration has been given at various times to some +sort of expression evaluation within the main GMP library. Going +beyond something minimal quickly leads to matters like user-defined +functions, looping, fixnums for control variables, etc, which are +considered outside the scope of GMP (much closer to language +interpreters or compilers, *Note Language Bindings::.) Something +simple for program input convenience may yet be a possibility, a +combination of the `expr' demo and the `pexpr' tree back-end perhaps. +But for now the above evaluators are offered as illustrations. + + +File: gmp.info, Node: Efficiency, Next: Debugging, Prev: Demonstration Programs, Up: GMP Basics + +3.11 Efficiency +=============== + +Small Operands + On small operands, the time for function call overheads and memory + allocation can be significant in comparison to actual calculation. + This is unavoidable in a general purpose variable precision + library, although GMP attempts to be as efficient as it can on + both large and small operands. + +Static Linking + On some CPUs, in particular the x86s, the static `libgmp.a' should + be used for maximum speed, since the PIC code in the shared + `libgmp.so' will have a small overhead on each function call and + global data address. For many programs this will be + insignificant, but for long calculations there's a gain to be had. + +Initializing and Clearing + Avoid excessive initializing and clearing of variables, since this + can be quite time consuming, especially in comparison to otherwise + fast operations like addition. + + A language interpreter might want to keep a free list or stack of + initialized variables ready for use. It should be possible to + integrate something like that with a garbage collector too. + +Reallocations + An `mpz_t' or `mpq_t' variable used to hold successively increasing + values will have its memory repeatedly `realloc'ed, which could be + quite slow or could fragment memory, depending on the C library. + If an application can estimate the final size then `mpz_init2' or + `mpz_realloc2' can be called to allocate the necessary space from + the beginning (*note Initializing Integers::). + + It doesn't matter if a size set with `mpz_init2' or `mpz_realloc2' + is too small, since all functions will do a further reallocation + if necessary. Badly overestimating memory required will waste + space though. + +`2exp' Functions + It's up to an application to call functions like `mpz_mul_2exp' + when appropriate. General purpose functions like `mpz_mul' make + no attempt to identify powers of two or other special forms, + because such inputs will usually be very rare and testing every + time would be wasteful. + +`ui' and `si' Functions + The `ui' functions and the small number of `si' functions exist for + convenience and should be used where applicable. But if for + example an `mpz_t' contains a value that fits in an `unsigned + long' there's no need extract it and call a `ui' function, just + use the regular `mpz' function. + +In-Place Operations + `mpz_abs', `mpq_abs', `mpf_abs', `mpz_neg', `mpq_neg' and + `mpf_neg' are fast when used for in-place operations like + `mpz_abs(x,x)', since in the current implementation only a single + field of `x' needs changing. On suitable compilers (GCC for + instance) this is inlined too. + + `mpz_add_ui', `mpz_sub_ui', `mpf_add_ui' and `mpf_sub_ui' benefit + from an in-place operation like `mpz_add_ui(x,x,y)', since usually + only one or two limbs of `x' will need to be changed. The same + applies to the full precision `mpz_add' etc if `y' is small. If + `y' is big then cache locality may be helped, but that's all. + + `mpz_mul' is currently the opposite, a separate destination is + slightly better. A call like `mpz_mul(x,x,y)' will, unless `y' is + only one limb, make a temporary copy of `x' before forming the + result. Normally that copying will only be a tiny fraction of the + time for the multiply, so this is not a particularly important + consideration. + + `mpz_set', `mpq_set', `mpq_set_num', `mpf_set', etc, make no + attempt to recognise a copy of something to itself, so a call like + `mpz_set(x,x)' will be wasteful. Naturally that would never be + written deliberately, but if it might arise from two pointers to + the same object then a test to avoid it might be desirable. + + if (x != y) + mpz_set (x, y); + + Note that it's never worth introducing extra `mpz_set' calls just + to get in-place operations. If a result should go to a particular + variable then just direct it there and let GMP take care of data + movement. + +Divisibility Testing (Small Integers) + `mpz_divisible_ui_p' and `mpz_congruent_ui_p' are the best + functions for testing whether an `mpz_t' is divisible by an + individual small integer. They use an algorithm which is faster + than `mpz_tdiv_ui', but which gives no useful information about + the actual remainder, only whether it's zero (or a particular + value). + + However when testing divisibility by several small integers, it's + best to take a remainder modulo their product, to save + multi-precision operations. For instance to test whether a number + is divisible by any of 23, 29 or 31 take a remainder modulo + 23*29*31 = 20677 and then test that. + + The division functions like `mpz_tdiv_q_ui' which give a quotient + as well as a remainder are generally a little slower than the + remainder-only functions like `mpz_tdiv_ui'. If the quotient is + only rarely wanted then it's probably best to just take a + remainder and then go back and calculate the quotient if and when + it's wanted (`mpz_divexact_ui' can be used if the remainder is + zero). + +Rational Arithmetic + The `mpq' functions operate on `mpq_t' values with no common + factors in the numerator and denominator. Common factors are + checked-for and cast out as necessary. In general, cancelling + factors every time is the best approach since it minimizes the + sizes for subsequent operations. + + However, applications that know something about the factorization + of the values they're working with might be able to avoid some of + the GCDs used for canonicalization, or swap them for divisions. + For example when multiplying by a prime it's enough to check for + factors of it in the denominator instead of doing a full GCD. Or + when forming a big product it might be known that very little + cancellation will be possible, and so canonicalization can be left + to the end. + + The `mpq_numref' and `mpq_denref' macros give access to the + numerator and denominator to do things outside the scope of the + supplied `mpq' functions. *Note Applying Integer Functions::. + + The canonical form for rationals allows mixed-type `mpq_t' and + integer additions or subtractions to be done directly with + multiples of the denominator. This will be somewhat faster than + `mpq_add'. For example, + + /* mpq increment */ + mpz_add (mpq_numref(q), mpq_numref(q), mpq_denref(q)); + + /* mpq += unsigned long */ + mpz_addmul_ui (mpq_numref(q), mpq_denref(q), 123UL); + + /* mpq -= mpz */ + mpz_submul (mpq_numref(q), mpq_denref(q), z); + +Number Sequences + Functions like `mpz_fac_ui', `mpz_fib_ui' and `mpz_bin_uiui' are + designed for calculating isolated values. If a range of values is + wanted it's probably best to call to get a starting point and + iterate from there. + +Text Input/Output + Hexadecimal or octal are suggested for input or output in text + form. Power-of-2 bases like these can be converted much more + efficiently than other bases, like decimal. For big numbers + there's usually nothing of particular interest to be seen in the + digits, so the base doesn't matter much. + + Maybe we can hope octal will one day become the normal base for + everyday use, as proposed by King Charles XII of Sweden and later + reformers. + + +File: gmp.info, Node: Debugging, Next: Profiling, Prev: Efficiency, Up: GMP Basics + +3.12 Debugging +============== + +Stack Overflow + Depending on the system, a segmentation violation or bus error + might be the only indication of stack overflow. See + `--enable-alloca' choices in *Note Build Options::, for how to + address this. + + In new enough versions of GCC, `-fstack-check' may be able to + ensure an overflow is recognised by the system before too much + damage is done, or `-fstack-limit-symbol' or + `-fstack-limit-register' may be able to add checking if the system + itself doesn't do any (*note Options for Code Generation: + (gcc)Code Gen Options.). These options must be added to the + `CFLAGS' used in the GMP build (*note Build Options::), adding + them just to an application will have no effect. Note also + they're a slowdown, adding overhead to each function call and each + stack allocation. + +Heap Problems + The most likely cause of application problems with GMP is heap + corruption. Failing to `init' GMP variables will have + unpredictable effects, and corruption arising elsewhere in a + program may well affect GMP. Initializing GMP variables more than + once or failing to clear them will cause memory leaks. + + In all such cases a `malloc' debugger is recommended. On a GNU or + BSD system the standard C library `malloc' has some diagnostic + facilities, see *Note Allocation Debugging: (libc)Allocation + Debugging, or `man 3 malloc'. Other possibilities, in no + particular order, include + + `http://www.inf.ethz.ch/personal/biere/projects/ccmalloc/' + `http://dmalloc.com/' + `http://www.perens.com/FreeSoftware/' (electric fence) + `http://packages.debian.org/stable/devel/fda' + `http://www.gnupdate.org/components/leakbug/' + `http://people.redhat.com/~otaylor/memprof/' + `http://www.cbmamiga.demon.co.uk/mpatrol/' + + The GMP default allocation routines in `memory.c' also have a + simple sentinel scheme which can be enabled with `#define DEBUG' + in that file. This is mainly designed for detecting buffer + overruns during GMP development, but might find other uses. + +Stack Backtraces + On some systems the compiler options GMP uses by default can + interfere with debugging. In particular on x86 and 68k systems + `-fomit-frame-pointer' is used and this generally inhibits stack + backtracing. Recompiling without such options may help while + debugging, though the usual caveats about it potentially moving a + memory problem or hiding a compiler bug will apply. + +GDB, the GNU Debugger + A sample `.gdbinit' is included in the distribution, showing how + to call some undocumented dump functions to print GMP variables + from within GDB. Note that these functions shouldn't be used in + final application code since they're undocumented and may be + subject to incompatible changes in future versions of GMP. + +Source File Paths + GMP has multiple source files with the same name, in different + directories. For example `mpz', `mpq' and `mpf' each have an + `init.c'. If the debugger can't already determine the right one + it may help to build with absolute paths on each C file. One way + to do that is to use a separate object directory with an absolute + path to the source directory. + + cd /my/build/dir + /my/source/dir/gmp-5.0.1/configure + + This works via `VPATH', and might require GNU `make'. Alternately + it might be possible to change the `.c.lo' rules appropriately. + +Assertion Checking + The build option `--enable-assert' is available to add some + consistency checks to the library (see *Note Build Options::). + These are likely to be of limited value to most applications. + Assertion failures are just as likely to indicate memory + corruption as a library or compiler bug. + + Applications using the low-level `mpn' functions, however, will + benefit from `--enable-assert' since it adds checks on the + parameters of most such functions, many of which have subtle + restrictions on their usage. Note however that only the generic C + code has checks, not the assembly code, so CPU `none' should be + used for maximum checking. + +Temporary Memory Checking + The build option `--enable-alloca=debug' arranges that each block + of temporary memory in GMP is allocated with a separate call to + `malloc' (or the allocation function set with + `mp_set_memory_functions'). + + This can help a malloc debugger detect accesses outside the + intended bounds, or detect memory not released. In a normal + build, on the other hand, temporary memory is allocated in blocks + which GMP divides up for its own use, or may be allocated with a + compiler builtin `alloca' which will go nowhere near any malloc + debugger hooks. + +Maximum Debuggability + To summarize the above, a GMP build for maximum debuggability + would be + + ./configure --disable-shared --enable-assert \ + --enable-alloca=debug --host=none CFLAGS=-g + + For C++, add `--enable-cxx CXXFLAGS=-g'. + +Checker + The GCC checker (`http://savannah.nongnu.org/projects/checker/') + can be used with GMP. It contains a stub library which means GMP + applications compiled with checker can use a normal GMP build. + + A build of GMP with checking within GMP itself can be made. This + will run very very slowly. On GNU/Linux for example, + + ./configure --host=none-pc-linux-gnu CC=checkergcc + + `--host=none' must be used, since the GMP assembly code doesn't + support the checking scheme. The GMP C++ features cannot be used, + since current versions of checker (0.9.9.1) don't yet support the + standard C++ library. + +Valgrind + The valgrind program (`http://valgrind.org/') is a memory checker + for x86s. It translates and emulates machine instructions to do + strong checks for uninitialized data (at the level of individual + bits), memory accesses through bad pointers, and memory leaks. + + Recent versions of Valgrind are getting support for MMX and + SSE/SSE2 instructions, for past versions GMP will need to be + configured not to use those, ie. for an x86 without them (for + instance plain `i486'). + +Other Problems + Any suspected bug in GMP itself should be isolated to make sure + it's not an application problem, see *Note Reporting Bugs::. + + +File: gmp.info, Node: Profiling, Next: Autoconf, Prev: Debugging, Up: GMP Basics + +3.13 Profiling +============== + +Running a program under a profiler is a good way to find where it's +spending most time and where improvements can be best sought. The +profiling choices for a GMP build are as follows. + +`--disable-profiling' + The default is to add nothing special for profiling. + + It should be possible to just compile the mainline of a program + with `-p' and use `prof' to get a profile consisting of + timer-based sampling of the program counter. Most of the GMP + assembly code has the necessary symbol information. + + This approach has the advantage of minimizing interference with + normal program operation, but on most systems the resolution of + the sampling is quite low (10 milliseconds for instance), + requiring long runs to get accurate information. + +`--enable-profiling=prof' + Build with support for the system `prof', which means `-p' added + to the `CFLAGS'. + + This provides call counting in addition to program counter + sampling, which allows the most frequently called routines to be + identified, and an average time spent in each routine to be + determined. + + The x86 assembly code has support for this option, but on other + processors the assembly routines will be as if compiled without + `-p' and therefore won't appear in the call counts. + + On some systems, such as GNU/Linux, `-p' in fact means `-pg' and in + this case `--enable-profiling=gprof' described below should be used + instead. + +`--enable-profiling=gprof' + Build with support for `gprof', which means `-pg' added to the + `CFLAGS'. + + This provides call graph construction in addition to call counting + and program counter sampling, which makes it possible to count + calls coming from different locations. For example the number of + calls to `mpn_mul' from `mpz_mul' versus the number from + `mpf_mul'. The program counter sampling is still flat though, so + only a total time in `mpn_mul' would be accumulated, not a + separate amount for each call site. + + The x86 assembly code has support for this option, but on other + processors the assembly routines will be as if compiled without + `-pg' and therefore not be included in the call counts. + + On x86 and m68k systems `-pg' and `-fomit-frame-pointer' are + incompatible, so the latter is omitted from the default flags in + that case, which might result in poorer code generation. + + Incidentally, it should be possible to use the `gprof' program + with a plain `--enable-profiling=prof' build. But in that case + only the `gprof -p' flat profile and call counts can be expected + to be valid, not the `gprof -q' call graph. + +`--enable-profiling=instrument' + Build with the GCC option `-finstrument-functions' added to the + `CFLAGS' (*note Options for Code Generation: (gcc)Code Gen + Options.). + + This inserts special instrumenting calls at the start and end of + each function, allowing exact timing and full call graph + construction. + + This instrumenting is not normally a standard system feature and + will require support from an external library, such as + + `http://sourceforge.net/projects/fnccheck/' + + This should be included in `LIBS' during the GMP configure so that + test programs will link. For example, + + ./configure --enable-profiling=instrument LIBS=-lfc + + On a GNU system the C library provides dummy instrumenting + functions, so programs compiled with this option will link. In + this case it's only necessary to ensure the correct library is + added when linking an application. + + The x86 assembly code supports this option, but on other + processors the assembly routines will be as if compiled without + `-finstrument-functions' meaning time spent in them will + effectively be attributed to their caller. + + +File: gmp.info, Node: Autoconf, Next: Emacs, Prev: Profiling, Up: GMP Basics + +3.14 Autoconf +============= + +Autoconf based applications can easily check whether GMP is installed. +The only thing to be noted is that GMP library symbols from version 3 +onwards have prefixes like `__gmpz'. The following therefore would be +a simple test, + + AC_CHECK_LIB(gmp, __gmpz_init) + + This just uses the default `AC_CHECK_LIB' actions for found or not +found, but an application that must have GMP would want to generate an +error if not found. For example, + + AC_CHECK_LIB(gmp, __gmpz_init, , + [AC_MSG_ERROR([GNU MP not found, see http://gmplib.org/])]) + + If functions added in some particular version of GMP are required, +then one of those can be used when checking. For example `mpz_mul_si' +was added in GMP 3.1, + + AC_CHECK_LIB(gmp, __gmpz_mul_si, , + [AC_MSG_ERROR( + [GNU MP not found, or not 3.1 or up, see http://gmplib.org/])]) + + An alternative would be to test the version number in `gmp.h' using +say `AC_EGREP_CPP'. That would make it possible to test the exact +version, if some particular sub-minor release is known to be necessary. + + In general it's recommended that applications should simply demand a +new enough GMP rather than trying to provide supplements for features +not available in past versions. + + Occasionally an application will need or want to know the size of a +type at configuration or preprocessing time, not just with `sizeof' in +the code. This can be done in the normal way with `mp_limb_t' etc, but +GMP 4.0 or up is best for this, since prior versions needed certain +`-D' defines on systems using a `long long' limb. The following would +suit Autoconf 2.50 or up, + + AC_CHECK_SIZEOF(mp_limb_t, , [#include ]) + + +File: gmp.info, Node: Emacs, Prev: Autoconf, Up: GMP Basics + +3.15 Emacs +========== + + (`info-lookup-symbol') is a good way to find documentation on +C functions while editing (*note Info Documentation Lookup: (emacs)Info +Lookup.). + + The GMP manual can be included in such lookups by putting the +following in your `.emacs', + + (eval-after-load "info-look" + '(let ((mode-value (assoc 'c-mode (assoc 'symbol info-lookup-alist)))) + (setcar (nthcdr 3 mode-value) + (cons '("(gmp)Function Index" nil "^ -.* " "\\>") + (nth 3 mode-value))))) + + +File: gmp.info, Node: Reporting Bugs, Next: Integer Functions, Prev: GMP Basics, Up: Top + +4 Reporting Bugs +**************** + +If you think you have found a bug in the GMP library, please +investigate it and report it. We have made this library available to +you, and it is not too much to ask you to report the bugs you find. + + Before you report a bug, check it's not already addressed in *Note +Known Build Problems::, or perhaps *Note Notes for Particular +Systems::. You may also want to check `http://gmplib.org/' for patches +for this release. + + Please include the following in any report, + + * The GMP version number, and if pre-packaged or patched then say so. + + * A test program that makes it possible for us to reproduce the bug. + Include instructions on how to run the program. + + * A description of what is wrong. If the results are incorrect, in + what way. If you get a crash, say so. + + * If you get a crash, include a stack backtrace from the debugger if + it's informative (`where' in `gdb', or `$C' in `adb'). + + * Please do not send core dumps, executables or `strace's. + + * The configuration options you used when building GMP, if any. + + * The name of the compiler and its version. For `gcc', get the + version with `gcc -v', otherwise perhaps `what `which cc`', or + similar. + + * The output from running `uname -a'. + + * The output from running `./config.guess', and from running + `./configfsf.guess' (might be the same). + + * If the bug is related to `configure', then the compressed contents + of `config.log'. + + * If the bug is related to an `asm' file not assembling, then the + contents of `config.m4' and the offending line or lines from the + temporary `mpn/tmp-.s'. + + Please make an effort to produce a self-contained report, with +something definite that can be tested or debugged. Vague queries or +piecemeal messages are difficult to act on and don't help the +development effort. + + It is not uncommon that an observed problem is actually due to a bug +in the compiler; the GMP code tends to explore interesting corners in +compilers. + + If your bug report is good, we will do our best to help you get a +corrected version of the library; if the bug report is poor, we won't +do anything about it (except maybe ask you to send a better report). + + Send your report to: . + + If you think something in this manual is unclear, or downright +incorrect, or if the language needs to be improved, please send a note +to the same address. + + +File: gmp.info, Node: Integer Functions, Next: Rational Number Functions, Prev: Reporting Bugs, Up: Top + +5 Integer Functions +******************* + +This chapter describes the GMP functions for performing integer +arithmetic. These functions start with the prefix `mpz_'. + + GMP integers are stored in objects of type `mpz_t'. + +* Menu: + +* Initializing Integers:: +* Assigning Integers:: +* Simultaneous Integer Init & Assign:: +* Converting Integers:: +* Integer Arithmetic:: +* Integer Division:: +* Integer Exponentiation:: +* Integer Roots:: +* Number Theoretic Functions:: +* Integer Comparisons:: +* Integer Logic and Bit Fiddling:: +* I/O of Integers:: +* Integer Random Numbers:: +* Integer Import and Export:: +* Miscellaneous Integer Functions:: +* Integer Special Functions:: + + +File: gmp.info, Node: Initializing Integers, Next: Assigning Integers, Prev: Integer Functions, Up: Integer Functions + +5.1 Initialization Functions +============================ + +The functions for integer arithmetic assume that all integer objects are +initialized. You do that by calling the function `mpz_init'. For +example, + + { + mpz_t integ; + mpz_init (integ); + ... + mpz_add (integ, ...); + ... + mpz_sub (integ, ...); + + /* Unless the program is about to exit, do ... */ + mpz_clear (integ); + } + + As you can see, you can store new values any number of times, once an +object is initialized. + + -- Function: void mpz_init (mpz_t X) + Initialize X, and set its value to 0. + + -- Function: void mpz_inits (mpz_t X, ...) + Initialize a NULL-terminated list of `mpz_t' variables, and set + their values to 0. + + -- Function: void mpz_init2 (mpz_t X, mp_bitcnt_t N) + Initialize X, with space for N-bit numbers, and set its value to 0. + Calling this function instead of `mpz_init' or `mpz_inits' is never + necessary; reallocation is handled automatically by GMP when + needed. + + N is only the initial space, X will grow automatically in the + normal way, if necessary, for subsequent values stored. + `mpz_init2' makes it possible to avoid such reallocations if a + maximum size is known in advance. + + -- Function: void mpz_clear (mpz_t X) + Free the space occupied by X. Call this function for all `mpz_t' + variables when you are done with them. + + -- Function: void mpz_clears (mpz_t X, ...) + Free the space occupied by a NULL-terminated list of `mpz_t' + variables. + + -- Function: void mpz_realloc2 (mpz_t X, mp_bitcnt_t N) + Change the space allocated for X to N bits. The value in X is + preserved if it fits, or is set to 0 if not. + + Calling this function is never necessary; reallocation is handled + automatically by GMP when needed. But this function can be used + to increase the space for a variable in order to avoid repeated + automatic reallocations, or to decrease it to give memory back to + the heap. + + +File: gmp.info, Node: Assigning Integers, Next: Simultaneous Integer Init & Assign, Prev: Initializing Integers, Up: Integer Functions + +5.2 Assignment Functions +======================== + +These functions assign new values to already initialized integers +(*note Initializing Integers::). + + -- Function: void mpz_set (mpz_t ROP, mpz_t OP) + -- Function: void mpz_set_ui (mpz_t ROP, unsigned long int OP) + -- Function: void mpz_set_si (mpz_t ROP, signed long int OP) + -- Function: void mpz_set_d (mpz_t ROP, double OP) + -- Function: void mpz_set_q (mpz_t ROP, mpq_t OP) + -- Function: void mpz_set_f (mpz_t ROP, mpf_t OP) + Set the value of ROP from OP. + + `mpz_set_d', `mpz_set_q' and `mpz_set_f' truncate OP to make it an + integer. + + -- Function: int mpz_set_str (mpz_t ROP, char *STR, int BASE) + Set the value of ROP from STR, a null-terminated C string in base + BASE. White space is allowed in the string, and is simply ignored. + + The BASE may vary from 2 to 62, or if BASE is 0, then the leading + characters are used: `0x' and `0X' for hexadecimal, `0b' and `0B' + for binary, `0' for octal, or decimal otherwise. + + For bases up to 36, case is ignored; upper-case and lower-case + letters have the same value. For bases 37 to 62, upper-case + letter represent the usual 10..35 while lower-case letter + represent 36..61. + + This function returns 0 if the entire string is a valid number in + base BASE. Otherwise it returns -1. + + -- Function: void mpz_swap (mpz_t ROP1, mpz_t ROP2) + Swap the values ROP1 and ROP2 efficiently. + + +File: gmp.info, Node: Simultaneous Integer Init & Assign, Next: Converting Integers, Prev: Assigning Integers, Up: Integer Functions + +5.3 Combined Initialization and Assignment Functions +==================================================== + +For convenience, GMP provides a parallel series of initialize-and-set +functions which initialize the output and then store the value there. +These functions' names have the form `mpz_init_set...' + + Here is an example of using one: + + { + mpz_t pie; + mpz_init_set_str (pie, "3141592653589793238462643383279502884", 10); + ... + mpz_sub (pie, ...); + ... + mpz_clear (pie); + } + +Once the integer has been initialized by any of the `mpz_init_set...' +functions, it can be used as the source or destination operand for the +ordinary integer functions. Don't use an initialize-and-set function +on a variable already initialized! + + -- Function: void mpz_init_set (mpz_t ROP, mpz_t OP) + -- Function: void mpz_init_set_ui (mpz_t ROP, unsigned long int OP) + -- Function: void mpz_init_set_si (mpz_t ROP, signed long int OP) + -- Function: void mpz_init_set_d (mpz_t ROP, double OP) + Initialize ROP with limb space and set the initial numeric value + from OP. + + -- Function: int mpz_init_set_str (mpz_t ROP, char *STR, int BASE) + Initialize ROP and set its value like `mpz_set_str' (see its + documentation above for details). + + If the string is a correct base BASE number, the function returns + 0; if an error occurs it returns -1. ROP is initialized even if + an error occurs. (I.e., you have to call `mpz_clear' for it.) + + +File: gmp.info, Node: Converting Integers, Next: Integer Arithmetic, Prev: Simultaneous Integer Init & Assign, Up: Integer Functions + +5.4 Conversion Functions +======================== + +This section describes functions for converting GMP integers to +standard C types. Functions for converting _to_ GMP integers are +described in *Note Assigning Integers:: and *Note I/O of Integers::. + + -- Function: unsigned long int mpz_get_ui (mpz_t OP) + Return the value of OP as an `unsigned long'. + + If OP is too big to fit an `unsigned long' then just the least + significant bits that do fit are returned. The sign of OP is + ignored, only the absolute value is used. + + -- Function: signed long int mpz_get_si (mpz_t OP) + If OP fits into a `signed long int' return the value of OP. + Otherwise return the least significant part of OP, with the same + sign as OP. + + If OP is too big to fit in a `signed long int', the returned + result is probably not very useful. To find out if the value will + fit, use the function `mpz_fits_slong_p'. + + -- Function: double mpz_get_d (mpz_t OP) + Convert OP to a `double', truncating if necessary (ie. rounding + towards zero). + + If the exponent from the conversion is too big, the result is + system dependent. An infinity is returned where available. A + hardware overflow trap may or may not occur. + + -- Function: double mpz_get_d_2exp (signed long int *EXP, mpz_t OP) + Convert OP to a `double', truncating if necessary (ie. rounding + towards zero), and returning the exponent separately. + + The return value is in the range 0.5<=abs(D)<1 and the exponent is + stored to `*EXP'. D * 2^EXP is the (truncated) OP value. If OP + is zero, the return is 0.0 and 0 is stored to `*EXP'. + + This is similar to the standard C `frexp' function (*note + Normalization Functions: (libc)Normalization Functions.). + + -- Function: char * mpz_get_str (char *STR, int BASE, mpz_t OP) + Convert OP to a string of digits in base BASE. The base argument + may vary from 2 to 62 or from -2 to -36. + + For BASE in the range 2..36, digits and lower-case letters are + used; for -2..-36, digits and upper-case letters are used; for + 37..62, digits, upper-case letters, and lower-case letters (in + that significance order) are used. + + If STR is `NULL', the result string is allocated using the current + allocation function (*note Custom Allocation::). The block will be + `strlen(str)+1' bytes, that being exactly enough for the string and + null-terminator. + + If STR is not `NULL', it should point to a block of storage large + enough for the result, that being `mpz_sizeinbase (OP, BASE) + 2'. + The two extra bytes are for a possible minus sign, and the + null-terminator. + + A pointer to the result string is returned, being either the + allocated block, or the given STR. + + +File: gmp.info, Node: Integer Arithmetic, Next: Integer Division, Prev: Converting Integers, Up: Integer Functions + +5.5 Arithmetic Functions +======================== + + -- Function: void mpz_add (mpz_t ROP, mpz_t OP1, mpz_t OP2) + -- Function: void mpz_add_ui (mpz_t ROP, mpz_t OP1, unsigned long int + OP2) + Set ROP to OP1 + OP2. + + -- Function: void mpz_sub (mpz_t ROP, mpz_t OP1, mpz_t OP2) + -- Function: void mpz_sub_ui (mpz_t ROP, mpz_t OP1, unsigned long int + OP2) + -- Function: void mpz_ui_sub (mpz_t ROP, unsigned long int OP1, mpz_t + OP2) + Set ROP to OP1 - OP2. + + -- Function: void mpz_mul (mpz_t ROP, mpz_t OP1, mpz_t OP2) + -- Function: void mpz_mul_si (mpz_t ROP, mpz_t OP1, long int OP2) + -- Function: void mpz_mul_ui (mpz_t ROP, mpz_t OP1, unsigned long int + OP2) + Set ROP to OP1 times OP2. + + -- Function: void mpz_addmul (mpz_t ROP, mpz_t OP1, mpz_t OP2) + -- Function: void mpz_addmul_ui (mpz_t ROP, mpz_t OP1, unsigned long + int OP2) + Set ROP to ROP + OP1 times OP2. + + -- Function: void mpz_submul (mpz_t ROP, mpz_t OP1, mpz_t OP2) + -- Function: void mpz_submul_ui (mpz_t ROP, mpz_t OP1, unsigned long + int OP2) + Set ROP to ROP - OP1 times OP2. + + -- Function: void mpz_mul_2exp (mpz_t ROP, mpz_t OP1, mp_bitcnt_t OP2) + Set ROP to OP1 times 2 raised to OP2. This operation can also be + defined as a left shift by OP2 bits. + + -- Function: void mpz_neg (mpz_t ROP, mpz_t OP) + Set ROP to -OP. + + -- Function: void mpz_abs (mpz_t ROP, mpz_t OP) + Set ROP to the absolute value of OP. + + +File: gmp.info, Node: Integer Division, Next: Integer Exponentiation, Prev: Integer Arithmetic, Up: Integer Functions + +5.6 Division Functions +====================== + +Division is undefined if the divisor is zero. Passing a zero divisor +to the division or modulo functions (including the modular powering +functions `mpz_powm' and `mpz_powm_ui'), will cause an intentional +division by zero. This lets a program handle arithmetic exceptions in +these functions the same way as for normal C `int' arithmetic. + + -- Function: void mpz_cdiv_q (mpz_t Q, mpz_t N, mpz_t D) + -- Function: void mpz_cdiv_r (mpz_t R, mpz_t N, mpz_t D) + -- Function: void mpz_cdiv_qr (mpz_t Q, mpz_t R, mpz_t N, mpz_t D) + -- Function: unsigned long int mpz_cdiv_q_ui (mpz_t Q, mpz_t N, + unsigned long int D) + -- Function: unsigned long int mpz_cdiv_r_ui (mpz_t R, mpz_t N, + unsigned long int D) + -- Function: unsigned long int mpz_cdiv_qr_ui (mpz_t Q, mpz_t R, + mpz_t N, unsigned long int D) + -- Function: unsigned long int mpz_cdiv_ui (mpz_t N, + unsigned long int D) + -- Function: void mpz_cdiv_q_2exp (mpz_t Q, mpz_t N, mp_bitcnt_t B) + -- Function: void mpz_cdiv_r_2exp (mpz_t R, mpz_t N, mp_bitcnt_t B) + + -- Function: void mpz_fdiv_q (mpz_t Q, mpz_t N, mpz_t D) + -- Function: void mpz_fdiv_r (mpz_t R, mpz_t N, mpz_t D) + -- Function: void mpz_fdiv_qr (mpz_t Q, mpz_t R, mpz_t N, mpz_t D) + -- Function: unsigned long int mpz_fdiv_q_ui (mpz_t Q, mpz_t N, + unsigned long int D) + -- Function: unsigned long int mpz_fdiv_r_ui (mpz_t R, mpz_t N, + unsigned long int D) + -- Function: unsigned long int mpz_fdiv_qr_ui (mpz_t Q, mpz_t R, + mpz_t N, unsigned long int D) + -- Function: unsigned long int mpz_fdiv_ui (mpz_t N, + unsigned long int D) + -- Function: void mpz_fdiv_q_2exp (mpz_t Q, mpz_t N, mp_bitcnt_t B) + -- Function: void mpz_fdiv_r_2exp (mpz_t R, mpz_t N, mp_bitcnt_t B) + + -- Function: void mpz_tdiv_q (mpz_t Q, mpz_t N, mpz_t D) + -- Function: void mpz_tdiv_r (mpz_t R, mpz_t N, mpz_t D) + -- Function: void mpz_tdiv_qr (mpz_t Q, mpz_t R, mpz_t N, mpz_t D) + -- Function: unsigned long int mpz_tdiv_q_ui (mpz_t Q, mpz_t N, + unsigned long int D) + -- Function: unsigned long int mpz_tdiv_r_ui (mpz_t R, mpz_t N, + unsigned long int D) + -- Function: unsigned long int mpz_tdiv_qr_ui (mpz_t Q, mpz_t R, + mpz_t N, unsigned long int D) + -- Function: unsigned long int mpz_tdiv_ui (mpz_t N, + unsigned long int D) + -- Function: void mpz_tdiv_q_2exp (mpz_t Q, mpz_t N, mp_bitcnt_t B) + -- Function: void mpz_tdiv_r_2exp (mpz_t R, mpz_t N, mp_bitcnt_t B) + + Divide N by D, forming a quotient Q and/or remainder R. For the + `2exp' functions, D=2^B. The rounding is in three styles, each + suiting different applications. + + * `cdiv' rounds Q up towards +infinity, and R will have the + opposite sign to D. The `c' stands for "ceil". + + * `fdiv' rounds Q down towards -infinity, and R will have the + same sign as D. The `f' stands for "floor". + + * `tdiv' rounds Q towards zero, and R will have the same sign + as N. The `t' stands for "truncate". + + In all cases Q and R will satisfy N=Q*D+R, and R will satisfy + 0<=abs(R) 0 and that MOD is odd. + + This function is designed to take the same time and have the same + cache access patterns for any two same-size arguments, assuming + that function arguments are placed at the same position and that + the machine state is identical upon function entry. This function + is intended for cryptographic purposes, where resilience to + side-channel attacks is desired. + + -- Function: void mpz_pow_ui (mpz_t ROP, mpz_t BASE, unsigned long int + EXP) + -- Function: void mpz_ui_pow_ui (mpz_t ROP, unsigned long int BASE, + unsigned long int EXP) + Set ROP to BASE raised to EXP. The case 0^0 yields 1. + + +File: gmp.info, Node: Integer Roots, Next: Number Theoretic Functions, Prev: Integer Exponentiation, Up: Integer Functions + +5.8 Root Extraction Functions +============================= + + -- Function: int mpz_root (mpz_t ROP, mpz_t OP, unsigned long int N) + Set ROP to the truncated integer part of the Nth root of OP. + Return non-zero if the computation was exact, i.e., if OP is ROP + to the Nth power. + + -- Function: void mpz_rootrem (mpz_t ROOT, mpz_t REM, mpz_t U, + unsigned long int N) + Set ROOT to the truncated integer part of the Nth root of U. Set + REM to the remainder, U-ROOT**N. + + -- Function: void mpz_sqrt (mpz_t ROP, mpz_t OP) + Set ROP to the truncated integer part of the square root of OP. + + -- Function: void mpz_sqrtrem (mpz_t ROP1, mpz_t ROP2, mpz_t OP) + Set ROP1 to the truncated integer part of the square root of OP, + like `mpz_sqrt'. Set ROP2 to the remainder OP-ROP1*ROP1, which + will be zero if OP is a perfect square. + + If ROP1 and ROP2 are the same variable, the results are undefined. + + -- Function: int mpz_perfect_power_p (mpz_t OP) + Return non-zero if OP is a perfect power, i.e., if there exist + integers A and B, with B>1, such that OP equals A raised to the + power B. + + Under this definition both 0 and 1 are considered to be perfect + powers. Negative values of OP are accepted, but of course can + only be odd perfect powers. + + -- Function: int mpz_perfect_square_p (mpz_t OP) + Return non-zero if OP is a perfect square, i.e., if the square + root of OP is an integer. Under this definition both 0 and 1 are + considered to be perfect squares. + + +File: gmp.info, Node: Number Theoretic Functions, Next: Integer Comparisons, Prev: Integer Roots, Up: Integer Functions + +5.9 Number Theoretic Functions +============================== + + -- Function: int mpz_probab_prime_p (mpz_t N, int REPS) + Determine whether N is prime. Return 2 if N is definitely prime, + return 1 if N is probably prime (without being certain), or return + 0 if N is definitely composite. + + This function does some trial divisions, then some Miller-Rabin + probabilistic primality tests. REPS controls how many such tests + are done, 5 to 10 is a reasonable number, more will reduce the + chances of a composite being returned as "probably prime". + + Miller-Rabin and similar tests can be more properly called + compositeness tests. Numbers which fail are known to be composite + but those which pass might be prime or might be composite. Only a + few composites pass, hence those which pass are considered + probably prime. + + -- Function: void mpz_nextprime (mpz_t ROP, mpz_t OP) + Set ROP to the next prime greater than OP. + + This function uses a probabilistic algorithm to identify primes. + For practical purposes it's adequate, the chance of a composite + passing will be extremely small. + + -- Function: void mpz_gcd (mpz_t ROP, mpz_t OP1, mpz_t OP2) + Set ROP to the greatest common divisor of OP1 and OP2. The result + is always positive even if one or both input operands are negative. + + -- Function: unsigned long int mpz_gcd_ui (mpz_t ROP, mpz_t OP1, + unsigned long int OP2) + Compute the greatest common divisor of OP1 and OP2. If ROP is not + `NULL', store the result there. + + If the result is small enough to fit in an `unsigned long int', it + is returned. If the result does not fit, 0 is returned, and the + result is equal to the argument OP1. Note that the result will + always fit if OP2 is non-zero. + + -- Function: void mpz_gcdext (mpz_t G, mpz_t S, mpz_t T, mpz_t A, + mpz_t B) + Set G to the greatest common divisor of A and B, and in addition + set S and T to coefficients satisfying A*S + B*T = G. The value + in G is always positive, even if one or both of A and B are + negative. The values in S and T are chosen such that abs(S) <= + abs(B) and abs(T) <= abs(A). + + If T is `NULL' then that value is not computed. + + -- Function: void mpz_lcm (mpz_t ROP, mpz_t OP1, mpz_t OP2) + -- Function: void mpz_lcm_ui (mpz_t ROP, mpz_t OP1, unsigned long OP2) + Set ROP to the least common multiple of OP1 and OP2. ROP is + always positive, irrespective of the signs of OP1 and OP2. ROP + will be zero if either OP1 or OP2 is zero. + + -- Function: int mpz_invert (mpz_t ROP, mpz_t OP1, mpz_t OP2) + Compute the inverse of OP1 modulo OP2 and put the result in ROP. + If the inverse exists, the return value is non-zero and ROP will + satisfy 0 <= ROP < OP2. If an inverse doesn't exist the return + value is zero and ROP is undefined. + + -- Function: int mpz_jacobi (mpz_t A, mpz_t B) + Calculate the Jacobi symbol (A/B). This is defined only for B odd. + + -- Function: int mpz_legendre (mpz_t A, mpz_t P) + Calculate the Legendre symbol (A/P). This is defined only for P + an odd positive prime, and for such P it's identical to the Jacobi + symbol. + + -- Function: int mpz_kronecker (mpz_t A, mpz_t B) + -- Function: int mpz_kronecker_si (mpz_t A, long B) + -- Function: int mpz_kronecker_ui (mpz_t A, unsigned long B) + -- Function: int mpz_si_kronecker (long A, mpz_t B) + -- Function: int mpz_ui_kronecker (unsigned long A, mpz_t B) + Calculate the Jacobi symbol (A/B) with the Kronecker extension + (a/2)=(2/a) when a odd, or (a/2)=0 when a even. + + When B is odd the Jacobi symbol and Kronecker symbol are + identical, so `mpz_kronecker_ui' etc can be used for mixed + precision Jacobi symbols too. + + For more information see Henri Cohen section 1.4.2 (*note + References::), or any number theory textbook. See also the + example program `demos/qcn.c' which uses `mpz_kronecker_ui'. + + -- Function: mp_bitcnt_t mpz_remove (mpz_t ROP, mpz_t OP, mpz_t F) + Remove all occurrences of the factor F from OP and store the + result in ROP. The return value is how many such occurrences were + removed. + + -- Function: void mpz_fac_ui (mpz_t ROP, unsigned long int OP) + Set ROP to OP!, the factorial of OP. + + -- Function: void mpz_bin_ui (mpz_t ROP, mpz_t N, unsigned long int K) + -- Function: void mpz_bin_uiui (mpz_t ROP, unsigned long int N, + unsigned long int K) + Compute the binomial coefficient N over K and store the result in + ROP. Negative values of N are supported by `mpz_bin_ui', using + the identity bin(-n,k) = (-1)^k * bin(n+k-1,k), see Knuth volume 1 + section 1.2.6 part G. + + -- Function: void mpz_fib_ui (mpz_t FN, unsigned long int N) + -- Function: void mpz_fib2_ui (mpz_t FN, mpz_t FNSUB1, unsigned long + int N) + `mpz_fib_ui' sets FN to to F[n], the N'th Fibonacci number. + `mpz_fib2_ui' sets FN to F[n], and FNSUB1 to F[n-1]. + + These functions are designed for calculating isolated Fibonacci + numbers. When a sequence of values is wanted it's best to start + with `mpz_fib2_ui' and iterate the defining F[n+1]=F[n]+F[n-1] or + similar. + + -- Function: void mpz_lucnum_ui (mpz_t LN, unsigned long int N) + -- Function: void mpz_lucnum2_ui (mpz_t LN, mpz_t LNSUB1, unsigned + long int N) + `mpz_lucnum_ui' sets LN to to L[n], the N'th Lucas number. + `mpz_lucnum2_ui' sets LN to L[n], and LNSUB1 to L[n-1]. + + These functions are designed for calculating isolated Lucas + numbers. When a sequence of values is wanted it's best to start + with `mpz_lucnum2_ui' and iterate the defining L[n+1]=L[n]+L[n-1] + or similar. + + The Fibonacci numbers and Lucas numbers are related sequences, so + it's never necessary to call both `mpz_fib2_ui' and + `mpz_lucnum2_ui'. The formulas for going from Fibonacci to Lucas + can be found in *Note Lucas Numbers Algorithm::, the reverse is + straightforward too. + + +File: gmp.info, Node: Integer Comparisons, Next: Integer Logic and Bit Fiddling, Prev: Number Theoretic Functions, Up: Integer Functions + +5.10 Comparison Functions +========================= + + -- Function: int mpz_cmp (mpz_t OP1, mpz_t OP2) + -- Function: int mpz_cmp_d (mpz_t OP1, double OP2) + -- Macro: int mpz_cmp_si (mpz_t OP1, signed long int OP2) + -- Macro: int mpz_cmp_ui (mpz_t OP1, unsigned long int OP2) + Compare OP1 and OP2. Return a positive value if OP1 > OP2, zero + if OP1 = OP2, or a negative value if OP1 < OP2. + + `mpz_cmp_ui' and `mpz_cmp_si' are macros and will evaluate their + arguments more than once. `mpz_cmp_d' can be called with an + infinity, but results are undefined for a NaN. + + -- Function: int mpz_cmpabs (mpz_t OP1, mpz_t OP2) + -- Function: int mpz_cmpabs_d (mpz_t OP1, double OP2) + -- Function: int mpz_cmpabs_ui (mpz_t OP1, unsigned long int OP2) + Compare the absolute values of OP1 and OP2. Return a positive + value if abs(OP1) > abs(OP2), zero if abs(OP1) = abs(OP2), or a + negative value if abs(OP1) < abs(OP2). + + `mpz_cmpabs_d' can be called with an infinity, but results are + undefined for a NaN. + + -- Macro: int mpz_sgn (mpz_t OP) + Return +1 if OP > 0, 0 if OP = 0, and -1 if OP < 0. + + This function is actually implemented as a macro. It evaluates + its argument multiple times. + + +File: gmp.info, Node: Integer Logic and Bit Fiddling, Next: I/O of Integers, Prev: Integer Comparisons, Up: Integer Functions + +5.11 Logical and Bit Manipulation Functions +=========================================== + +These functions behave as if twos complement arithmetic were used +(although sign-magnitude is the actual implementation). The least +significant bit is number 0. + + -- Function: void mpz_and (mpz_t ROP, mpz_t OP1, mpz_t OP2) + Set ROP to OP1 bitwise-and OP2. + + -- Function: void mpz_ior (mpz_t ROP, mpz_t OP1, mpz_t OP2) + Set ROP to OP1 bitwise inclusive-or OP2. + + -- Function: void mpz_xor (mpz_t ROP, mpz_t OP1, mpz_t OP2) + Set ROP to OP1 bitwise exclusive-or OP2. + + -- Function: void mpz_com (mpz_t ROP, mpz_t OP) + Set ROP to the one's complement of OP. + + -- Function: mp_bitcnt_t mpz_popcount (mpz_t OP) + If OP>=0, return the population count of OP, which is the number + of 1 bits in the binary representation. If OP<0, the number of 1s + is infinite, and the return value is the largest possible + `mp_bitcnt_t'. + + -- Function: mp_bitcnt_t mpz_hamdist (mpz_t OP1, mpz_t OP2) + If OP1 and OP2 are both >=0 or both <0, return the hamming + distance between the two operands, which is the number of bit + positions where OP1 and OP2 have different bit values. If one + operand is >=0 and the other <0 then the number of bits different + is infinite, and the return value is the largest possible + `mp_bitcnt_t'. + + -- Function: mp_bitcnt_t mpz_scan0 (mpz_t OP, mp_bitcnt_t STARTING_BIT) + -- Function: mp_bitcnt_t mpz_scan1 (mpz_t OP, mp_bitcnt_t STARTING_BIT) + Scan OP, starting from bit STARTING_BIT, towards more significant + bits, until the first 0 or 1 bit (respectively) is found. Return + the index of the found bit. + + If the bit at STARTING_BIT is already what's sought, then + STARTING_BIT is returned. + + If there's no bit found, then the largest possible `mp_bitcnt_t' is + returned. This will happen in `mpz_scan0' past the end of a + negative number, or `mpz_scan1' past the end of a nonnegative + number. + + -- Function: void mpz_setbit (mpz_t ROP, mp_bitcnt_t BIT_INDEX) + Set bit BIT_INDEX in ROP. + + -- Function: void mpz_clrbit (mpz_t ROP, mp_bitcnt_t BIT_INDEX) + Clear bit BIT_INDEX in ROP. + + -- Function: void mpz_combit (mpz_t ROP, mp_bitcnt_t BIT_INDEX) + Complement bit BIT_INDEX in ROP. + + -- Function: int mpz_tstbit (mpz_t OP, mp_bitcnt_t BIT_INDEX) + Test bit BIT_INDEX in OP and return 0 or 1 accordingly. + + +File: gmp.info, Node: I/O of Integers, Next: Integer Random Numbers, Prev: Integer Logic and Bit Fiddling, Up: Integer Functions + +5.12 Input and Output Functions +=============================== + +Functions that perform input from a stdio stream, and functions that +output to a stdio stream. Passing a `NULL' pointer for a STREAM +argument to any of these functions will make them read from `stdin' and +write to `stdout', respectively. + + When using any of these functions, it is a good idea to include +`stdio.h' before `gmp.h', since that will allow `gmp.h' to define +prototypes for these functions. + + -- Function: size_t mpz_out_str (FILE *STREAM, int BASE, mpz_t OP) + Output OP on stdio stream STREAM, as a string of digits in base + BASE. The base argument may vary from 2 to 62 or from -2 to -36. + + For BASE in the range 2..36, digits and lower-case letters are + used; for -2..-36, digits and upper-case letters are used; for + 37..62, digits, upper-case letters, and lower-case letters (in + that significance order) are used. + + Return the number of bytes written, or if an error occurred, + return 0. + + -- Function: size_t mpz_inp_str (mpz_t ROP, FILE *STREAM, int BASE) + Input a possibly white-space preceded string in base BASE from + stdio stream STREAM, and put the read integer in ROP. + + The BASE may vary from 2 to 62, or if BASE is 0, then the leading + characters are used: `0x' and `0X' for hexadecimal, `0b' and `0B' + for binary, `0' for octal, or decimal otherwise. + + For bases up to 36, case is ignored; upper-case and lower-case + letters have the same value. For bases 37 to 62, upper-case + letter represent the usual 10..35 while lower-case letter + represent 36..61. + + Return the number of bytes read, or if an error occurred, return 0. + + -- Function: size_t mpz_out_raw (FILE *STREAM, mpz_t OP) + Output OP on stdio stream STREAM, in raw binary format. The + integer is written in a portable format, with 4 bytes of size + information, and that many bytes of limbs. Both the size and the + limbs are written in decreasing significance order (i.e., in + big-endian). + + The output can be read with `mpz_inp_raw'. + + Return the number of bytes written, or if an error occurred, + return 0. + + The output of this can not be read by `mpz_inp_raw' from GMP 1, + because of changes necessary for compatibility between 32-bit and + 64-bit machines. + + -- Function: size_t mpz_inp_raw (mpz_t ROP, FILE *STREAM) + Input from stdio stream STREAM in the format written by + `mpz_out_raw', and put the result in ROP. Return the number of + bytes read, or if an error occurred, return 0. + + This routine can read the output from `mpz_out_raw' also from GMP + 1, in spite of changes necessary for compatibility between 32-bit + and 64-bit machines. + + +File: gmp.info, Node: Integer Random Numbers, Next: Integer Import and Export, Prev: I/O of Integers, Up: Integer Functions + +5.13 Random Number Functions +============================ + +The random number functions of GMP come in two groups; older function +that rely on a global state, and newer functions that accept a state +parameter that is read and modified. Please see the *Note Random +Number Functions:: for more information on how to use and not to use +random number functions. + + -- Function: void mpz_urandomb (mpz_t ROP, gmp_randstate_t STATE, + mp_bitcnt_t N) + Generate a uniformly distributed random integer in the range 0 to + 2^N-1, inclusive. + + The variable STATE must be initialized by calling one of the + `gmp_randinit' functions (*Note Random State Initialization::) + before invoking this function. + + -- Function: void mpz_urandomm (mpz_t ROP, gmp_randstate_t STATE, + mpz_t N) + Generate a uniform random integer in the range 0 to N-1, inclusive. + + The variable STATE must be initialized by calling one of the + `gmp_randinit' functions (*Note Random State Initialization::) + before invoking this function. + + -- Function: void mpz_rrandomb (mpz_t ROP, gmp_randstate_t STATE, + mp_bitcnt_t N) + Generate a random integer with long strings of zeros and ones in + the binary representation. Useful for testing functions and + algorithms, since this kind of random numbers have proven to be + more likely to trigger corner-case bugs. The random number will + be in the range 0 to 2^N-1, inclusive. + + The variable STATE must be initialized by calling one of the + `gmp_randinit' functions (*Note Random State Initialization::) + before invoking this function. + + -- Function: void mpz_random (mpz_t ROP, mp_size_t MAX_SIZE) + Generate a random integer of at most MAX_SIZE limbs. The generated + random number doesn't satisfy any particular requirements of + randomness. Negative random numbers are generated when MAX_SIZE + is negative. + + This function is obsolete. Use `mpz_urandomb' or `mpz_urandomm' + instead. + + -- Function: void mpz_random2 (mpz_t ROP, mp_size_t MAX_SIZE) + Generate a random integer of at most MAX_SIZE limbs, with long + strings of zeros and ones in the binary representation. Useful + for testing functions and algorithms, since this kind of random + numbers have proven to be more likely to trigger corner-case bugs. + Negative random numbers are generated when MAX_SIZE is negative. + + This function is obsolete. Use `mpz_rrandomb' instead. + + +File: gmp.info, Node: Integer Import and Export, Next: Miscellaneous Integer Functions, Prev: Integer Random Numbers, Up: Integer Functions + +5.14 Integer Import and Export +============================== + +`mpz_t' variables can be converted to and from arbitrary words of binary +data with the following functions. + + -- Function: void mpz_import (mpz_t ROP, size_t COUNT, int ORDER, + size_t SIZE, int ENDIAN, size_t NAILS, const void *OP) + Set ROP from an array of word data at OP. + + The parameters specify the format of the data. COUNT many words + are read, each SIZE bytes. ORDER can be 1 for most significant + word first or -1 for least significant first. Within each word + ENDIAN can be 1 for most significant byte first, -1 for least + significant first, or 0 for the native endianness of the host CPU. + The most significant NAILS bits of each word are skipped, this + can be 0 to use the full words. + + There is no sign taken from the data, ROP will simply be a positive + integer. An application can handle any sign itself, and apply it + for instance with `mpz_neg'. + + There are no data alignment restrictions on OP, any address is + allowed. + + Here's an example converting an array of `unsigned long' data, most + significant element first, and host byte order within each value. + + unsigned long a[20]; + /* Initialize Z and A */ + mpz_import (z, 20, 1, sizeof(a[0]), 0, 0, a); + + This example assumes the full `sizeof' bytes are used for data in + the given type, which is usually true, and certainly true for + `unsigned long' everywhere we know of. However on Cray vector + systems it may be noted that `short' and `int' are always stored + in 8 bytes (and with `sizeof' indicating that) but use only 32 or + 46 bits. The NAILS feature can account for this, by passing for + instance `8*sizeof(int)-INT_BIT'. + + -- Function: void * mpz_export (void *ROP, size_t *COUNTP, int ORDER, + size_t SIZE, int ENDIAN, size_t NAILS, mpz_t OP) + Fill ROP with word data from OP. + + The parameters specify the format of the data produced. Each word + will be SIZE bytes and ORDER can be 1 for most significant word + first or -1 for least significant first. Within each word ENDIAN + can be 1 for most significant byte first, -1 for least significant + first, or 0 for the native endianness of the host CPU. The most + significant NAILS bits of each word are unused and set to zero, + this can be 0 to produce full words. + + The number of words produced is written to `*COUNTP', or COUNTP + can be `NULL' to discard the count. ROP must have enough space + for the data, or if ROP is `NULL' then a result array of the + necessary size is allocated using the current GMP allocation + function (*note Custom Allocation::). In either case the return + value is the destination used, either ROP or the allocated block. + + If OP is non-zero then the most significant word produced will be + non-zero. If OP is zero then the count returned will be zero and + nothing written to ROP. If ROP is `NULL' in this case, no block + is allocated, just `NULL' is returned. + + The sign of OP is ignored, just the absolute value is exported. An + application can use `mpz_sgn' to get the sign and handle it as + desired. (*note Integer Comparisons::) + + There are no data alignment restrictions on ROP, any address is + allowed. + + When an application is allocating space itself the required size + can be determined with a calculation like the following. Since + `mpz_sizeinbase' always returns at least 1, `count' here will be + at least one, which avoids any portability problems with + `malloc(0)', though if `z' is zero no space at all is actually + needed (or written). + + numb = 8*size - nail; + count = (mpz_sizeinbase (z, 2) + numb-1) / numb; + p = malloc (count * size); + + +File: gmp.info, Node: Miscellaneous Integer Functions, Next: Integer Special Functions, Prev: Integer Import and Export, Up: Integer Functions + +5.15 Miscellaneous Functions +============================ + + -- Function: int mpz_fits_ulong_p (mpz_t OP) + -- Function: int mpz_fits_slong_p (mpz_t OP) + -- Function: int mpz_fits_uint_p (mpz_t OP) + -- Function: int mpz_fits_sint_p (mpz_t OP) + -- Function: int mpz_fits_ushort_p (mpz_t OP) + -- Function: int mpz_fits_sshort_p (mpz_t OP) + Return non-zero iff the value of OP fits in an `unsigned long int', + `signed long int', `unsigned int', `signed int', `unsigned short + int', or `signed short int', respectively. Otherwise, return zero. + + -- Macro: int mpz_odd_p (mpz_t OP) + -- Macro: int mpz_even_p (mpz_t OP) + Determine whether OP is odd or even, respectively. Return + non-zero if yes, zero if no. These macros evaluate their argument + more than once. + + -- Function: size_t mpz_sizeinbase (mpz_t OP, int BASE) + Return the size of OP measured in number of digits in the given + BASE. BASE can vary from 2 to 62. The sign of OP is ignored, + just the absolute value is used. The result will be either exact + or 1 too big. If BASE is a power of 2, the result is always + exact. If OP is zero the return value is always 1. + + This function can be used to determine the space required when + converting OP to a string. The right amount of allocation is + normally two more than the value returned by `mpz_sizeinbase', one + extra for a minus sign and one for the null-terminator. + + It will be noted that `mpz_sizeinbase(OP,2)' can be used to locate + the most significant 1 bit in OP, counting from 1. (Unlike the + bitwise functions which start from 0, *Note Logical and Bit + Manipulation Functions: Integer Logic and Bit Fiddling.) + + +File: gmp.info, Node: Integer Special Functions, Prev: Miscellaneous Integer Functions, Up: Integer Functions + +5.16 Special Functions +====================== + +The functions in this section are for various special purposes. Most +applications will not need them. + + -- Function: void mpz_array_init (mpz_t INTEGER_ARRAY, mp_size_t + ARRAY_SIZE, mp_size_t FIXED_NUM_BITS) + This is a special type of initialization. *Fixed* space of + FIXED_NUM_BITS is allocated to each of the ARRAY_SIZE integers in + INTEGER_ARRAY. There is no way to free the storage allocated by + this function. Don't call `mpz_clear'! + + The INTEGER_ARRAY parameter is the first `mpz_t' in the array. For + example, + + mpz_t arr[20000]; + mpz_array_init (arr[0], 20000, 512); + + This function is only intended for programs that create a large + number of integers and need to reduce memory usage by avoiding the + overheads of allocating and reallocating lots of small blocks. In + normal programs this function is not recommended. + + The space allocated to each integer by this function will not be + automatically increased, unlike the normal `mpz_init', so an + application must ensure it is sufficient for any value stored. + The following space requirements apply to various routines, + + * `mpz_abs', `mpz_neg', `mpz_set', `mpz_set_si' and + `mpz_set_ui' need room for the value they store. + + * `mpz_add', `mpz_add_ui', `mpz_sub' and `mpz_sub_ui' need room + for the larger of the two operands, plus an extra + `mp_bits_per_limb'. + + * `mpz_mul', `mpz_mul_ui' and `mpz_mul_ui' need room for the sum + of the number of bits in their operands, but each rounded up + to a multiple of `mp_bits_per_limb'. + + * `mpz_swap' can be used between two array variables, but not + between an array and a normal variable. + + For other functions, or if in doubt, the suggestion is to + calculate in a regular `mpz_init' variable and copy the result to + an array variable with `mpz_set'. + + -- Function: void * _mpz_realloc (mpz_t INTEGER, mp_size_t NEW_ALLOC) + Change the space for INTEGER to NEW_ALLOC limbs. The value in + INTEGER is preserved if it fits, or is set to 0 if not. The return + value is not useful to applications and should be ignored. + + `mpz_realloc2' is the preferred way to accomplish allocation + changes like this. `mpz_realloc2' and `_mpz_realloc' are the same + except that `_mpz_realloc' takes its size in limbs. + + -- Function: mp_limb_t mpz_getlimbn (mpz_t OP, mp_size_t N) + Return limb number N from OP. The sign of OP is ignored, just the + absolute value is used. The least significant limb is number 0. + + `mpz_size' can be used to find how many limbs make up OP. + `mpz_getlimbn' returns zero if N is outside the range 0 to + `mpz_size(OP)-1'. + + -- Function: size_t mpz_size (mpz_t OP) + Return the size of OP measured in number of limbs. If OP is zero, + the returned value will be zero. + + +File: gmp.info, Node: Rational Number Functions, Next: Floating-point Functions, Prev: Integer Functions, Up: Top + +6 Rational Number Functions +*************************** + +This chapter describes the GMP functions for performing arithmetic on +rational numbers. These functions start with the prefix `mpq_'. + + Rational numbers are stored in objects of type `mpq_t'. + + All rational arithmetic functions assume operands have a canonical +form, and canonicalize their result. The canonical from means that the +denominator and the numerator have no common factors, and that the +denominator is positive. Zero has the unique representation 0/1. + + Pure assignment functions do not canonicalize the assigned variable. +It is the responsibility of the user to canonicalize the assigned +variable before any arithmetic operations are performed on that +variable. + + -- Function: void mpq_canonicalize (mpq_t OP) + Remove any factors that are common to the numerator and + denominator of OP, and make the denominator positive. + +* Menu: + +* Initializing Rationals:: +* Rational Conversions:: +* Rational Arithmetic:: +* Comparing Rationals:: +* Applying Integer Functions:: +* I/O of Rationals:: + + +File: gmp.info, Node: Initializing Rationals, Next: Rational Conversions, Prev: Rational Number Functions, Up: Rational Number Functions + +6.1 Initialization and Assignment Functions +=========================================== + + -- Function: void mpq_init (mpq_t X) + Initialize X and set it to 0/1. Each variable should normally + only be initialized once, or at least cleared out (using the + function `mpq_clear') between each initialization. + + -- Function: void mpq_inits (mpq_t X, ...) + Initialize a NULL-terminated list of `mpq_t' variables, and set + their values to 0/1. + + -- Function: void mpq_clear (mpq_t X) + Free the space occupied by X. Make sure to call this function for + all `mpq_t' variables when you are done with them. + + -- Function: void mpq_clears (mpq_t X, ...) + Free the space occupied by a NULL-terminated list of `mpq_t' + variables. + + -- Function: void mpq_set (mpq_t ROP, mpq_t OP) + -- Function: void mpq_set_z (mpq_t ROP, mpz_t OP) + Assign ROP from OP. + + -- Function: void mpq_set_ui (mpq_t ROP, unsigned long int OP1, + unsigned long int OP2) + -- Function: void mpq_set_si (mpq_t ROP, signed long int OP1, unsigned + long int OP2) + Set the value of ROP to OP1/OP2. Note that if OP1 and OP2 have + common factors, ROP has to be passed to `mpq_canonicalize' before + any operations are performed on ROP. + + -- Function: int mpq_set_str (mpq_t ROP, char *STR, int BASE) + Set ROP from a null-terminated string STR in the given BASE. + + The string can be an integer like "41" or a fraction like + "41/152". The fraction must be in canonical form (*note Rational + Number Functions::), or if not then `mpq_canonicalize' must be + called. + + The numerator and optional denominator are parsed the same as in + `mpz_set_str' (*note Assigning Integers::). White space is + allowed in the string, and is simply ignored. The BASE can vary + from 2 to 62, or if BASE is 0 then the leading characters are + used: `0x' or `0X' for hex, `0b' or `0B' for binary, `0' for + octal, or decimal otherwise. Note that this is done separately + for the numerator and denominator, so for instance `0xEF/100' is + 239/100, whereas `0xEF/0x100' is 239/256. + + The return value is 0 if the entire string is a valid number, or + -1 if not. + + -- Function: void mpq_swap (mpq_t ROP1, mpq_t ROP2) + Swap the values ROP1 and ROP2 efficiently. + + +File: gmp.info, Node: Rational Conversions, Next: Rational Arithmetic, Prev: Initializing Rationals, Up: Rational Number Functions + +6.2 Conversion Functions +======================== + + -- Function: double mpq_get_d (mpq_t OP) + Convert OP to a `double', truncating if necessary (ie. rounding + towards zero). + + If the exponent from the conversion is too big or too small to fit + a `double' then the result is system dependent. For too big an + infinity is returned when available. For too small 0.0 is + normally returned. Hardware overflow, underflow and denorm traps + may or may not occur. + + -- Function: void mpq_set_d (mpq_t ROP, double OP) + -- Function: void mpq_set_f (mpq_t ROP, mpf_t OP) + Set ROP to the value of OP. There is no rounding, this conversion + is exact. + + -- Function: char * mpq_get_str (char *STR, int BASE, mpq_t OP) + Convert OP to a string of digits in base BASE. The base may vary + from 2 to 36. The string will be of the form `num/den', or if the + denominator is 1 then just `num'. + + If STR is `NULL', the result string is allocated using the current + allocation function (*note Custom Allocation::). The block will be + `strlen(str)+1' bytes, that being exactly enough for the string and + null-terminator. + + If STR is not `NULL', it should point to a block of storage large + enough for the result, that being + + mpz_sizeinbase (mpq_numref(OP), BASE) + + mpz_sizeinbase (mpq_denref(OP), BASE) + 3 + + The three extra bytes are for a possible minus sign, possible + slash, and the null-terminator. + + A pointer to the result string is returned, being either the + allocated block, or the given STR. + + +File: gmp.info, Node: Rational Arithmetic, Next: Comparing Rationals, Prev: Rational Conversions, Up: Rational Number Functions + +6.3 Arithmetic Functions +======================== + + -- Function: void mpq_add (mpq_t SUM, mpq_t ADDEND1, mpq_t ADDEND2) + Set SUM to ADDEND1 + ADDEND2. + + -- Function: void mpq_sub (mpq_t DIFFERENCE, mpq_t MINUEND, mpq_t + SUBTRAHEND) + Set DIFFERENCE to MINUEND - SUBTRAHEND. + + -- Function: void mpq_mul (mpq_t PRODUCT, mpq_t MULTIPLIER, mpq_t + MULTIPLICAND) + Set PRODUCT to MULTIPLIER times MULTIPLICAND. + + -- Function: void mpq_mul_2exp (mpq_t ROP, mpq_t OP1, mp_bitcnt_t OP2) + Set ROP to OP1 times 2 raised to OP2. + + -- Function: void mpq_div (mpq_t QUOTIENT, mpq_t DIVIDEND, mpq_t + DIVISOR) + Set QUOTIENT to DIVIDEND/DIVISOR. + + -- Function: void mpq_div_2exp (mpq_t ROP, mpq_t OP1, mp_bitcnt_t OP2) + Set ROP to OP1 divided by 2 raised to OP2. + + -- Function: void mpq_neg (mpq_t NEGATED_OPERAND, mpq_t OPERAND) + Set NEGATED_OPERAND to -OPERAND. + + -- Function: void mpq_abs (mpq_t ROP, mpq_t OP) + Set ROP to the absolute value of OP. + + -- Function: void mpq_inv (mpq_t INVERTED_NUMBER, mpq_t NUMBER) + Set INVERTED_NUMBER to 1/NUMBER. If the new denominator is zero, + this routine will divide by zero. + + +File: gmp.info, Node: Comparing Rationals, Next: Applying Integer Functions, Prev: Rational Arithmetic, Up: Rational Number Functions + +6.4 Comparison Functions +======================== + + -- Function: int mpq_cmp (mpq_t OP1, mpq_t OP2) + Compare OP1 and OP2. Return a positive value if OP1 > OP2, zero + if OP1 = OP2, and a negative value if OP1 < OP2. + + To determine if two rationals are equal, `mpq_equal' is faster than + `mpq_cmp'. + + -- Macro: int mpq_cmp_ui (mpq_t OP1, unsigned long int NUM2, unsigned + long int DEN2) + -- Macro: int mpq_cmp_si (mpq_t OP1, long int NUM2, unsigned long int + DEN2) + Compare OP1 and NUM2/DEN2. Return a positive value if OP1 > + NUM2/DEN2, zero if OP1 = NUM2/DEN2, and a negative value if OP1 < + NUM2/DEN2. + + NUM2 and DEN2 are allowed to have common factors. + + These functions are implemented as a macros and evaluate their + arguments multiple times. + + -- Macro: int mpq_sgn (mpq_t OP) + Return +1 if OP > 0, 0 if OP = 0, and -1 if OP < 0. + + This function is actually implemented as a macro. It evaluates its + arguments multiple times. + + -- Function: int mpq_equal (mpq_t OP1, mpq_t OP2) + Return non-zero if OP1 and OP2 are equal, zero if they are + non-equal. Although `mpq_cmp' can be used for the same purpose, + this function is much faster. + + +File: gmp.info, Node: Applying Integer Functions, Next: I/O of Rationals, Prev: Comparing Rationals, Up: Rational Number Functions + +6.5 Applying Integer Functions to Rationals +=========================================== + +The set of `mpq' functions is quite small. In particular, there are few +functions for either input or output. The following functions give +direct access to the numerator and denominator of an `mpq_t'. + + Note that if an assignment to the numerator and/or denominator could +take an `mpq_t' out of the canonical form described at the start of +this chapter (*note Rational Number Functions::) then +`mpq_canonicalize' must be called before any other `mpq' functions are +applied to that `mpq_t'. + + -- Macro: mpz_t mpq_numref (mpq_t OP) + -- Macro: mpz_t mpq_denref (mpq_t OP) + Return a reference to the numerator and denominator of OP, + respectively. The `mpz' functions can be used on the result of + these macros. + + -- Function: void mpq_get_num (mpz_t NUMERATOR, mpq_t RATIONAL) + -- Function: void mpq_get_den (mpz_t DENOMINATOR, mpq_t RATIONAL) + -- Function: void mpq_set_num (mpq_t RATIONAL, mpz_t NUMERATOR) + -- Function: void mpq_set_den (mpq_t RATIONAL, mpz_t DENOMINATOR) + Get or set the numerator or denominator of a rational. These + functions are equivalent to calling `mpz_set' with an appropriate + `mpq_numref' or `mpq_denref'. Direct use of `mpq_numref' or + `mpq_denref' is recommended instead of these functions. + + +File: gmp.info, Node: I/O of Rationals, Prev: Applying Integer Functions, Up: Rational Number Functions + +6.6 Input and Output Functions +============================== + +When using any of these functions, it's a good idea to include `stdio.h' +before `gmp.h', since that will allow `gmp.h' to define prototypes for +these functions. + + Passing a `NULL' pointer for a STREAM argument to any of these +functions will make them read from `stdin' and write to `stdout', +respectively. + + -- Function: size_t mpq_out_str (FILE *STREAM, int BASE, mpq_t OP) + Output OP on stdio stream STREAM, as a string of digits in base + BASE. The base may vary from 2 to 36. Output is in the form + `num/den' or if the denominator is 1 then just `num'. + + Return the number of bytes written, or if an error occurred, + return 0. + + -- Function: size_t mpq_inp_str (mpq_t ROP, FILE *STREAM, int BASE) + Read a string of digits from STREAM and convert them to a rational + in ROP. Any initial white-space characters are read and + discarded. Return the number of characters read (including white + space), or 0 if a rational could not be read. + + The input can be a fraction like `17/63' or just an integer like + `123'. Reading stops at the first character not in this form, and + white space is not permitted within the string. If the input + might not be in canonical form, then `mpq_canonicalize' must be + called (*note Rational Number Functions::). + + The BASE can be between 2 and 36, or can be 0 in which case the + leading characters of the string determine the base, `0x' or `0X' + for hexadecimal, `0' for octal, or decimal otherwise. The leading + characters are examined separately for the numerator and + denominator of a fraction, so for instance `0x10/11' is 16/11, + whereas `0x10/0x11' is 16/17. + + +File: gmp.info, Node: Floating-point Functions, Next: Low-level Functions, Prev: Rational Number Functions, Up: Top + +7 Floating-point Functions +************************** + +GMP floating point numbers are stored in objects of type `mpf_t' and +functions operating on them have an `mpf_' prefix. + + The mantissa of each float has a user-selectable precision, limited +only by available memory. Each variable has its own precision, and +that can be increased or decreased at any time. + + The exponent of each float is a fixed precision, one machine word on +most systems. In the current implementation the exponent is a count of +limbs, so for example on a 32-bit system this means a range of roughly +2^-68719476768 to 2^68719476736, or on a 64-bit system this will be +greater. Note however `mpf_get_str' can only return an exponent which +fits an `mp_exp_t' and currently `mpf_set_str' doesn't accept exponents +bigger than a `long'. + + Each variable keeps a size for the mantissa data actually in use. +This means that if a float is exactly represented in only a few bits +then only those bits will be used in a calculation, even if the +selected precision is high. + + All calculations are performed to the precision of the destination +variable. Each function is defined to calculate with "infinite +precision" followed by a truncation to the destination precision, but +of course the work done is only what's needed to determine a result +under that definition. + + The precision selected for a variable is a minimum value, GMP may +increase it a little to facilitate efficient calculation. Currently +this means rounding up to a whole limb, and then sometimes having a +further partial limb, depending on the high limb of the mantissa. But +applications shouldn't be concerned by such details. + + The mantissa in stored in binary, as might be imagined from the fact +precisions are expressed in bits. One consequence of this is that +decimal fractions like 0.1 cannot be represented exactly. The same is +true of plain IEEE `double' floats. This makes both highly unsuitable +for calculations involving money or other values that should be exact +decimal fractions. (Suitably scaled integers, or perhaps rationals, +are better choices.) + + `mpf' functions and variables have no special notion of infinity or +not-a-number, and applications must take care not to overflow the +exponent or results will be unpredictable. This might change in a +future release. + + Note that the `mpf' functions are _not_ intended as a smooth +extension to IEEE P754 arithmetic. In particular results obtained on +one computer often differ from the results on a computer with a +different word size. + +* Menu: + +* Initializing Floats:: +* Assigning Floats:: +* Simultaneous Float Init & Assign:: +* Converting Floats:: +* Float Arithmetic:: +* Float Comparison:: +* I/O of Floats:: +* Miscellaneous Float Functions:: + + +File: gmp.info, Node: Initializing Floats, Next: Assigning Floats, Prev: Floating-point Functions, Up: Floating-point Functions + +7.1 Initialization Functions +============================ + + -- Function: void mpf_set_default_prec (mp_bitcnt_t PREC) + Set the default precision to be *at least* PREC bits. All + subsequent calls to `mpf_init' will use this precision, but + previously initialized variables are unaffected. + + -- Function: mp_bitcnt_t mpf_get_default_prec (void) + Return the default precision actually used. + + An `mpf_t' object must be initialized before storing the first value +in it. The functions `mpf_init' and `mpf_init2' are used for that +purpose. + + -- Function: void mpf_init (mpf_t X) + Initialize X to 0. Normally, a variable should be initialized + once only or at least be cleared, using `mpf_clear', between + initializations. The precision of X is undefined unless a default + precision has already been established by a call to + `mpf_set_default_prec'. + + -- Function: void mpf_init2 (mpf_t X, mp_bitcnt_t PREC) + Initialize X to 0 and set its precision to be *at least* PREC + bits. Normally, a variable should be initialized once only or at + least be cleared, using `mpf_clear', between initializations. + + -- Function: void mpf_inits (mpf_t X, ...) + Initialize a NULL-terminated list of `mpf_t' variables, and set + their values to 0. The precision of the initialized variables is + undefined unless a default precision has already been established + by a call to `mpf_set_default_prec'. + + -- Function: void mpf_clear (mpf_t X) + Free the space occupied by X. Make sure to call this function for + all `mpf_t' variables when you are done with them. + + -- Function: void mpf_clears (mpf_t X, ...) + Free the space occupied by a NULL-terminated list of `mpf_t' + variables. + + Here is an example on how to initialize floating-point variables: + { + mpf_t x, y; + mpf_init (x); /* use default precision */ + mpf_init2 (y, 256); /* precision _at least_ 256 bits */ + ... + /* Unless the program is about to exit, do ... */ + mpf_clear (x); + mpf_clear (y); + } + + The following three functions are useful for changing the precision +during a calculation. A typical use would be for adjusting the +precision gradually in iterative algorithms like Newton-Raphson, making +the computation precision closely match the actual accurate part of the +numbers. + + -- Function: mp_bitcnt_t mpf_get_prec (mpf_t OP) + Return the current precision of OP, in bits. + + -- Function: void mpf_set_prec (mpf_t ROP, mp_bitcnt_t PREC) + Set the precision of ROP to be *at least* PREC bits. The value in + ROP will be truncated to the new precision. + + This function requires a call to `realloc', and so should not be + used in a tight loop. + + -- Function: void mpf_set_prec_raw (mpf_t ROP, mp_bitcnt_t PREC) + Set the precision of ROP to be *at least* PREC bits, without + changing the memory allocated. + + PREC must be no more than the allocated precision for ROP, that + being the precision when ROP was initialized, or in the most recent + `mpf_set_prec'. + + The value in ROP is unchanged, and in particular if it had a higher + precision than PREC it will retain that higher precision. New + values written to ROP will use the new PREC. + + Before calling `mpf_clear' or the full `mpf_set_prec', another + `mpf_set_prec_raw' call must be made to restore ROP to its original + allocated precision. Failing to do so will have unpredictable + results. + + `mpf_get_prec' can be used before `mpf_set_prec_raw' to get the + original allocated precision. After `mpf_set_prec_raw' it + reflects the PREC value set. + + `mpf_set_prec_raw' is an efficient way to use an `mpf_t' variable + at different precisions during a calculation, perhaps to gradually + increase precision in an iteration, or just to use various + different precisions for different purposes during a calculation. + + +File: gmp.info, Node: Assigning Floats, Next: Simultaneous Float Init & Assign, Prev: Initializing Floats, Up: Floating-point Functions + +7.2 Assignment Functions +======================== + +These functions assign new values to already initialized floats (*note +Initializing Floats::). + + -- Function: void mpf_set (mpf_t ROP, mpf_t OP) + -- Function: void mpf_set_ui (mpf_t ROP, unsigned long int OP) + -- Function: void mpf_set_si (mpf_t ROP, signed long int OP) + -- Function: void mpf_set_d (mpf_t ROP, double OP) + -- Function: void mpf_set_z (mpf_t ROP, mpz_t OP) + -- Function: void mpf_set_q (mpf_t ROP, mpq_t OP) + Set the value of ROP from OP. + + -- Function: int mpf_set_str (mpf_t ROP, char *STR, int BASE) + Set the value of ROP from the string in STR. The string is of the + form `M@N' or, if the base is 10 or less, alternatively `MeN'. + `M' is the mantissa and `N' is the exponent. The mantissa is + always in the specified base. The exponent is either in the + specified base or, if BASE is negative, in decimal. The decimal + point expected is taken from the current locale, on systems + providing `localeconv'. + + The argument BASE may be in the ranges 2 to 62, or -62 to -2. + Negative values are used to specify that the exponent is in + decimal. + + For bases up to 36, case is ignored; upper-case and lower-case + letters have the same value; for bases 37 to 62, upper-case letter + represent the usual 10..35 while lower-case letter represent + 36..61. + + Unlike the corresponding `mpz' function, the base will not be + determined from the leading characters of the string if BASE is 0. + This is so that numbers like `0.23' are not interpreted as octal. + + White space is allowed in the string, and is simply ignored. + [This is not really true; white-space is ignored in the beginning + of the string and within the mantissa, but not in other places, + such as after a minus sign or in the exponent. We are considering + changing the definition of this function, making it fail when + there is any white-space in the input, since that makes a lot of + sense. Please tell us your opinion about this change. Do you + really want it to accept "3 14" as meaning 314 as it does now?] + + This function returns 0 if the entire string is a valid number in + base BASE. Otherwise it returns -1. + + -- Function: void mpf_swap (mpf_t ROP1, mpf_t ROP2) + Swap ROP1 and ROP2 efficiently. Both the values and the + precisions of the two variables are swapped. + + +File: gmp.info, Node: Simultaneous Float Init & Assign, Next: Converting Floats, Prev: Assigning Floats, Up: Floating-point Functions + +7.3 Combined Initialization and Assignment Functions +==================================================== + +For convenience, GMP provides a parallel series of initialize-and-set +functions which initialize the output and then store the value there. +These functions' names have the form `mpf_init_set...' + + Once the float has been initialized by any of the `mpf_init_set...' +functions, it can be used as the source or destination operand for the +ordinary float functions. Don't use an initialize-and-set function on +a variable already initialized! + + -- Function: void mpf_init_set (mpf_t ROP, mpf_t OP) + -- Function: void mpf_init_set_ui (mpf_t ROP, unsigned long int OP) + -- Function: void mpf_init_set_si (mpf_t ROP, signed long int OP) + -- Function: void mpf_init_set_d (mpf_t ROP, double OP) + Initialize ROP and set its value from OP. + + The precision of ROP will be taken from the active default + precision, as set by `mpf_set_default_prec'. + + -- Function: int mpf_init_set_str (mpf_t ROP, char *STR, int BASE) + Initialize ROP and set its value from the string in STR. See + `mpf_set_str' above for details on the assignment operation. + + Note that ROP is initialized even if an error occurs. (I.e., you + have to call `mpf_clear' for it.) + + The precision of ROP will be taken from the active default + precision, as set by `mpf_set_default_prec'. + + +File: gmp.info, Node: Converting Floats, Next: Float Arithmetic, Prev: Simultaneous Float Init & Assign, Up: Floating-point Functions + +7.4 Conversion Functions +======================== + + -- Function: double mpf_get_d (mpf_t OP) + Convert OP to a `double', truncating if necessary (ie. rounding + towards zero). + + If the exponent in OP is too big or too small to fit a `double' + then the result is system dependent. For too big an infinity is + returned when available. For too small 0.0 is normally returned. + Hardware overflow, underflow and denorm traps may or may not occur. + + -- Function: double mpf_get_d_2exp (signed long int *EXP, mpf_t OP) + Convert OP to a `double', truncating if necessary (ie. rounding + towards zero), and with an exponent returned separately. + + The return value is in the range 0.5<=abs(D)<1 and the exponent is + stored to `*EXP'. D * 2^EXP is the (truncated) OP value. If OP + is zero, the return is 0.0 and 0 is stored to `*EXP'. + + This is similar to the standard C `frexp' function (*note + Normalization Functions: (libc)Normalization Functions.). + + -- Function: long mpf_get_si (mpf_t OP) + -- Function: unsigned long mpf_get_ui (mpf_t OP) + Convert OP to a `long' or `unsigned long', truncating any fraction + part. If OP is too big for the return type, the result is + undefined. + + See also `mpf_fits_slong_p' and `mpf_fits_ulong_p' (*note + Miscellaneous Float Functions::). + + -- Function: char * mpf_get_str (char *STR, mp_exp_t *EXPPTR, int + BASE, size_t N_DIGITS, mpf_t OP) + Convert OP to a string of digits in base BASE. The base argument + may vary from 2 to 62 or from -2 to -36. Up to N_DIGITS digits + will be generated. Trailing zeros are not returned. No more + digits than can be accurately represented by OP are ever + generated. If N_DIGITS is 0 then that accurate maximum number of + digits are generated. + + For BASE in the range 2..36, digits and lower-case letters are + used; for -2..-36, digits and upper-case letters are used; for + 37..62, digits, upper-case letters, and lower-case letters (in + that significance order) are used. + + If STR is `NULL', the result string is allocated using the current + allocation function (*note Custom Allocation::). The block will be + `strlen(str)+1' bytes, that being exactly enough for the string and + null-terminator. + + If STR is not `NULL', it should point to a block of N_DIGITS + 2 + bytes, that being enough for the mantissa, a possible minus sign, + and a null-terminator. When N_DIGITS is 0 to get all significant + digits, an application won't be able to know the space required, + and STR should be `NULL' in that case. + + The generated string is a fraction, with an implicit radix point + immediately to the left of the first digit. The applicable + exponent is written through the EXPPTR pointer. For example, the + number 3.1416 would be returned as string "31416" and exponent 1. + + When OP is zero, an empty string is produced and the exponent + returned is 0. + + A pointer to the result string is returned, being either the + allocated block or the given STR. + + +File: gmp.info, Node: Float Arithmetic, Next: Float Comparison, Prev: Converting Floats, Up: Floating-point Functions + +7.5 Arithmetic Functions +======================== + + -- Function: void mpf_add (mpf_t ROP, mpf_t OP1, mpf_t OP2) + -- Function: void mpf_add_ui (mpf_t ROP, mpf_t OP1, unsigned long int + OP2) + Set ROP to OP1 + OP2. + + -- Function: void mpf_sub (mpf_t ROP, mpf_t OP1, mpf_t OP2) + -- Function: void mpf_ui_sub (mpf_t ROP, unsigned long int OP1, mpf_t + OP2) + -- Function: void mpf_sub_ui (mpf_t ROP, mpf_t OP1, unsigned long int + OP2) + Set ROP to OP1 - OP2. + + -- Function: void mpf_mul (mpf_t ROP, mpf_t OP1, mpf_t OP2) + -- Function: void mpf_mul_ui (mpf_t ROP, mpf_t OP1, unsigned long int + OP2) + Set ROP to OP1 times OP2. + + Division is undefined if the divisor is zero, and passing a zero +divisor to the divide functions will make these functions intentionally +divide by zero. This lets the user handle arithmetic exceptions in +these functions in the same manner as other arithmetic exceptions. + + -- Function: void mpf_div (mpf_t ROP, mpf_t OP1, mpf_t OP2) + -- Function: void mpf_ui_div (mpf_t ROP, unsigned long int OP1, mpf_t + OP2) + -- Function: void mpf_div_ui (mpf_t ROP, mpf_t OP1, unsigned long int + OP2) + Set ROP to OP1/OP2. + + -- Function: void mpf_sqrt (mpf_t ROP, mpf_t OP) + -- Function: void mpf_sqrt_ui (mpf_t ROP, unsigned long int OP) + Set ROP to the square root of OP. + + -- Function: void mpf_pow_ui (mpf_t ROP, mpf_t OP1, unsigned long int + OP2) + Set ROP to OP1 raised to the power OP2. + + -- Function: void mpf_neg (mpf_t ROP, mpf_t OP) + Set ROP to -OP. + + -- Function: void mpf_abs (mpf_t ROP, mpf_t OP) + Set ROP to the absolute value of OP. + + -- Function: void mpf_mul_2exp (mpf_t ROP, mpf_t OP1, mp_bitcnt_t OP2) + Set ROP to OP1 times 2 raised to OP2. + + -- Function: void mpf_div_2exp (mpf_t ROP, mpf_t OP1, mp_bitcnt_t OP2) + Set ROP to OP1 divided by 2 raised to OP2. + + +File: gmp.info, Node: Float Comparison, Next: I/O of Floats, Prev: Float Arithmetic, Up: Floating-point Functions + +7.6 Comparison Functions +======================== + + -- Function: int mpf_cmp (mpf_t OP1, mpf_t OP2) + -- Function: int mpf_cmp_d (mpf_t OP1, double OP2) + -- Function: int mpf_cmp_ui (mpf_t OP1, unsigned long int OP2) + -- Function: int mpf_cmp_si (mpf_t OP1, signed long int OP2) + Compare OP1 and OP2. Return a positive value if OP1 > OP2, zero + if OP1 = OP2, and a negative value if OP1 < OP2. + + `mpf_cmp_d' can be called with an infinity, but results are + undefined for a NaN. + + -- Function: int mpf_eq (mpf_t OP1, mpf_t OP2, mp_bitcnt_t op3) + Return non-zero if the first OP3 bits of OP1 and OP2 are equal, + zero otherwise. I.e., test if OP1 and OP2 are approximately equal. + + Caution 1: All version of GMP up to version 4.2.4 compared just + whole limbs, meaning sometimes more than OP3 bits, sometimes fewer. + + Caution 2: This function will consider XXX11...111 and XX100...000 + different, even if ... is replaced by a semi-infinite number of + bits. Such numbers are really just one ulp off, and should be + considered equal. + + -- Function: void mpf_reldiff (mpf_t ROP, mpf_t OP1, mpf_t OP2) + Compute the relative difference between OP1 and OP2 and store the + result in ROP. This is abs(OP1-OP2)/OP1. + + -- Macro: int mpf_sgn (mpf_t OP) + Return +1 if OP > 0, 0 if OP = 0, and -1 if OP < 0. + + This function is actually implemented as a macro. It evaluates + its arguments multiple times. + + +File: gmp.info, Node: I/O of Floats, Next: Miscellaneous Float Functions, Prev: Float Comparison, Up: Floating-point Functions + +7.7 Input and Output Functions +============================== + +Functions that perform input from a stdio stream, and functions that +output to a stdio stream. Passing a `NULL' pointer for a STREAM +argument to any of these functions will make them read from `stdin' and +write to `stdout', respectively. + + When using any of these functions, it is a good idea to include +`stdio.h' before `gmp.h', since that will allow `gmp.h' to define +prototypes for these functions. + + -- Function: size_t mpf_out_str (FILE *STREAM, int BASE, size_t + N_DIGITS, mpf_t OP) + Print OP to STREAM, as a string of digits. Return the number of + bytes written, or if an error occurred, return 0. + + The mantissa is prefixed with an `0.' and is in the given BASE, + which may vary from 2 to 62 or from -2 to -36. An exponent is + then printed, separated by an `e', or if the base is greater than + 10 then by an `@'. The exponent is always in decimal. The + decimal point follows the current locale, on systems providing + `localeconv'. + + For BASE in the range 2..36, digits and lower-case letters are + used; for -2..-36, digits and upper-case letters are used; for + 37..62, digits, upper-case letters, and lower-case letters (in + that significance order) are used. + + Up to N_DIGITS will be printed from the mantissa, except that no + more digits than are accurately representable by OP will be + printed. N_DIGITS can be 0 to select that accurate maximum. + + -- Function: size_t mpf_inp_str (mpf_t ROP, FILE *STREAM, int BASE) + Read a string in base BASE from STREAM, and put the read float in + ROP. The string is of the form `M@N' or, if the base is 10 or + less, alternatively `MeN'. `M' is the mantissa and `N' is the + exponent. The mantissa is always in the specified base. The + exponent is either in the specified base or, if BASE is negative, + in decimal. The decimal point expected is taken from the current + locale, on systems providing `localeconv'. + + The argument BASE may be in the ranges 2 to 36, or -36 to -2. + Negative values are used to specify that the exponent is in + decimal. + + Unlike the corresponding `mpz' function, the base will not be + determined from the leading characters of the string if BASE is 0. + This is so that numbers like `0.23' are not interpreted as octal. + + Return the number of bytes read, or if an error occurred, return 0. + + +File: gmp.info, Node: Miscellaneous Float Functions, Prev: I/O of Floats, Up: Floating-point Functions + +7.8 Miscellaneous Functions +=========================== + + -- Function: void mpf_ceil (mpf_t ROP, mpf_t OP) + -- Function: void mpf_floor (mpf_t ROP, mpf_t OP) + -- Function: void mpf_trunc (mpf_t ROP, mpf_t OP) + Set ROP to OP rounded to an integer. `mpf_ceil' rounds to the + next higher integer, `mpf_floor' to the next lower, and `mpf_trunc' + to the integer towards zero. + + -- Function: int mpf_integer_p (mpf_t OP) + Return non-zero if OP is an integer. + + -- Function: int mpf_fits_ulong_p (mpf_t OP) + -- Function: int mpf_fits_slong_p (mpf_t OP) + -- Function: int mpf_fits_uint_p (mpf_t OP) + -- Function: int mpf_fits_sint_p (mpf_t OP) + -- Function: int mpf_fits_ushort_p (mpf_t OP) + -- Function: int mpf_fits_sshort_p (mpf_t OP) + Return non-zero if OP would fit in the respective C data type, when + truncated to an integer. + + -- Function: void mpf_urandomb (mpf_t ROP, gmp_randstate_t STATE, + mp_bitcnt_t NBITS) + Generate a uniformly distributed random float in ROP, such that 0 + <= ROP < 1, with NBITS significant bits in the mantissa. + + The variable STATE must be initialized by calling one of the + `gmp_randinit' functions (*Note Random State Initialization::) + before invoking this function. + + -- Function: void mpf_random2 (mpf_t ROP, mp_size_t MAX_SIZE, mp_exp_t + EXP) + Generate a random float of at most MAX_SIZE limbs, with long + strings of zeros and ones in the binary representation. The + exponent of the number is in the interval -EXP to EXP (in limbs). + This function is useful for testing functions and algorithms, + since these kind of random numbers have proven to be more likely + to trigger corner-case bugs. Negative random numbers are + generated when MAX_SIZE is negative. + + +File: gmp.info, Node: Low-level Functions, Next: Random Number Functions, Prev: Floating-point Functions, Up: Top + +8 Low-level Functions +********************* + +This chapter describes low-level GMP functions, used to implement the +high-level GMP functions, but also intended for time-critical user code. + + These functions start with the prefix `mpn_'. + + The `mpn' functions are designed to be as fast as possible, *not* to +provide a coherent calling interface. The different functions have +somewhat similar interfaces, but there are variations that make them +hard to use. These functions do as little as possible apart from the +real multiple precision computation, so that no time is spent on things +that not all callers need. + + A source operand is specified by a pointer to the least significant +limb and a limb count. A destination operand is specified by just a +pointer. It is the responsibility of the caller to ensure that the +destination has enough space for storing the result. + + With this way of specifying operands, it is possible to perform +computations on subranges of an argument, and store the result into a +subrange of a destination. + + A common requirement for all functions is that each source area +needs at least one limb. No size argument may be zero. Unless +otherwise stated, in-place operations are allowed where source and +destination are the same, but not where they only partly overlap. + + The `mpn' functions are the base for the implementation of the +`mpz_', `mpf_', and `mpq_' functions. + + This example adds the number beginning at S1P and the number +beginning at S2P and writes the sum at DESTP. All areas have N limbs. + + cy = mpn_add_n (destp, s1p, s2p, n) + + It should be noted that the `mpn' functions make no attempt to +identify high or low zero limbs on their operands, or other special +forms. On random data such cases will be unlikely and it'd be wasteful +for every function to check every time. An application knowing +something about its data can take steps to trim or perhaps split its +calculations. + + +In the notation used below, a source operand is identified by the +pointer to the least significant limb, and the limb count in braces. +For example, {S1P, S1N}. + + -- Function: mp_limb_t mpn_add_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Add {S1P, N} and {S2P, N}, and write the N least significant limbs + of the result to RP. Return carry, either 0 or 1. + + This is the lowest-level function for addition. It is the + preferred function for addition, since it is written in assembly + for most CPUs. For addition of a variable to itself (i.e., S1P + equals S2P) use `mpn_lshift' with a count of 1 for optimal speed. + + -- Function: mp_limb_t mpn_add_1 (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t N, mp_limb_t S2LIMB) + Add {S1P, N} and S2LIMB, and write the N least significant limbs + of the result to RP. Return carry, either 0 or 1. + + -- Function: mp_limb_t mpn_add (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t S1N, const mp_limb_t *S2P, mp_size_t S2N) + Add {S1P, S1N} and {S2P, S2N}, and write the S1N least significant + limbs of the result to RP. Return carry, either 0 or 1. + + This function requires that S1N is greater than or equal to S2N. + + -- Function: mp_limb_t mpn_sub_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Subtract {S2P, N} from {S1P, N}, and write the N least significant + limbs of the result to RP. Return borrow, either 0 or 1. + + This is the lowest-level function for subtraction. It is the + preferred function for subtraction, since it is written in + assembly for most CPUs. + + -- Function: mp_limb_t mpn_sub_1 (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t N, mp_limb_t S2LIMB) + Subtract S2LIMB from {S1P, N}, and write the N least significant + limbs of the result to RP. Return borrow, either 0 or 1. + + -- Function: mp_limb_t mpn_sub (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t S1N, const mp_limb_t *S2P, mp_size_t S2N) + Subtract {S2P, S2N} from {S1P, S1N}, and write the S1N least + significant limbs of the result to RP. Return borrow, either 0 or + 1. + + This function requires that S1N is greater than or equal to S2N. + + -- Function: void mpn_neg (mp_limb_t *RP, const mp_limb_t *SP, + mp_size_t N) + Perform the negation of {SP, N}, and write the result to {RP, N}. + Return carry-out. + + -- Function: void mpn_mul_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Multiply {S1P, N} and {S2P, N}, and write the 2*N-limb result to + RP. + + The destination has to have space for 2*N limbs, even if the + product's most significant limb is zero. No overlap is permitted + between the destination and either source. + + If the two input operands are the same, use `mpn_sqr'. + + -- Function: mp_limb_t mpn_mul (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t S1N, const mp_limb_t *S2P, mp_size_t S2N) + Multiply {S1P, S1N} and {S2P, S2N}, and write the (S1N+S2N)-limb + result to RP. Return the most significant limb of the result. + + The destination has to have space for S1N + S2N limbs, even if the + product's most significant limb is zero. No overlap is permitted + between the destination and either source. + + This function requires that S1N is greater than or equal to S2N. + + -- Function: void mpn_sqr (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t N) + Compute the square of {S1P, N} and write the 2*N-limb result to RP. + + The destination has to have space for 2*N limbs, even if the + result's most significant limb is zero. No overlap is permitted + between the destination and the source. + + -- Function: mp_limb_t mpn_mul_1 (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t N, mp_limb_t S2LIMB) + Multiply {S1P, N} by S2LIMB, and write the N least significant + limbs of the product to RP. Return the most significant limb of + the product. {S1P, N} and {RP, N} are allowed to overlap provided + RP <= S1P. + + This is a low-level function that is a building block for general + multiplication as well as other operations in GMP. It is written + in assembly for most CPUs. + + Don't call this function if S2LIMB is a power of 2; use + `mpn_lshift' with a count equal to the logarithm of S2LIMB + instead, for optimal speed. + + -- Function: mp_limb_t mpn_addmul_1 (mp_limb_t *RP, const mp_limb_t + *S1P, mp_size_t N, mp_limb_t S2LIMB) + Multiply {S1P, N} and S2LIMB, and add the N least significant + limbs of the product to {RP, N} and write the result to RP. + Return the most significant limb of the product, plus carry-out + from the addition. + + This is a low-level function that is a building block for general + multiplication as well as other operations in GMP. It is written + in assembly for most CPUs. + + -- Function: mp_limb_t mpn_submul_1 (mp_limb_t *RP, const mp_limb_t + *S1P, mp_size_t N, mp_limb_t S2LIMB) + Multiply {S1P, N} and S2LIMB, and subtract the N least significant + limbs of the product from {RP, N} and write the result to RP. + Return the most significant limb of the product, plus borrow-out + from the subtraction. + + This is a low-level function that is a building block for general + multiplication and division as well as other operations in GMP. + It is written in assembly for most CPUs. + + -- Function: void mpn_tdiv_qr (mp_limb_t *QP, mp_limb_t *RP, mp_size_t + QXN, const mp_limb_t *NP, mp_size_t NN, const mp_limb_t *DP, + mp_size_t DN) + Divide {NP, NN} by {DP, DN} and put the quotient at {QP, NN-DN+1} + and the remainder at {RP, DN}. The quotient is rounded towards 0. + + No overlap is permitted between arguments, except that NP might + equal RP. The dividend size NN must be greater than or equal to + divisor size DN. The most significant limb of the divisor must be + non-zero. The QXN operand must be zero. + + -- Function: mp_limb_t mpn_divrem (mp_limb_t *R1P, mp_size_t QXN, + mp_limb_t *RS2P, mp_size_t RS2N, const mp_limb_t *S3P, + mp_size_t S3N) + [This function is obsolete. Please call `mpn_tdiv_qr' instead for + best performance.] + + Divide {RS2P, RS2N} by {S3P, S3N}, and write the quotient at R1P, + with the exception of the most significant limb, which is + returned. The remainder replaces the dividend at RS2P; it will be + S3N limbs long (i.e., as many limbs as the divisor). + + In addition to an integer quotient, QXN fraction limbs are + developed, and stored after the integral limbs. For most usages, + QXN will be zero. + + It is required that RS2N is greater than or equal to S3N. It is + required that the most significant bit of the divisor is set. + + If the quotient is not needed, pass RS2P + S3N as R1P. Aside from + that special case, no overlap between arguments is permitted. + + Return the most significant limb of the quotient, either 0 or 1. + + The area at R1P needs to be RS2N - S3N + QXN limbs large. + + -- Function: mp_limb_t mpn_divrem_1 (mp_limb_t *R1P, mp_size_t QXN, + mp_limb_t *S2P, mp_size_t S2N, mp_limb_t S3LIMB) + -- Macro: mp_limb_t mpn_divmod_1 (mp_limb_t *R1P, mp_limb_t *S2P, + mp_size_t S2N, mp_limb_t S3LIMB) + Divide {S2P, S2N} by S3LIMB, and write the quotient at R1P. + Return the remainder. + + The integer quotient is written to {R1P+QXN, S2N} and in addition + QXN fraction limbs are developed and written to {R1P, QXN}. + Either or both S2N and QXN can be zero. For most usages, QXN will + be zero. + + `mpn_divmod_1' exists for upward source compatibility and is + simply a macro calling `mpn_divrem_1' with a QXN of 0. + + The areas at R1P and S2P have to be identical or completely + separate, not partially overlapping. + + -- Function: mp_limb_t mpn_divmod (mp_limb_t *R1P, mp_limb_t *RS2P, + mp_size_t RS2N, const mp_limb_t *S3P, mp_size_t S3N) + [This function is obsolete. Please call `mpn_tdiv_qr' instead for + best performance.] + + -- Macro: mp_limb_t mpn_divexact_by3 (mp_limb_t *RP, mp_limb_t *SP, + mp_size_t N) + -- Function: mp_limb_t mpn_divexact_by3c (mp_limb_t *RP, mp_limb_t + *SP, mp_size_t N, mp_limb_t CARRY) + Divide {SP, N} by 3, expecting it to divide exactly, and writing + the result to {RP, N}. If 3 divides exactly, the return value is + zero and the result is the quotient. If not, the return value is + non-zero and the result won't be anything useful. + + `mpn_divexact_by3c' takes an initial carry parameter, which can be + the return value from a previous call, so a large calculation can + be done piece by piece from low to high. `mpn_divexact_by3' is + simply a macro calling `mpn_divexact_by3c' with a 0 carry + parameter. + + These routines use a multiply-by-inverse and will be faster than + `mpn_divrem_1' on CPUs with fast multiplication but slow division. + + The source a, result q, size n, initial carry i, and return value + c satisfy c*b^n + a-i = 3*q, where b=2^GMP_NUMB_BITS. The return + c is always 0, 1 or 2, and the initial carry i must also be 0, 1 + or 2 (these are both borrows really). When c=0 clearly q=(a-i)/3. + When c!=0, the remainder (a-i) mod 3 is given by 3-c, because b + == 1 mod 3 (when `mp_bits_per_limb' is even, which is always so + currently). + + -- Function: mp_limb_t mpn_mod_1 (mp_limb_t *S1P, mp_size_t S1N, + mp_limb_t S2LIMB) + Divide {S1P, S1N} by S2LIMB, and return the remainder. S1N can be + zero. + + -- Function: mp_limb_t mpn_lshift (mp_limb_t *RP, const mp_limb_t *SP, + mp_size_t N, unsigned int COUNT) + Shift {SP, N} left by COUNT bits, and write the result to {RP, N}. + The bits shifted out at the left are returned in the least + significant COUNT bits of the return value (the rest of the return + value is zero). + + COUNT must be in the range 1 to mp_bits_per_limb-1. The regions + {SP, N} and {RP, N} may overlap, provided RP >= SP. + + This function is written in assembly for most CPUs. + + -- Function: mp_limb_t mpn_rshift (mp_limb_t *RP, const mp_limb_t *SP, + mp_size_t N, unsigned int COUNT) + Shift {SP, N} right by COUNT bits, and write the result to {RP, + N}. The bits shifted out at the right are returned in the most + significant COUNT bits of the return value (the rest of the return + value is zero). + + COUNT must be in the range 1 to mp_bits_per_limb-1. The regions + {SP, N} and {RP, N} may overlap, provided RP <= SP. + + This function is written in assembly for most CPUs. + + -- Function: int mpn_cmp (const mp_limb_t *S1P, const mp_limb_t *S2P, + mp_size_t N) + Compare {S1P, N} and {S2P, N} and return a positive value if S1 > + S2, 0 if they are equal, or a negative value if S1 < S2. + + -- Function: mp_size_t mpn_gcd (mp_limb_t *RP, mp_limb_t *XP, + mp_size_t XN, mp_limb_t *YP, mp_size_t YN) + Set {RP, RETVAL} to the greatest common divisor of {XP, XN} and + {YP, YN}. The result can be up to YN limbs, the return value is + the actual number produced. Both source operands are destroyed. + + {XP, XN} must have at least as many bits as {YP, YN}. {YP, YN} + must be odd. Both operands must have non-zero most significant + limbs. No overlap is permitted between {XP, XN} and {YP, YN}. + + -- Function: mp_limb_t mpn_gcd_1 (const mp_limb_t *XP, mp_size_t XN, + mp_limb_t YLIMB) + Return the greatest common divisor of {XP, XN} and YLIMB. Both + operands must be non-zero. + + -- Function: mp_size_t mpn_gcdext (mp_limb_t *GP, mp_limb_t *SP, + mp_size_t *SN, mp_limb_t *XP, mp_size_t XN, mp_limb_t *YP, + mp_size_t YN) + Let U be defined by {XP, XN} and let V be defined by {YP, YN}. + + Compute the greatest common divisor G of U and V. Compute a + cofactor S such that G = US + VT. The second cofactor T is not + computed but can easily be obtained from (G - U*S) / V (the + division will be exact). It is required that U >= V > 0. + + S satisfies S = 1 or abs(S) < V / (2 G). S = 0 if and only if V + divides U (i.e., G = V). + + Store G at GP and let the return value define its limb count. + Store S at SP and let |*SN| define its limb count. S can be + negative; when this happens *SN will be negative. The areas at GP + and SP should each have room for XN+1 limbs. + + The areas {XP, XN+1} and {YP, YN+1} are destroyed (i.e. the input + operands plus an extra limb past the end of each). + + Compatibility note: GMP 4.3.0 and 4.3.1 defined S less strictly. + Earlier as well as later GMP releases define S as described here. + + -- Function: mp_size_t mpn_sqrtrem (mp_limb_t *R1P, mp_limb_t *R2P, + const mp_limb_t *SP, mp_size_t N) + Compute the square root of {SP, N} and put the result at {R1P, + ceil(N/2)} and the remainder at {R2P, RETVAL}. R2P needs space + for N limbs, but the return value indicates how many are produced. + + The most significant limb of {SP, N} must be non-zero. The areas + {R1P, ceil(N/2)} and {SP, N} must be completely separate. The + areas {R2P, N} and {SP, N} must be either identical or completely + separate. + + If the remainder is not wanted then R2P can be `NULL', and in this + case the return value is zero or non-zero according to whether the + remainder would have been zero or non-zero. + + A return value of zero indicates a perfect square. See also + `mpz_perfect_square_p'. + + -- Function: mp_size_t mpn_get_str (unsigned char *STR, int BASE, + mp_limb_t *S1P, mp_size_t S1N) + Convert {S1P, S1N} to a raw unsigned char array at STR in base + BASE, and return the number of characters produced. There may be + leading zeros in the string. The string is not in ASCII; to + convert it to printable format, add the ASCII codes for `0' or + `A', depending on the base and range. BASE can vary from 2 to 256. + + The most significant limb of the input {S1P, S1N} must be + non-zero. The input {S1P, S1N} is clobbered, except when BASE is + a power of 2, in which case it's unchanged. + + The area at STR has to have space for the largest possible number + represented by a S1N long limb array, plus one extra character. + + -- Function: mp_size_t mpn_set_str (mp_limb_t *RP, const unsigned char + *STR, size_t STRSIZE, int BASE) + Convert bytes {STR,STRSIZE} in the given BASE to limbs at RP. + + STR[0] is the most significant byte and STR[STRSIZE-1] is the + least significant. Each byte should be a value in the range 0 to + BASE-1, not an ASCII character. BASE can vary from 2 to 256. + + The return value is the number of limbs written to RP. If the most + significant input byte is non-zero then the high limb at RP will be + non-zero, and only that exact number of limbs will be required + there. + + If the most significant input byte is zero then there may be high + zero limbs written to RP and included in the return value. + + STRSIZE must be at least 1, and no overlap is permitted between + {STR,STRSIZE} and the result at RP. + + -- Function: mp_bitcnt_t mpn_scan0 (const mp_limb_t *S1P, mp_bitcnt_t + BIT) + Scan S1P from bit position BIT for the next clear bit. + + It is required that there be a clear bit within the area at S1P at + or beyond bit position BIT, so that the function has something to + return. + + -- Function: mp_bitcnt_t mpn_scan1 (const mp_limb_t *S1P, mp_bitcnt_t + BIT) + Scan S1P from bit position BIT for the next set bit. + + It is required that there be a set bit within the area at S1P at or + beyond bit position BIT, so that the function has something to + return. + + -- Function: void mpn_random (mp_limb_t *R1P, mp_size_t R1N) + -- Function: void mpn_random2 (mp_limb_t *R1P, mp_size_t R1N) + Generate a random number of length R1N and store it at R1P. The + most significant limb is always non-zero. `mpn_random' generates + uniformly distributed limb data, `mpn_random2' generates long + strings of zeros and ones in the binary representation. + + `mpn_random2' is intended for testing the correctness of the `mpn' + routines. + + -- Function: mp_bitcnt_t mpn_popcount (const mp_limb_t *S1P, mp_size_t + N) + Count the number of set bits in {S1P, N}. + + -- Function: mp_bitcnt_t mpn_hamdist (const mp_limb_t *S1P, const + mp_limb_t *S2P, mp_size_t N) + Compute the hamming distance between {S1P, N} and {S2P, N}, which + is the number of bit positions where the two operands have + different bit values. + + -- Function: int mpn_perfect_square_p (const mp_limb_t *S1P, mp_size_t + N) + Return non-zero iff {S1P, N} is a perfect square. + + -- Function: void mpn_and_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical and of {S1P, N} and {S2P, N}, and + write the result to {RP, N}. + + -- Function: void mpn_ior_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical inclusive or of {S1P, N} and {S2P, N}, + and write the result to {RP, N}. + + -- Function: void mpn_xor_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical exclusive or of {S1P, N} and {S2P, N}, + and write the result to {RP, N}. + + -- Function: void mpn_andn_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical and of {S1P, N} and the bitwise + complement of {S2P, N}, and write the result to {RP, N}. + + -- Function: void mpn_iorn_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical inclusive or of {S1P, N} and the + bitwise complement of {S2P, N}, and write the result to {RP, N}. + + -- Function: void mpn_nand_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical and of {S1P, N} and {S2P, N}, and + write the bitwise complement of the result to {RP, N}. + + -- Function: void mpn_nior_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical inclusive or of {S1P, N} and {S2P, N}, + and write the bitwise complement of the result to {RP, N}. + + -- Function: void mpn_xnor_n (mp_limb_t *RP, const mp_limb_t *S1P, + const mp_limb_t *S2P, mp_size_t N) + Perform the bitwise logical exclusive or of {S1P, N} and {S2P, N}, + and write the bitwise complement of the result to {RP, N}. + + -- Function: void mpn_com (mp_limb_t *RP, const mp_limb_t *SP, + mp_size_t N) + Perform the bitwise complement of {SP, N}, and write the result to + {RP, N}. + + -- Function: void mpn_copyi (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t N) + Copy from {S1P, N} to {RP, N}, increasingly. + + -- Function: void mpn_copyd (mp_limb_t *RP, const mp_limb_t *S1P, + mp_size_t N) + Copy from {S1P, N} to {RP, N}, decreasingly. + + -- Function: void mpn_zero (mp_limb_t *RP, mp_size_t N) + Zero {RP, N}. + + +8.1 Nails +========= + +*Everything in this section is highly experimental and may disappear or +be subject to incompatible changes in a future version of GMP.* + + Nails are an experimental feature whereby a few bits are left unused +at the top of each `mp_limb_t'. This can significantly improve carry +handling on some processors. + + All the `mpn' functions accepting limb data will expect the nail +bits to be zero on entry, and will return data with the nails similarly +all zero. This applies both to limb vectors and to single limb +arguments. + + Nails can be enabled by configuring with `--enable-nails'. By +default the number of bits will be chosen according to what suits the +host processor, but a particular number can be selected with +`--enable-nails=N'. + + At the mpn level, a nail build is neither source nor binary +compatible with a non-nail build, strictly speaking. But programs +acting on limbs only through the mpn functions are likely to work +equally well with either build, and judicious use of the definitions +below should make any program compatible with either build, at the +source level. + + For the higher level routines, meaning `mpz' etc, a nail build +should be fully source and binary compatible with a non-nail build. + + -- Macro: GMP_NAIL_BITS + -- Macro: GMP_NUMB_BITS + -- Macro: GMP_LIMB_BITS + `GMP_NAIL_BITS' is the number of nail bits, or 0 when nails are + not in use. `GMP_NUMB_BITS' is the number of data bits in a limb. + `GMP_LIMB_BITS' is the total number of bits in an `mp_limb_t'. In + all cases + + GMP_LIMB_BITS == GMP_NAIL_BITS + GMP_NUMB_BITS + + -- Macro: GMP_NAIL_MASK + -- Macro: GMP_NUMB_MASK + Bit masks for the nail and number parts of a limb. + `GMP_NAIL_MASK' is 0 when nails are not in use. + + `GMP_NAIL_MASK' is not often needed, since the nail part can be + obtained with `x >> GMP_NUMB_BITS', and that means one less large + constant, which can help various RISC chips. + + -- Macro: GMP_NUMB_MAX + The maximum value that can be stored in the number part of a limb. + This is the same as `GMP_NUMB_MASK', but can be used for clarity + when doing comparisons rather than bit-wise operations. + + The term "nails" comes from finger or toe nails, which are at the +ends of a limb (arm or leg). "numb" is short for number, but is also +how the developers felt after trying for a long time to come up with +sensible names for these things. + + In the future (the distant future most likely) a non-zero nail might +be permitted, giving non-unique representations for numbers in a limb +vector. This would help vector processors since carries would only +ever need to propagate one or two limbs. + + +File: gmp.info, Node: Random Number Functions, Next: Formatted Output, Prev: Low-level Functions, Up: Top + +9 Random Number Functions +************************* + +Sequences of pseudo-random numbers in GMP are generated using a +variable of type `gmp_randstate_t', which holds an algorithm selection +and a current state. Such a variable must be initialized by a call to +one of the `gmp_randinit' functions, and can be seeded with one of the +`gmp_randseed' functions. + + The functions actually generating random numbers are described in +*Note Integer Random Numbers::, and *Note Miscellaneous Float +Functions::. + + The older style random number functions don't accept a +`gmp_randstate_t' parameter but instead share a global variable of that +type. They use a default algorithm and are currently not seeded +(though perhaps that will change in the future). The new functions +accepting a `gmp_randstate_t' are recommended for applications that +care about randomness. + +* Menu: + +* Random State Initialization:: +* Random State Seeding:: +* Random State Miscellaneous:: + + +File: gmp.info, Node: Random State Initialization, Next: Random State Seeding, Prev: Random Number Functions, Up: Random Number Functions + +9.1 Random State Initialization +=============================== + + -- Function: void gmp_randinit_default (gmp_randstate_t STATE) + Initialize STATE with a default algorithm. This will be a + compromise between speed and randomness, and is recommended for + applications with no special requirements. Currently this is + `gmp_randinit_mt'. + + -- Function: void gmp_randinit_mt (gmp_randstate_t STATE) + Initialize STATE for a Mersenne Twister algorithm. This algorithm + is fast and has good randomness properties. + + -- Function: void gmp_randinit_lc_2exp (gmp_randstate_t STATE, mpz_t + A, unsigned long C, mp_bitcnt_t M2EXP) + Initialize STATE with a linear congruential algorithm X = (A*X + + C) mod 2^M2EXP. + + The low bits of X in this algorithm are not very random. The least + significant bit will have a period no more than 2, and the second + bit no more than 4, etc. For this reason only the high half of + each X is actually used. + + When a random number of more than M2EXP/2 bits is to be generated, + multiple iterations of the recurrence are used and the results + concatenated. + + -- Function: int gmp_randinit_lc_2exp_size (gmp_randstate_t STATE, + mp_bitcnt_t SIZE) + Initialize STATE for a linear congruential algorithm as per + `gmp_randinit_lc_2exp'. A, C and M2EXP are selected from a table, + chosen so that SIZE bits (or more) of each X will be used, ie. + M2EXP/2 >= SIZE. + + If successful the return value is non-zero. If SIZE is bigger + than the table data provides then the return value is zero. The + maximum SIZE currently supported is 128. + + -- Function: void gmp_randinit_set (gmp_randstate_t ROP, + gmp_randstate_t OP) + Initialize ROP with a copy of the algorithm and state from OP. + + -- Function: void gmp_randinit (gmp_randstate_t STATE, + gmp_randalg_t ALG, ...) + *This function is obsolete.* + + Initialize STATE with an algorithm selected by ALG. The only + choice is `GMP_RAND_ALG_LC', which is `gmp_randinit_lc_2exp_size' + described above. A third parameter of type `unsigned long' is + required, this is the SIZE for that function. + `GMP_RAND_ALG_DEFAULT' or 0 are the same as `GMP_RAND_ALG_LC'. + + `gmp_randinit' sets bits in the global variable `gmp_errno' to + indicate an error. `GMP_ERROR_UNSUPPORTED_ARGUMENT' if ALG is + unsupported, or `GMP_ERROR_INVALID_ARGUMENT' if the SIZE parameter + is too big. It may be noted this error reporting is not thread + safe (a good reason to use `gmp_randinit_lc_2exp_size' instead). + + -- Function: void gmp_randclear (gmp_randstate_t STATE) + Free all memory occupied by STATE. + + +File: gmp.info, Node: Random State Seeding, Next: Random State Miscellaneous, Prev: Random State Initialization, Up: Random Number Functions + +9.2 Random State Seeding +======================== + + -- Function: void gmp_randseed (gmp_randstate_t STATE, mpz_t SEED) + -- Function: void gmp_randseed_ui (gmp_randstate_t STATE, + unsigned long int SEED) + Set an initial seed value into STATE. + + The size of a seed determines how many different sequences of + random numbers that it's possible to generate. The "quality" of + the seed is the randomness of a given seed compared to the + previous seed used, and this affects the randomness of separate + number sequences. The method for choosing a seed is critical if + the generated numbers are to be used for important applications, + such as generating cryptographic keys. + + Traditionally the system time has been used to seed, but care + needs to be taken with this. If an application seeds often and + the resolution of the system clock is low, then the same sequence + of numbers might be repeated. Also, the system time is quite easy + to guess, so if unpredictability is required then it should + definitely not be the only source for the seed value. On some + systems there's a special device `/dev/random' which provides + random data better suited for use as a seed. + + +File: gmp.info, Node: Random State Miscellaneous, Prev: Random State Seeding, Up: Random Number Functions + +9.3 Random State Miscellaneous +============================== + + -- Function: unsigned long gmp_urandomb_ui (gmp_randstate_t STATE, + unsigned long N) + Return a uniformly distributed random number of N bits, ie. in the + range 0 to 2^N-1 inclusive. N must be less than or equal to the + number of bits in an `unsigned long'. + + -- Function: unsigned long gmp_urandomm_ui (gmp_randstate_t STATE, + unsigned long N) + Return a uniformly distributed random number in the range 0 to + N-1, inclusive. + + +File: gmp.info, Node: Formatted Output, Next: Formatted Input, Prev: Random Number Functions, Up: Top + +10 Formatted Output +******************* + +* Menu: + +* Formatted Output Strings:: +* Formatted Output Functions:: +* C++ Formatted Output:: + + +File: gmp.info, Node: Formatted Output Strings, Next: Formatted Output Functions, Prev: Formatted Output, Up: Formatted Output + +10.1 Format Strings +=================== + +`gmp_printf' and friends accept format strings similar to the standard C +`printf' (*note Formatted Output: (libc)Formatted Output.). A format +specification is of the form + + % [flags] [width] [.[precision]] [type] conv + + GMP adds types `Z', `Q' and `F' for `mpz_t', `mpq_t' and `mpf_t' +respectively, `M' for `mp_limb_t', and `N' for an `mp_limb_t' array. +`Z', `Q', `M' and `N' behave like integers. `Q' will print a `/' and a +denominator, if needed. `F' behaves like a float. For example, + + mpz_t z; + gmp_printf ("%s is an mpz %Zd\n", "here", z); + + mpq_t q; + gmp_printf ("a hex rational: %#40Qx\n", q); + + mpf_t f; + int n; + gmp_printf ("fixed point mpf %.*Ff with %d digits\n", n, f, n); + + mp_limb_t l; + gmp_printf ("limb %Mu\n", l); + + const mp_limb_t *ptr; + mp_size_t size; + gmp_printf ("limb array %Nx\n", ptr, size); + + For `N' the limbs are expected least significant first, as per the +`mpn' functions (*note Low-level Functions::). A negative size can be +given to print the value as a negative. + + All the standard C `printf' types behave the same as the C library +`printf', and can be freely intermixed with the GMP extensions. In the +current implementation the standard parts of the format string are +simply handed to `printf' and only the GMP extensions handled directly. + + The flags accepted are as follows. GLIBC style ' is only for the +standard C types (not the GMP types), and only if the C library +supports it. + + 0 pad with zeros (rather than spaces) + # show the base with `0x', `0X' or `0' + + always show a sign + (space) show a space or a `-' sign + ' group digits, GLIBC style (not GMP types) + + The optional width and precision can be given as a number within the +format string, or as a `*' to take an extra parameter of type `int', the +same as the standard `printf'. + + The standard types accepted are as follows. `h' and `l' are +portable, the rest will depend on the compiler (or include files) for +the type and the C library for the output. + + h short + hh char + j intmax_t or uintmax_t + l long or wchar_t + ll long long + L long double + q quad_t or u_quad_t + t ptrdiff_t + z size_t + +The GMP types are + + F mpf_t, float conversions + Q mpq_t, integer conversions + M mp_limb_t, integer conversions + N mp_limb_t array, integer conversions + Z mpz_t, integer conversions + + The conversions accepted are as follows. `a' and `A' are always +supported for `mpf_t' but depend on the C library for standard C float +types. `m' and `p' depend on the C library. + + a A hex floats, C99 style + c character + d decimal integer + e E scientific format float + f fixed point float + i same as d + g G fixed or scientific float + m `strerror' string, GLIBC style + n store characters written so far + o octal integer + p pointer + s string + u unsigned integer + x X hex integer + + `o', `x' and `X' are unsigned for the standard C types, but for +types `Z', `Q' and `N' they are signed. `u' is not meaningful for `Z', +`Q' and `N'. + + `M' is a proxy for the C library `l' or `L', according to the size +of `mp_limb_t'. Unsigned conversions will be usual, but a signed +conversion can be used and will interpret the value as a twos complement +negative. + + `n' can be used with any type, even the GMP types. + + Other types or conversions that might be accepted by the C library +`printf' cannot be used through `gmp_printf', this includes for +instance extensions registered with GLIBC `register_printf_function'. +Also currently there's no support for POSIX `$' style numbered arguments +(perhaps this will be added in the future). + + The precision field has it's usual meaning for integer `Z' and float +`F' types, but is currently undefined for `Q' and should not be used +with that. + + `mpf_t' conversions only ever generate as many digits as can be +accurately represented by the operand, the same as `mpf_get_str' does. +Zeros will be used if necessary to pad to the requested precision. This +happens even for an `f' conversion of an `mpf_t' which is an integer, +for instance 2^1024 in an `mpf_t' of 128 bits precision will only +produce about 40 digits, then pad with zeros to the decimal point. An +empty precision field like `%.Fe' or `%.Ff' can be used to specifically +request just the significant digits. + + The decimal point character (or string) is taken from the current +locale settings on systems which provide `localeconv' (*note Locales +and Internationalization: (libc)Locales.). The C library will normally +do the same for standard float output. + + The format string is only interpreted as plain `char's, multibyte +characters are not recognised. Perhaps this will change in the future. + + +File: gmp.info, Node: Formatted Output Functions, Next: C++ Formatted Output, Prev: Formatted Output Strings, Up: Formatted Output + +10.2 Functions +============== + +Each of the following functions is similar to the corresponding C +library function. The basic `printf' forms take a variable argument +list. The `vprintf' forms take an argument pointer, see *Note Variadic +Functions: (libc)Variadic Functions, or `man 3 va_start'. + + It should be emphasised that if a format string is invalid, or the +arguments don't match what the format specifies, then the behaviour of +any of these functions will be unpredictable. GCC format string +checking is not available, since it doesn't recognise the GMP +extensions. + + The file based functions `gmp_printf' and `gmp_fprintf' will return +-1 to indicate a write error. Output is not "atomic", so partial +output may be produced if a write error occurs. All the functions can +return -1 if the C library `printf' variant in use returns -1, but this +shouldn't normally occur. + + -- Function: int gmp_printf (const char *FMT, ...) + -- Function: int gmp_vprintf (const char *FMT, va_list AP) + Print to the standard output `stdout'. Return the number of + characters written, or -1 if an error occurred. + + -- Function: int gmp_fprintf (FILE *FP, const char *FMT, ...) + -- Function: int gmp_vfprintf (FILE *FP, const char *FMT, va_list AP) + Print to the stream FP. Return the number of characters written, + or -1 if an error occurred. + + -- Function: int gmp_sprintf (char *BUF, const char *FMT, ...) + -- Function: int gmp_vsprintf (char *BUF, const char *FMT, va_list AP) + Form a null-terminated string in BUF. Return the number of + characters written, excluding the terminating null. + + No overlap is permitted between the space at BUF and the string + FMT. + + These functions are not recommended, since there's no protection + against exceeding the space available at BUF. + + -- Function: int gmp_snprintf (char *BUF, size_t SIZE, const char + *FMT, ...) + -- Function: int gmp_vsnprintf (char *BUF, size_t SIZE, const char + *FMT, va_list AP) + Form a null-terminated string in BUF. No more than SIZE bytes + will be written. To get the full output, SIZE must be enough for + the string and null-terminator. + + The return value is the total number of characters which ought to + have been produced, excluding the terminating null. If RETVAL >= + SIZE then the actual output has been truncated to the first SIZE-1 + characters, and a null appended. + + No overlap is permitted between the region {BUF,SIZE} and the FMT + string. + + Notice the return value is in ISO C99 `snprintf' style. This is + so even if the C library `vsnprintf' is the older GLIBC 2.0.x + style. + + -- Function: int gmp_asprintf (char **PP, const char *FMT, ...) + -- Function: int gmp_vasprintf (char **PP, const char *FMT, va_list AP) + Form a null-terminated string in a block of memory obtained from + the current memory allocation function (*note Custom + Allocation::). The block will be the size of the string and + null-terminator. The address of the block in stored to *PP. The + return value is the number of characters produced, excluding the + null-terminator. + + Unlike the C library `asprintf', `gmp_asprintf' doesn't return -1 + if there's no more memory available, it lets the current allocation + function handle that. + + -- Function: int gmp_obstack_printf (struct obstack *OB, const char + *FMT, ...) + -- Function: int gmp_obstack_vprintf (struct obstack *OB, const char + *FMT, va_list AP) + Append to the current object in OB. The return value is the + number of characters written. A null-terminator is not written. + + FMT cannot be within the current object in OB, since that object + might move as it grows. + + These functions are available only when the C library provides the + obstack feature, which probably means only on GNU systems, see + *Note Obstacks: (libc)Obstacks. + + +File: gmp.info, Node: C++ Formatted Output, Prev: Formatted Output Functions, Up: Formatted Output + +10.3 C++ Formatted Output +========================= + +The following functions are provided in `libgmpxx' (*note Headers and +Libraries::), which is built if C++ support is enabled (*note Build +Options::). Prototypes are available from `'. + + -- Function: ostream& operator<< (ostream& STREAM, mpz_t OP) + Print OP to STREAM, using its `ios' formatting settings. + `ios::width' is reset to 0 after output, the same as the standard + `ostream operator<<' routines do. + + In hex or octal, OP is printed as a signed number, the same as for + decimal. This is unlike the standard `operator<<' routines on + `int' etc, which instead give twos complement. + + -- Function: ostream& operator<< (ostream& STREAM, mpq_t OP) + Print OP to STREAM, using its `ios' formatting settings. + `ios::width' is reset to 0 after output, the same as the standard + `ostream operator<<' routines do. + + Output will be a fraction like `5/9', or if the denominator is 1 + then just a plain integer like `123'. + + In hex or octal, OP is printed as a signed value, the same as for + decimal. If `ios::showbase' is set then a base indicator is shown + on both the numerator and denominator (if the denominator is + required). + + -- Function: ostream& operator<< (ostream& STREAM, mpf_t OP) + Print OP to STREAM, using its `ios' formatting settings. + `ios::width' is reset to 0 after output, the same as the standard + `ostream operator<<' routines do. + + The decimal point follows the standard library float `operator<<', + which on recent systems means the `std::locale' imbued on STREAM. + + Hex and octal are supported, unlike the standard `operator<<' on + `double'. The mantissa will be in hex or octal, the exponent will + be in decimal. For hex the exponent delimiter is an `@'. This is + as per `mpf_out_str'. + + `ios::showbase' is supported, and will put a base on the mantissa, + for example hex `0x1.8' or `0x0.8', or octal `01.4' or `00.4'. + This last form is slightly strange, but at least differentiates + itself from decimal. + + These operators mean that GMP types can be printed in the usual C++ +way, for example, + + mpz_t z; + int n; + ... + cout << "iteration " << n << " value " << z << "\n"; + + But note that `ostream' output (and `istream' input, *note C++ +Formatted Input::) is the only overloading available for the GMP types +and that for instance using `+' with an `mpz_t' will have unpredictable +results. For classes with overloading, see *Note C++ Class Interface::. + + +File: gmp.info, Node: Formatted Input, Next: C++ Class Interface, Prev: Formatted Output, Up: Top + +11 Formatted Input +****************** + +* Menu: + +* Formatted Input Strings:: +* Formatted Input Functions:: +* C++ Formatted Input:: + + +File: gmp.info, Node: Formatted Input Strings, Next: Formatted Input Functions, Prev: Formatted Input, Up: Formatted Input + +11.1 Formatted Input Strings +============================ + +`gmp_scanf' and friends accept format strings similar to the standard C +`scanf' (*note Formatted Input: (libc)Formatted Input.). A format +specification is of the form + + % [flags] [width] [type] conv + + GMP adds types `Z', `Q' and `F' for `mpz_t', `mpq_t' and `mpf_t' +respectively. `Z' and `Q' behave like integers. `Q' will read a `/' +and a denominator, if present. `F' behaves like a float. + + GMP variables don't require an `&' when passed to `gmp_scanf', since +they're already "call-by-reference". For example, + + /* to read say "a(5) = 1234" */ + int n; + mpz_t z; + gmp_scanf ("a(%d) = %Zd\n", &n, z); + + mpq_t q1, q2; + gmp_sscanf ("0377 + 0x10/0x11", "%Qi + %Qi", q1, q2); + + /* to read say "topleft (1.55,-2.66)" */ + mpf_t x, y; + char buf[32]; + gmp_scanf ("%31s (%Ff,%Ff)", buf, x, y); + + All the standard C `scanf' types behave the same as in the C library +`scanf', and can be freely intermixed with the GMP extensions. In the +current implementation the standard parts of the format string are +simply handed to `scanf' and only the GMP extensions handled directly. + + The flags accepted are as follows. `a' and `'' will depend on +support from the C library, and `'' cannot be used with GMP types. + + * read but don't store + a allocate a buffer (string conversions) + ' grouped digits, GLIBC style (not GMP + types) + + The standard types accepted are as follows. `h' and `l' are +portable, the rest will depend on the compiler (or include files) for +the type and the C library for the input. + + h short + hh char + j intmax_t or uintmax_t + l long int, double or wchar_t + ll long long + L long double + q quad_t or u_quad_t + t ptrdiff_t + z size_t + +The GMP types are + + F mpf_t, float conversions + Q mpq_t, integer conversions + Z mpz_t, integer conversions + + The conversions accepted are as follows. `p' and `[' will depend on +support from the C library, the rest are standard. + + c character or characters + d decimal integer + e E f g G float + i integer with base indicator + n characters read so far + o octal integer + p pointer + s string of non-whitespace characters + u decimal integer + x X hex integer + [ string of characters in a set + + `e', `E', `f', `g' and `G' are identical, they all read either fixed +point or scientific format, and either upper or lower case `e' for the +exponent in scientific format. + + C99 style hex float format (`printf %a', *note Formatted Output +Strings::) is always accepted for `mpf_t', but for the standard float +types it will depend on the C library. + + `x' and `X' are identical, both accept both upper and lower case +hexadecimal. + + `o', `u', `x' and `X' all read positive or negative values. For the +standard C types these are described as "unsigned" conversions, but +that merely affects certain overflow handling, negatives are still +allowed (per `strtoul', *note Parsing of Integers: (libc)Parsing of +Integers.). For GMP types there are no overflows, so `d' and `u' are +identical. + + `Q' type reads the numerator and (optional) denominator as given. +If the value might not be in canonical form then `mpq_canonicalize' +must be called before using it in any calculations (*note Rational +Number Functions::). + + `Qi' will read a base specification separately for the numerator and +denominator. For example `0x10/11' would be 16/11, whereas `0x10/0x11' +would be 16/17. + + `n' can be used with any of the types above, even the GMP types. +`*' to suppress assignment is allowed, though in that case it would do +nothing at all. + + Other conversions or types that might be accepted by the C library +`scanf' cannot be used through `gmp_scanf'. + + Whitespace is read and discarded before a field, except for `c' and +`[' conversions. + + For float conversions, the decimal point character (or string) +expected is taken from the current locale settings on systems which +provide `localeconv' (*note Locales and Internationalization: +(libc)Locales.). The C library will normally do the same for standard +float input. + + The format string is only interpreted as plain `char's, multibyte +characters are not recognised. Perhaps this will change in the future. + + +File: gmp.info, Node: Formatted Input Functions, Next: C++ Formatted Input, Prev: Formatted Input Strings, Up: Formatted Input + +11.2 Formatted Input Functions +============================== + +Each of the following functions is similar to the corresponding C +library function. The plain `scanf' forms take a variable argument +list. The `vscanf' forms take an argument pointer, see *Note Variadic +Functions: (libc)Variadic Functions, or `man 3 va_start'. + + It should be emphasised that if a format string is invalid, or the +arguments don't match what the format specifies, then the behaviour of +any of these functions will be unpredictable. GCC format string +checking is not available, since it doesn't recognise the GMP +extensions. + + No overlap is permitted between the FMT string and any of the results +produced. + + -- Function: int gmp_scanf (const char *FMT, ...) + -- Function: int gmp_vscanf (const char *FMT, va_list AP) + Read from the standard input `stdin'. + + -- Function: int gmp_fscanf (FILE *FP, const char *FMT, ...) + -- Function: int gmp_vfscanf (FILE *FP, const char *FMT, va_list AP) + Read from the stream FP. + + -- Function: int gmp_sscanf (const char *S, const char *FMT, ...) + -- Function: int gmp_vsscanf (const char *S, const char *FMT, va_list + AP) + Read from a null-terminated string S. + + The return value from each of these functions is the same as the +standard C99 `scanf', namely the number of fields successfully parsed +and stored. `%n' fields and fields read but suppressed by `*' don't +count towards the return value. + + If end of input (or a file error) is reached before a character for +a field or a literal, and if no previous non-suppressed fields have +matched, then the return value is `EOF' instead of 0. A whitespace +character in the format string is only an optional match and doesn't +induce an `EOF' in this fashion. Leading whitespace read and discarded +for a field don't count as characters for that field. + + For the GMP types, input parsing follows C99 rules, namely one +character of lookahead is used and characters are read while they +continue to meet the format requirements. If this doesn't provide a +complete number then the function terminates, with that field not +stored nor counted towards the return value. For instance with `mpf_t' +an input `1.23e-XYZ' would be read up to the `X' and that character +pushed back since it's not a digit. The string `1.23e-' would then be +considered invalid since an `e' must be followed by at least one digit. + + For the standard C types, in the current implementation GMP calls +the C library `scanf' functions, which might have looser rules about +what constitutes a valid input. + + Note that `gmp_sscanf' is the same as `gmp_fscanf' and only does one +character of lookahead when parsing. Although clearly it could look at +its entire input, it is deliberately made identical to `gmp_fscanf', +the same way C99 `sscanf' is the same as `fscanf'. + + +File: gmp.info, Node: C++ Formatted Input, Prev: Formatted Input Functions, Up: Formatted Input + +11.3 C++ Formatted Input +======================== + +The following functions are provided in `libgmpxx' (*note Headers and +Libraries::), which is built only if C++ support is enabled (*note +Build Options::). Prototypes are available from `'. + + -- Function: istream& operator>> (istream& STREAM, mpz_t ROP) + Read ROP from STREAM, using its `ios' formatting settings. + + -- Function: istream& operator>> (istream& STREAM, mpq_t ROP) + An integer like `123' will be read, or a fraction like `5/9'. No + whitespace is allowed around the `/'. If the fraction is not in + canonical form then `mpq_canonicalize' must be called (*note + Rational Number Functions::) before operating on it. + + As per integer input, an `0' or `0x' base indicator is read when + none of `ios::dec', `ios::oct' or `ios::hex' are set. This is + done separately for numerator and denominator, so that for instance + `0x10/11' is 16/11 and `0x10/0x11' is 16/17. + + -- Function: istream& operator>> (istream& STREAM, mpf_t ROP) + Read ROP from STREAM, using its `ios' formatting settings. + + Hex or octal floats are not supported, but might be in the future, + or perhaps it's best to accept only what the standard float + `operator>>' does. + + Note that digit grouping specified by the `istream' locale is +currently not accepted. Perhaps this will change in the future. + + + These operators mean that GMP types can be read in the usual C++ +way, for example, + + mpz_t z; + ... + cin >> z; + + But note that `istream' input (and `ostream' output, *note C++ +Formatted Output::) is the only overloading available for the GMP types +and that for instance using `+' with an `mpz_t' will have unpredictable +results. For classes with overloading, see *Note C++ Class Interface::. + + +File: gmp.info, Node: C++ Class Interface, Next: BSD Compatible Functions, Prev: Formatted Input, Up: Top + +12 C++ Class Interface +********************** + +This chapter describes the C++ class based interface to GMP. + + All GMP C language types and functions can be used in C++ programs, +since `gmp.h' has `extern "C"' qualifiers, but the class interface +offers overloaded functions and operators which may be more convenient. + + Due to the implementation of this interface, a reasonably recent C++ +compiler is required, one supporting namespaces, partial specialization +of templates and member templates. For GCC this means version 2.91 or +later. + + *Everything described in this chapter is to be considered preliminary +and might be subject to incompatible changes if some unforeseen +difficulty reveals itself.* + +* Menu: + +* C++ Interface General:: +* C++ Interface Integers:: +* C++ Interface Rationals:: +* C++ Interface Floats:: +* C++ Interface Random Numbers:: +* C++ Interface Limitations:: + + +File: gmp.info, Node: C++ Interface General, Next: C++ Interface Integers, Prev: C++ Class Interface, Up: C++ Class Interface + +12.1 C++ Interface General +========================== + +All the C++ classes and functions are available with + + #include + + Programs should be linked with the `libgmpxx' and `libgmp' +libraries. For example, + + g++ mycxxprog.cc -lgmpxx -lgmp + +The classes defined are + + -- Class: mpz_class + -- Class: mpq_class + -- Class: mpf_class + + The standard operators and various standard functions are overloaded +to allow arithmetic with these classes. For example, + + int + main (void) + { + mpz_class a, b, c; + + a = 1234; + b = "-5678"; + c = a+b; + cout << "sum is " << c << "\n"; + cout << "absolute value is " << abs(c) << "\n"; + + return 0; + } + + An important feature of the implementation is that an expression like +`a=b+c' results in a single call to the corresponding `mpz_add', +without using a temporary for the `b+c' part. Expressions which by +their nature imply intermediate values, like `a=b*c+d*e', still use +temporaries though. + + The classes can be freely intermixed in expressions, as can the +classes and the standard types `long', `unsigned long' and `double'. +Smaller types like `int' or `float' can also be intermixed, since C++ +will promote them. + + Note that `bool' is not accepted directly, but must be explicitly +cast to an `int' first. This is because C++ will automatically convert +any pointer to a `bool', so if GMP accepted `bool' it would make all +sorts of invalid class and pointer combinations compile but almost +certainly not do anything sensible. + + Conversions back from the classes to standard C++ types aren't done +automatically, instead member functions like `get_si' are provided (see +the following sections for details). + + Also there are no automatic conversions from the classes to the +corresponding GMP C types, instead a reference to the underlying C +object can be obtained with the following functions, + + -- Function: mpz_t mpz_class::get_mpz_t () + -- Function: mpq_t mpq_class::get_mpq_t () + -- Function: mpf_t mpf_class::get_mpf_t () + + These can be used to call a C function which doesn't have a C++ class +interface. For example to set `a' to the GCD of `b' and `c', + + mpz_class a, b, c; + ... + mpz_gcd (a.get_mpz_t(), b.get_mpz_t(), c.get_mpz_t()); + + In the other direction, a class can be initialized from the +corresponding GMP C type, or assigned to if an explicit constructor is +used. In both cases this makes a copy of the value, it doesn't create +any sort of association. For example, + + mpz_t z; + // ... init and calculate z ... + mpz_class x(z); + mpz_class y; + y = mpz_class (z); + + There are no namespace setups in `gmpxx.h', all types and functions +are simply put into the global namespace. This is what `gmp.h' has +done in the past, and continues to do for compatibility. The extras +provided by `gmpxx.h' follow GMP naming conventions and are unlikely to +clash with anything. + + +File: gmp.info, Node: C++ Interface Integers, Next: C++ Interface Rationals, Prev: C++ Interface General, Up: C++ Class Interface + +12.2 C++ Interface Integers +=========================== + + -- Function: void mpz_class::mpz_class (type N) + Construct an `mpz_class'. All the standard C++ types may be used, + except `long long' and `long double', and all the GMP C++ classes + can be used. Any necessary conversion follows the corresponding C + function, for example `double' follows `mpz_set_d' (*note + Assigning Integers::). + + -- Function: void mpz_class::mpz_class (mpz_t Z) + Construct an `mpz_class' from an `mpz_t'. The value in Z is + copied into the new `mpz_class', there won't be any permanent + association between it and Z. + + -- Function: void mpz_class::mpz_class (const char *S) + -- Function: void mpz_class::mpz_class (const char *S, int BASE = 0) + -- Function: void mpz_class::mpz_class (const string& S) + -- Function: void mpz_class::mpz_class (const string& S, int BASE = 0) + Construct an `mpz_class' converted from a string using + `mpz_set_str' (*note Assigning Integers::). + + If the string is not a valid integer, an `std::invalid_argument' + exception is thrown. The same applies to `operator='. + + -- Function: mpz_class operator/ (mpz_class A, mpz_class D) + -- Function: mpz_class operator% (mpz_class A, mpz_class D) + Divisions involving `mpz_class' round towards zero, as per the + `mpz_tdiv_q' and `mpz_tdiv_r' functions (*note Integer Division::). + This is the same as the C99 `/' and `%' operators. + + The `mpz_fdiv...' or `mpz_cdiv...' functions can always be called + directly if desired. For example, + + mpz_class q, a, d; + ... + mpz_fdiv_q (q.get_mpz_t(), a.get_mpz_t(), d.get_mpz_t()); + + -- Function: mpz_class abs (mpz_class OP1) + -- Function: int cmp (mpz_class OP1, type OP2) + -- Function: int cmp (type OP1, mpz_class OP2) + -- Function: bool mpz_class::fits_sint_p (void) + -- Function: bool mpz_class::fits_slong_p (void) + -- Function: bool mpz_class::fits_sshort_p (void) + -- Function: bool mpz_class::fits_uint_p (void) + -- Function: bool mpz_class::fits_ulong_p (void) + -- Function: bool mpz_class::fits_ushort_p (void) + -- Function: double mpz_class::get_d (void) + -- Function: long mpz_class::get_si (void) + -- Function: string mpz_class::get_str (int BASE = 10) + -- Function: unsigned long mpz_class::get_ui (void) + -- Function: int mpz_class::set_str (const char *STR, int BASE) + -- Function: int mpz_class::set_str (const string& STR, int BASE) + -- Function: int sgn (mpz_class OP) + -- Function: mpz_class sqrt (mpz_class OP) + These functions provide a C++ class interface to the corresponding + GMP C routines. + + `cmp' can be used with any of the classes or the standard C++ + types, except `long long' and `long double'. + + + Overloaded operators for combinations of `mpz_class' and `double' +are provided for completeness, but it should be noted that if the given +`double' is not an integer then the way any rounding is done is +currently unspecified. The rounding might take place at the start, in +the middle, or at the end of the operation, and it might change in the +future. + + Conversions between `mpz_class' and `double', however, are defined +to follow the corresponding C functions `mpz_get_d' and `mpz_set_d'. +And comparisons are always made exactly, as per `mpz_cmp_d'. + + +File: gmp.info, Node: C++ Interface Rationals, Next: C++ Interface Floats, Prev: C++ Interface Integers, Up: C++ Class Interface + +12.3 C++ Interface Rationals +============================ + +In all the following constructors, if a fraction is given then it +should be in canonical form, or if not then `mpq_class::canonicalize' +called. + + -- Function: void mpq_class::mpq_class (type OP) + -- Function: void mpq_class::mpq_class (integer NUM, integer DEN) + Construct an `mpq_class'. The initial value can be a single value + of any type, or a pair of integers (`mpz_class' or standard C++ + integer types) representing a fraction, except that `long long' + and `long double' are not supported. For example, + + mpq_class q (99); + mpq_class q (1.75); + mpq_class q (1, 3); + + -- Function: void mpq_class::mpq_class (mpq_t Q) + Construct an `mpq_class' from an `mpq_t'. The value in Q is + copied into the new `mpq_class', there won't be any permanent + association between it and Q. + + -- Function: void mpq_class::mpq_class (const char *S) + -- Function: void mpq_class::mpq_class (const char *S, int BASE = 0) + -- Function: void mpq_class::mpq_class (const string& S) + -- Function: void mpq_class::mpq_class (const string& S, int BASE = 0) + Construct an `mpq_class' converted from a string using + `mpq_set_str' (*note Initializing Rationals::). + + If the string is not a valid rational, an `std::invalid_argument' + exception is thrown. The same applies to `operator='. + + -- Function: void mpq_class::canonicalize () + Put an `mpq_class' into canonical form, as per *Note Rational + Number Functions::. All arithmetic operators require their + operands in canonical form, and will return results in canonical + form. + + -- Function: mpq_class abs (mpq_class OP) + -- Function: int cmp (mpq_class OP1, type OP2) + -- Function: int cmp (type OP1, mpq_class OP2) + -- Function: double mpq_class::get_d (void) + -- Function: string mpq_class::get_str (int BASE = 10) + -- Function: int mpq_class::set_str (const char *STR, int BASE) + -- Function: int mpq_class::set_str (const string& STR, int BASE) + -- Function: int sgn (mpq_class OP) + These functions provide a C++ class interface to the corresponding + GMP C routines. + + `cmp' can be used with any of the classes or the standard C++ + types, except `long long' and `long double'. + + -- Function: mpz_class& mpq_class::get_num () + -- Function: mpz_class& mpq_class::get_den () + Get a reference to an `mpz_class' which is the numerator or + denominator of an `mpq_class'. This can be used both for read and + write access. If the object returned is modified, it modifies the + original `mpq_class'. + + If direct manipulation might produce a non-canonical value, then + `mpq_class::canonicalize' must be called before further operations. + + -- Function: mpz_t mpq_class::get_num_mpz_t () + -- Function: mpz_t mpq_class::get_den_mpz_t () + Get a reference to the underlying `mpz_t' numerator or denominator + of an `mpq_class'. This can be passed to C functions expecting an + `mpz_t'. Any modifications made to the `mpz_t' will modify the + original `mpq_class'. + + If direct manipulation might produce a non-canonical value, then + `mpq_class::canonicalize' must be called before further operations. + + -- Function: istream& operator>> (istream& STREAM, mpq_class& ROP); + Read ROP from STREAM, using its `ios' formatting settings, the + same as `mpq_t operator>>' (*note C++ Formatted Input::). + + If the ROP read might not be in canonical form then + `mpq_class::canonicalize' must be called. + + +File: gmp.info, Node: C++ Interface Floats, Next: C++ Interface Random Numbers, Prev: C++ Interface Rationals, Up: C++ Class Interface + +12.4 C++ Interface Floats +========================= + +When an expression requires the use of temporary intermediate +`mpf_class' values, like `f=g*h+x*y', those temporaries will have the +same precision as the destination `f'. Explicit constructors can be +used if this doesn't suit. + + -- Function: mpf_class::mpf_class (type OP) + -- Function: mpf_class::mpf_class (type OP, unsigned long PREC) + Construct an `mpf_class'. Any standard C++ type can be used, + except `long long' and `long double', and any of the GMP C++ + classes can be used. + + If PREC is given, the initial precision is that value, in bits. If + PREC is not given, then the initial precision is determined by the + type of OP given. An `mpz_class', `mpq_class', or C++ builtin + type will give the default `mpf' precision (*note Initializing + Floats::). An `mpf_class' or expression will give the precision + of that value. The precision of a binary expression is the higher + of the two operands. + + mpf_class f(1.5); // default precision + mpf_class f(1.5, 500); // 500 bits (at least) + mpf_class f(x); // precision of x + mpf_class f(abs(x)); // precision of x + mpf_class f(-g, 1000); // 1000 bits (at least) + mpf_class f(x+y); // greater of precisions of x and y + + -- Function: void mpf_class::mpf_class (const char *S) + -- Function: void mpf_class::mpf_class (const char *S, unsigned long + PREC, int BASE = 0) + -- Function: void mpf_class::mpf_class (const string& S) + -- Function: void mpf_class::mpf_class (const string& S, unsigned long + PREC, int BASE = 0) + Construct an `mpf_class' converted from a string using + `mpf_set_str' (*note Assigning Floats::). If PREC is given, the + initial precision is that value, in bits. If not, the default + `mpf' precision (*note Initializing Floats::) is used. + + If the string is not a valid float, an `std::invalid_argument' + exception is thrown. The same applies to `operator='. + + -- Function: mpf_class& mpf_class::operator= (type OP) + Convert and store the given OP value to an `mpf_class' object. The + same types are accepted as for the constructors above. + + Note that `operator=' only stores a new value, it doesn't copy or + change the precision of the destination, instead the value is + truncated if necessary. This is the same as `mpf_set' etc. Note + in particular this means for `mpf_class' a copy constructor is not + the same as a default constructor plus assignment. + + mpf_class x (y); // x created with precision of y + + mpf_class x; // x created with default precision + x = y; // value truncated to that precision + + Applications using templated code may need to be careful about the + assumptions the code makes in this area, when working with + `mpf_class' values of various different or non-default precisions. + For instance implementations of the standard `complex' template + have been seen in both styles above, though of course `complex' is + normally only actually specified for use with the builtin float + types. + + -- Function: mpf_class abs (mpf_class OP) + -- Function: mpf_class ceil (mpf_class OP) + -- Function: int cmp (mpf_class OP1, type OP2) + -- Function: int cmp (type OP1, mpf_class OP2) + -- Function: bool mpf_class::fits_sint_p (void) + -- Function: bool mpf_class::fits_slong_p (void) + -- Function: bool mpf_class::fits_sshort_p (void) + -- Function: bool mpf_class::fits_uint_p (void) + -- Function: bool mpf_class::fits_ulong_p (void) + -- Function: bool mpf_class::fits_ushort_p (void) + -- Function: mpf_class floor (mpf_class OP) + -- Function: mpf_class hypot (mpf_class OP1, mpf_class OP2) + -- Function: double mpf_class::get_d (void) + -- Function: long mpf_class::get_si (void) + -- Function: string mpf_class::get_str (mp_exp_t& EXP, int BASE = 10, + size_t DIGITS = 0) + -- Function: unsigned long mpf_class::get_ui (void) + -- Function: int mpf_class::set_str (const char *STR, int BASE) + -- Function: int mpf_class::set_str (const string& STR, int BASE) + -- Function: int sgn (mpf_class OP) + -- Function: mpf_class sqrt (mpf_class OP) + -- Function: mpf_class trunc (mpf_class OP) + These functions provide a C++ class interface to the corresponding + GMP C routines. + + `cmp' can be used with any of the classes or the standard C++ + types, except `long long' and `long double'. + + The accuracy provided by `hypot' is not currently guaranteed. + + -- Function: mp_bitcnt_t mpf_class::get_prec () + -- Function: void mpf_class::set_prec (mp_bitcnt_t PREC) + -- Function: void mpf_class::set_prec_raw (mp_bitcnt_t PREC) + Get or set the current precision of an `mpf_class'. + + The restrictions described for `mpf_set_prec_raw' (*note + Initializing Floats::) apply to `mpf_class::set_prec_raw'. Note + in particular that the `mpf_class' must be restored to it's + allocated precision before being destroyed. This must be done by + application code, there's no automatic mechanism for it. + + +File: gmp.info, Node: C++ Interface Random Numbers, Next: C++ Interface Limitations, Prev: C++ Interface Floats, Up: C++ Class Interface + +12.5 C++ Interface Random Numbers +================================= + + -- Class: gmp_randclass + The C++ class interface to the GMP random number functions uses + `gmp_randclass' to hold an algorithm selection and current state, + as per `gmp_randstate_t'. + + -- Function: gmp_randclass::gmp_randclass (void (*RANDINIT) + (gmp_randstate_t, ...), ...) + Construct a `gmp_randclass', using a call to the given RANDINIT + function (*note Random State Initialization::). The arguments + expected are the same as RANDINIT, but with `mpz_class' instead of + `mpz_t'. For example, + + gmp_randclass r1 (gmp_randinit_default); + gmp_randclass r2 (gmp_randinit_lc_2exp_size, 32); + gmp_randclass r3 (gmp_randinit_lc_2exp, a, c, m2exp); + gmp_randclass r4 (gmp_randinit_mt); + + `gmp_randinit_lc_2exp_size' will fail if the size requested is too + big, an `std::length_error' exception is thrown in that case. + + -- Function: gmp_randclass::gmp_randclass (gmp_randalg_t ALG, ...) + Construct a `gmp_randclass' using the same parameters as + `gmp_randinit' (*note Random State Initialization::). This + function is obsolete and the above RANDINIT style should be + preferred. + + -- Function: void gmp_randclass::seed (unsigned long int S) + -- Function: void gmp_randclass::seed (mpz_class S) + Seed a random number generator. See *note Random Number + Functions::, for how to choose a good seed. + + -- Function: mpz_class gmp_randclass::get_z_bits (unsigned long BITS) + -- Function: mpz_class gmp_randclass::get_z_bits (mpz_class BITS) + Generate a random integer with a specified number of bits. + + -- Function: mpz_class gmp_randclass::get_z_range (mpz_class N) + Generate a random integer in the range 0 to N-1 inclusive. + + -- Function: mpf_class gmp_randclass::get_f () + -- Function: mpf_class gmp_randclass::get_f (unsigned long PREC) + Generate a random float F in the range 0 <= F < 1. F will be to + PREC bits precision, or if PREC is not given then to the precision + of the destination. For example, + + gmp_randclass r; + ... + mpf_class f (0, 512); // 512 bits precision + f = r.get_f(); // random number, 512 bits + + +File: gmp.info, Node: C++ Interface Limitations, Prev: C++ Interface Random Numbers, Up: C++ Class Interface + +12.6 C++ Interface Limitations +============================== + +`mpq_class' and Templated Reading + A generic piece of template code probably won't know that + `mpq_class' requires a `canonicalize' call if inputs read with + `operator>>' might be non-canonical. This can lead to incorrect + results. + + `operator>>' behaves as it does for reasons of efficiency. A + canonicalize can be quite time consuming on large operands, and is + best avoided if it's not necessary. + + But this potential difficulty reduces the usefulness of + `mpq_class'. Perhaps a mechanism to tell `operator>>' what to do + will be adopted in the future, maybe a preprocessor define, a + global flag, or an `ios' flag pressed into service. Or maybe, at + the risk of inconsistency, the `mpq_class' `operator>>' could + canonicalize and leave `mpq_t' `operator>>' not doing so, for use + on those occasions when that's acceptable. Send feedback or + alternate ideas to . + +Subclassing + Subclassing the GMP C++ classes works, but is not currently + recommended. + + Expressions involving subclasses resolve correctly (or seem to), + but in normal C++ fashion the subclass doesn't inherit + constructors and assignments. There's many of those in the GMP + classes, and a good way to reestablish them in a subclass is not + yet provided. + +Templated Expressions + A subtle difficulty exists when using expressions together with + application-defined template functions. Consider the following, + with `T' intended to be some numeric type, + + template + T fun (const T &, const T &); + + When used with, say, plain `mpz_class' variables, it works fine: + `T' is resolved as `mpz_class'. + + mpz_class f(1), g(2); + fun (f, g); // Good + + But when one of the arguments is an expression, it doesn't work. + + mpz_class f(1), g(2), h(3); + fun (f, g+h); // Bad + + This is because `g+h' ends up being a certain expression template + type internal to `gmpxx.h', which the C++ template resolution + rules are unable to automatically convert to `mpz_class'. The + workaround is simply to add an explicit cast. + + mpz_class f(1), g(2), h(3); + fun (f, mpz_class(g+h)); // Good + + Similarly, within `fun' it may be necessary to cast an expression + to type `T' when calling a templated `fun2'. + + template + void fun (T f, T g) + { + fun2 (f, f+g); // Bad + } + + template + void fun (T f, T g) + { + fun2 (f, T(f+g)); // Good + } + + +File: gmp.info, Node: BSD Compatible Functions, Next: Custom Allocation, Prev: C++ Class Interface, Up: Top + +13 Berkeley MP Compatible Functions +*********************************** + +These functions are intended to be fully compatible with the Berkeley MP +library which is available on many BSD derived U*ix systems. The +`--enable-mpbsd' option must be used when building GNU MP to make these +available (*note Installing GMP::). + + The original Berkeley MP library has a usage restriction: you cannot +use the same variable as both source and destination in a single +function call. The compatible functions in GNU MP do not share this +restriction--inputs and outputs may overlap. + + It is not recommended that new programs are written using these +functions. Apart from the incomplete set of functions, the interface +for initializing `MINT' objects is more error prone, and the `pow' +function collides with `pow' in `libm.a'. + + Include the header `mp.h' to get the definition of the necessary +types and functions. If you are on a BSD derived system, make sure to +include GNU `mp.h' if you are going to link the GNU `libmp.a' to your +program. This means that you probably need to give the `-I' +option to the compiler, where `' is the directory where you have +GNU `mp.h'. + + -- Function: MINT * itom (signed short int INITIAL_VALUE) + Allocate an integer consisting of a `MINT' object and dynamic limb + space. Initialize the integer to INITIAL_VALUE. Return a pointer + to the `MINT' object. + + -- Function: MINT * xtom (char *INITIAL_VALUE) + Allocate an integer consisting of a `MINT' object and dynamic limb + space. Initialize the integer from INITIAL_VALUE, a hexadecimal, + null-terminated C string. Return a pointer to the `MINT' object. + + -- Function: void move (MINT *SRC, MINT *DEST) + Set DEST to SRC by copying. Both variables must be previously + initialized. + + -- Function: void madd (MINT *SRC_1, MINT *SRC_2, MINT *DESTINATION) + Add SRC_1 and SRC_2 and put the sum in DESTINATION. + + -- Function: void msub (MINT *SRC_1, MINT *SRC_2, MINT *DESTINATION) + Subtract SRC_2 from SRC_1 and put the difference in DESTINATION. + + -- Function: void mult (MINT *SRC_1, MINT *SRC_2, MINT *DESTINATION) + Multiply SRC_1 and SRC_2 and put the product in DESTINATION. + + -- Function: void mdiv (MINT *DIVIDEND, MINT *DIVISOR, MINT *QUOTIENT, + MINT *REMAINDER) + -- Function: void sdiv (MINT *DIVIDEND, signed short int DIVISOR, MINT + *QUOTIENT, signed short int *REMAINDER) + Set QUOTIENT to DIVIDEND/DIVISOR, and REMAINDER to DIVIDEND mod + DIVISOR. The quotient is rounded towards zero; the remainder has + the same sign as the dividend unless it is zero. + + Some implementations of these functions work differently--or not + at all--for negative arguments. + + -- Function: void msqrt (MINT *OP, MINT *ROOT, MINT *REMAINDER) + Set ROOT to the truncated integer part of the square root of OP, + like `mpz_sqrt'. Set REMAINDER to OP-ROOT*ROOT, i.e. zero if OP + is a perfect square. + + If ROOT and REMAINDER are the same variable, the results are + undefined. + + -- Function: void pow (MINT *BASE, MINT *EXP, MINT *MOD, MINT *DEST) + Set DEST to (BASE raised to EXP) modulo MOD. + + Note that the name `pow' clashes with `pow' from the standard C + math library (*note Exponentiation and Logarithms: (libc)Exponents + and Logarithms.). An application will only be able to use one or + the other. + + -- Function: void rpow (MINT *BASE, signed short int EXP, MINT *DEST) + Set DEST to BASE raised to EXP. + + -- Function: void gcd (MINT *OP1, MINT *OP2, MINT *RES) + Set RES to the greatest common divisor of OP1 and OP2. + + -- Function: int mcmp (MINT *OP1, MINT *OP2) + Compare OP1 and OP2. Return a positive value if OP1 > OP2, zero + if OP1 = OP2, and a negative value if OP1 < OP2. + + -- Function: void min (MINT *DEST) + Input a decimal string from `stdin', and put the read integer in + DEST. SPC and TAB are allowed in the number string, and are + ignored. + + -- Function: void mout (MINT *SRC) + Output SRC to `stdout', as a decimal string. Also output a + newline. + + -- Function: char * mtox (MINT *OP) + Convert OP to a hexadecimal string, and return a pointer to the + string. The returned string is allocated using the default memory + allocation function, `malloc' by default. It will be + `strlen(str)+1' bytes, that being exactly enough for the string + and null-terminator. + + -- Function: void mfree (MINT *OP) + De-allocate, the space used by OP. *This function should only be + passed a value returned by `itom' or `xtom'.* + + +File: gmp.info, Node: Custom Allocation, Next: Language Bindings, Prev: BSD Compatible Functions, Up: Top + +14 Custom Allocation +******************** + +By default GMP uses `malloc', `realloc' and `free' for memory +allocation, and if they fail GMP prints a message to the standard error +output and terminates the program. + + Alternate functions can be specified, to allocate memory in a +different way or to have a different error action on running out of +memory. + + This feature is available in the Berkeley compatibility library +(*note BSD Compatible Functions::) as well as the main GMP library. + + -- Function: void mp_set_memory_functions ( + void *(*ALLOC_FUNC_PTR) (size_t), + void *(*REALLOC_FUNC_PTR) (void *, size_t, size_t), + void (*FREE_FUNC_PTR) (void *, size_t)) + Replace the current allocation functions from the arguments. If + an argument is `NULL', the corresponding default function is used. + + These functions will be used for all memory allocation done by + GMP, apart from temporary space from `alloca' if that function is + available and GMP is configured to use it (*note Build Options::). + + *Be sure to call `mp_set_memory_functions' only when there are no + active GMP objects allocated using the previous memory functions! + Usually that means calling it before any other GMP function.* + + The functions supplied should fit the following declarations: + + -- Function: void * allocate_function (size_t ALLOC_SIZE) + Return a pointer to newly allocated space with at least ALLOC_SIZE + bytes. + + -- Function: void * reallocate_function (void *PTR, size_t OLD_SIZE, + size_t NEW_SIZE) + Resize a previously allocated block PTR of OLD_SIZE bytes to be + NEW_SIZE bytes. + + The block may be moved if necessary or if desired, and in that + case the smaller of OLD_SIZE and NEW_SIZE bytes must be copied to + the new location. The return value is a pointer to the resized + block, that being the new location if moved or just PTR if not. + + PTR is never `NULL', it's always a previously allocated block. + NEW_SIZE may be bigger or smaller than OLD_SIZE. + + -- Function: void free_function (void *PTR, size_t SIZE) + De-allocate the space pointed to by PTR. + + PTR is never `NULL', it's always a previously allocated block of + SIZE bytes. + + A "byte" here means the unit used by the `sizeof' operator. + + The OLD_SIZE parameters to REALLOCATE_FUNCTION and FREE_FUNCTION are +passed for convenience, but of course can be ignored if not needed. +The default functions using `malloc' and friends for instance don't use +them. + + No error return is allowed from any of these functions, if they +return then they must have performed the specified operation. In +particular note that ALLOCATE_FUNCTION or REALLOCATE_FUNCTION mustn't +return `NULL'. + + Getting a different fatal error action is a good use for custom +allocation functions, for example giving a graphical dialog rather than +the default print to `stderr'. How much is possible when genuinely out +of memory is another question though. + + There's currently no defined way for the allocation functions to +recover from an error such as out of memory, they must terminate +program execution. A `longjmp' or throwing a C++ exception will have +undefined results. This may change in the future. + + GMP may use allocated blocks to hold pointers to other allocated +blocks. This will limit the assumptions a conservative garbage +collection scheme can make. + + Since the default GMP allocation uses `malloc' and friends, those +functions will be linked in even if the first thing a program does is an +`mp_set_memory_functions'. It's necessary to change the GMP sources if +this is a problem. + + + -- Function: void mp_get_memory_functions ( + void *(**ALLOC_FUNC_PTR) (size_t), + void *(**REALLOC_FUNC_PTR) (void *, size_t, size_t), + void (**FREE_FUNC_PTR) (void *, size_t)) + Get the current allocation functions, storing function pointers to + the locations given by the arguments. If an argument is `NULL', + that function pointer is not stored. + + For example, to get just the current free function, + + void (*freefunc) (void *, size_t); + + mp_get_memory_functions (NULL, NULL, &freefunc); + + +File: gmp.info, Node: Language Bindings, Next: Algorithms, Prev: Custom Allocation, Up: Top + +15 Language Bindings +******************** + +The following packages and projects offer access to GMP from languages +other than C, though perhaps with varying levels of functionality and +efficiency. + + +C++ + * GMP C++ class interface, *note C++ Class Interface:: + Straightforward interface, expression templates to eliminate + temporaries. + + * ALP `http://www-sop.inria.fr/saga/logiciels/ALP/' + Linear algebra and polynomials using templates. + + * Arithmos `http://www.win.ua.ac.be/~cant/arithmos/' + Rationals with infinities and square roots. + + * CLN `http://www.ginac.de/CLN/' + High level classes for arithmetic. + + * LiDIA `http://www.cdc.informatik.tu-darmstadt.de/TI/LiDIA/' + A C++ library for computational number theory. + + * Linbox `http://www.linalg.org/' + Sparse vectors and matrices. + + * NTL `http://www.shoup.net/ntl/' + A C++ number theory library. + +Fortran + * Omni F77 `http://phase.hpcc.jp/Omni/home.html' + Arbitrary precision floats. + +Haskell + * Glasgow Haskell Compiler `http://www.haskell.org/ghc/' + +Java + * Kaffe `http://www.kaffe.org/' + + * Kissme `http://kissme.sourceforge.net/' + +Lisp + * GNU Common Lisp `http://www.gnu.org/software/gcl/gcl.html' + + * Librep `http://librep.sourceforge.net/' + + * XEmacs (21.5.18 beta and up) `http://www.xemacs.org' + Optional big integers, rationals and floats using GMP. + +M4 + * GNU m4 betas `http://www.seindal.dk/rene/gnu/' + Optionally provides an arbitrary precision `mpeval'. + +ML + * MLton compiler `http://mlton.org/' + +Objective Caml + * MLGMP `http://www.di.ens.fr/~monniaux/programmes.html.en' + + * Numerix `http://pauillac.inria.fr/~quercia/' + Optionally using GMP. + +Oz + * Mozart `http://www.mozart-oz.org/' + +Pascal + * GNU Pascal Compiler `http://www.gnu-pascal.de/' + GMP unit. + + * Numerix `http://pauillac.inria.fr/~quercia/' + For Free Pascal, optionally using GMP. + +Perl + * GMP module, see `demos/perl' in the GMP sources (*note + Demonstration Programs::). + + * Math::GMP `http://www.cpan.org/' + Compatible with Math::BigInt, but not as many functions as + the GMP module above. + + * Math::BigInt::GMP `http://www.cpan.org/' + Plug Math::GMP into normal Math::BigInt operations. + +Pike + * mpz module in the standard distribution, + `http://pike.ida.liu.se/' + +Prolog + * SWI Prolog `http://www.swi-prolog.org/' + Arbitrary precision floats. + +Python + * mpz module in the standard distribution, + `http://www.python.org/' + + * GMPY `http://gmpy.sourceforge.net/' + +Scheme + * GNU Guile (upcoming 1.8) + `http://www.gnu.org/software/guile/guile.html' + + * RScheme `http://www.rscheme.org/' + + * STklos `http://www.stklos.org/' + +Smalltalk + * GNU Smalltalk + `http://www.smalltalk.org/versions/GNUSmalltalk.html' + +Other + * Axiom `http://savannah.nongnu.org/projects/axiom' + Computer algebra using GCL. + + * DrGenius `http://drgenius.seul.org/' + Geometry system and mathematical programming language. + + * GiNaC `http://www.ginac.de/' + C++ computer algebra using CLN. + + * GOO `http://www.googoogaga.org/' + Dynamic object oriented language. + + * Maxima `http://www.ma.utexas.edu/users/wfs/maxima.html' + Macsyma computer algebra using GCL. + + * Q `http://q-lang.sourceforge.net/' + Equational programming system. + + * Regina `http://regina.sourceforge.net/' + Topological calculator. + + * Yacas `http://www.xs4all.nl/~apinkus/yacas.html' + Yet another computer algebra system. + + + +File: gmp.info, Node: Algorithms, Next: Internals, Prev: Language Bindings, Up: Top + +16 Algorithms +************* + +This chapter is an introduction to some of the algorithms used for +various GMP operations. The code is likely to be hard to understand +without knowing something about the algorithms. + + Some GMP internals are mentioned, but applications that expect to be +compatible with future GMP releases should take care to use only the +documented functions. + +* Menu: + +* Multiplication Algorithms:: +* Division Algorithms:: +* Greatest Common Divisor Algorithms:: +* Powering Algorithms:: +* Root Extraction Algorithms:: +* Radix Conversion Algorithms:: +* Other Algorithms:: +* Assembly Coding:: + + +File: gmp.info, Node: Multiplication Algorithms, Next: Division Algorithms, Prev: Algorithms, Up: Algorithms + +16.1 Multiplication +=================== + +NxN limb multiplications and squares are done using one of five +algorithms, as the size N increases. + + Algorithm Threshold + Basecase (none) + Karatsuba `MUL_TOOM22_THRESHOLD' + Toom-3 `MUL_TOOM33_THRESHOLD' + Toom-4 `MUL_TOOM44_THRESHOLD' + FFT `MUL_FFT_THRESHOLD' + + Similarly for squaring, with the `SQR' thresholds. + + NxM multiplications of operands with different sizes above +`MUL_TOOM22_THRESHOLD' are currently done by special Toom-inspired +algorithms or directly with FFT, depending on operand size (*note +Unbalanced Multiplication::). + +* Menu: + +* Basecase Multiplication:: +* Karatsuba Multiplication:: +* Toom 3-Way Multiplication:: +* Toom 4-Way Multiplication:: +* FFT Multiplication:: +* Other Multiplication:: +* Unbalanced Multiplication:: + + +File: gmp.info, Node: Basecase Multiplication, Next: Karatsuba Multiplication, Prev: Multiplication Algorithms, Up: Multiplication Algorithms + +16.1.1 Basecase Multiplication +------------------------------ + +Basecase NxM multiplication is a straightforward rectangular set of +cross-products, the same as long multiplication done by hand and for +that reason sometimes known as the schoolbook or grammar school method. +This is an O(N*M) algorithm. See Knuth section 4.3.1 algorithm M +(*note References::), and the `mpn/generic/mul_basecase.c' code. + + Assembly implementations of `mpn_mul_basecase' are essentially the +same as the generic C code, but have all the usual assembly tricks and +obscurities introduced for speed. + + A square can be done in roughly half the time of a multiply, by +using the fact that the cross products above and below the diagonal are +the same. A triangle of products below the diagonal is formed, doubled +(left shift by one bit), and then the products on the diagonal added. +This can be seen in `mpn/generic/sqr_basecase.c'. Again the assembly +implementations take essentially the same approach. + + u0 u1 u2 u3 u4 + +---+---+---+---+---+ + u0 | d | | | | | + +---+---+---+---+---+ + u1 | | d | | | | + +---+---+---+---+---+ + u2 | | | d | | | + +---+---+---+---+---+ + u3 | | | | d | | + +---+---+---+---+---+ + u4 | | | | | d | + +---+---+---+---+---+ + + In practice squaring isn't a full 2x faster than multiplying, it's +usually around 1.5x. Less than 1.5x probably indicates +`mpn_sqr_basecase' wants improving on that CPU. + + On some CPUs `mpn_mul_basecase' can be faster than the generic C +`mpn_sqr_basecase' on some small sizes. `SQR_BASECASE_THRESHOLD' is +the size at which to use `mpn_sqr_basecase', this will be zero if that +routine should be used always. + + +File: gmp.info, Node: Karatsuba Multiplication, Next: Toom 3-Way Multiplication, Prev: Basecase Multiplication, Up: Multiplication Algorithms + +16.1.2 Karatsuba Multiplication +------------------------------- + +The Karatsuba multiplication algorithm is described in Knuth section +4.3.3 part A, and various other textbooks. A brief description is +given here. + + The inputs x and y are treated as each split into two parts of equal +length (or the most significant part one limb shorter if N is odd). + + high low + +----------+----------+ + | x1 | x0 | + +----------+----------+ + + +----------+----------+ + | y1 | y0 | + +----------+----------+ + + Let b be the power of 2 where the split occurs, ie. if x0 is k limbs +(y0 the same) then b=2^(k*mp_bits_per_limb). With that x=x1*b+x0 and +y=y1*b+y0, and the following holds, + + x*y = (b^2+b)*x1*y1 - b*(x1-x0)*(y1-y0) + (b+1)*x0*y0 + + This formula means doing only three multiplies of (N/2)x(N/2) limbs, +whereas a basecase multiply of NxN limbs is equivalent to four +multiplies of (N/2)x(N/2). The factors (b^2+b) etc represent the +positions where the three products must be added. + + high low + +--------+--------+ +--------+--------+ + | x1*y1 | | x0*y0 | + +--------+--------+ +--------+--------+ + +--------+--------+ + add | x1*y1 | + +--------+--------+ + +--------+--------+ + add | x0*y0 | + +--------+--------+ + +--------+--------+ + sub | (x1-x0)*(y1-y0) | + +--------+--------+ + + The term (x1-x0)*(y1-y0) is best calculated as an absolute value, +and the sign used to choose to add or subtract. Notice the sum +high(x0*y0)+low(x1*y1) occurs twice, so it's possible to do 5*k limb +additions, rather than 6*k, but in GMP extra function call overheads +outweigh the saving. + + Squaring is similar to multiplying, but with x=y the formula reduces +to an equivalent with three squares, + + x^2 = (b^2+b)*x1^2 - b*(x1-x0)^2 + (b+1)*x0^2 + + The final result is accumulated from those three squares the same +way as for the three multiplies above. The middle term (x1-x0)^2 is now +always positive. + + A similar formula for both multiplying and squaring can be +constructed with a middle term (x1+x0)*(y1+y0). But those sums can +exceed k limbs, leading to more carry handling and additions than the +form above. + + Karatsuba multiplication is asymptotically an O(N^1.585) algorithm, +the exponent being log(3)/log(2), representing 3 multiplies each 1/2 +the size of the inputs. This is a big improvement over the basecase +multiply at O(N^2) and the advantage soon overcomes the extra additions +Karatsuba performs. `MUL_TOOM22_THRESHOLD' can be as little as 10 +limbs. The `SQR' threshold is usually about twice the `MUL'. + + The basecase algorithm will take a time of the form M(N) = a*N^2 + +b*N + c and the Karatsuba algorithm K(N) = 3*M(N/2) + d*N + e, which +expands to K(N) = 3/4*a*N^2 + 3/2*b*N + 3*c + d*N + e. The factor 3/4 +for a means per-crossproduct speedups in the basecase code will +increase the threshold since they benefit M(N) more than K(N). And +conversely the 3/2 for b means linear style speedups of b will increase +the threshold since they benefit K(N) more than M(N). The latter can +be seen for instance when adding an optimized `mpn_sqr_diagonal' to +`mpn_sqr_basecase'. Of course all speedups reduce total time, and in +that sense the algorithm thresholds are merely of academic interest. + + +File: gmp.info, Node: Toom 3-Way Multiplication, Next: Toom 4-Way Multiplication, Prev: Karatsuba Multiplication, Up: Multiplication Algorithms + +16.1.3 Toom 3-Way Multiplication +-------------------------------- + +The Karatsuba formula is the simplest case of a general approach to +splitting inputs that leads to both Toom and FFT algorithms. A +description of Toom can be found in Knuth section 4.3.3, with an +example 3-way calculation after Theorem A. The 3-way form used in GMP +is described here. + + The operands are each considered split into 3 pieces of equal length +(or the most significant part 1 or 2 limbs shorter than the other two). + + high low + +----------+----------+----------+ + | x2 | x1 | x0 | + +----------+----------+----------+ + + +----------+----------+----------+ + | y2 | y1 | y0 | + +----------+----------+----------+ + +These parts are treated as the coefficients of two polynomials + + X(t) = x2*t^2 + x1*t + x0 + Y(t) = y2*t^2 + y1*t + y0 + + Let b equal the power of 2 which is the size of the x0, x1, y0 and +y1 pieces, ie. if they're k limbs each then b=2^(k*mp_bits_per_limb). +With this x=X(b) and y=Y(b). + + Let a polynomial W(t)=X(t)*Y(t) and suppose its coefficients are + + W(t) = w4*t^4 + w3*t^3 + w2*t^2 + w1*t + w0 + + The w[i] are going to be determined, and when they are they'll give +the final result using w=W(b), since x*y=X(b)*Y(b)=W(b). The +coefficients will be roughly b^2 each, and the final W(b) will be an +addition like, + + high low + +-------+-------+ + | w4 | + +-------+-------+ + +--------+-------+ + | w3 | + +--------+-------+ + +--------+-------+ + | w2 | + +--------+-------+ + +--------+-------+ + | w1 | + +--------+-------+ + +-------+-------+ + | w0 | + +-------+-------+ + + The w[i] coefficients could be formed by a simple set of cross +products, like w4=x2*y2, w3=x2*y1+x1*y2, w2=x2*y0+x1*y1+x0*y2 etc, but +this would need all nine x[i]*y[j] for i,j=0,1,2, and would be +equivalent merely to a basecase multiply. Instead the following +approach is used. + + X(t) and Y(t) are evaluated and multiplied at 5 points, giving +values of W(t) at those points. In GMP the following points are used, + + Point Value + t=0 x0 * y0, which gives w0 immediately + t=1 (x2+x1+x0) * (y2+y1+y0) + t=-1 (x2-x1+x0) * (y2-y1+y0) + t=2 (4*x2+2*x1+x0) * (4*y2+2*y1+y0) + t=inf x2 * y2, which gives w4 immediately + + At t=-1 the values can be negative and that's handled using the +absolute values and tracking the sign separately. At t=inf the value +is actually X(t)*Y(t)/t^4 in the limit as t approaches infinity, but +it's much easier to think of as simply x2*y2 giving w4 immediately +(much like x0*y0 at t=0 gives w0 immediately). + + Each of the points substituted into W(t)=w4*t^4+...+w0 gives a +linear combination of the w[i] coefficients, and the value of those +combinations has just been calculated. + + W(0) = w0 + W(1) = w4 + w3 + w2 + w1 + w0 + W(-1) = w4 - w3 + w2 - w1 + w0 + W(2) = 16*w4 + 8*w3 + 4*w2 + 2*w1 + w0 + W(inf) = w4 + + This is a set of five equations in five unknowns, and some +elementary linear algebra quickly isolates each w[i]. This involves +adding or subtracting one W(t) value from another, and a couple of +divisions by powers of 2 and one division by 3, the latter using the +special `mpn_divexact_by3' (*note Exact Division::). + + The conversion of W(t) values to the coefficients is interpolation. +A polynomial of degree 4 like W(t) is uniquely determined by values +known at 5 different points. The points are arbitrary and can be +chosen to make the linear equations come out with a convenient set of +steps for quickly isolating the w[i]. + + Squaring follows the same procedure as multiplication, but there's +only one X(t) and it's evaluated at the 5 points, and those values +squared to give values of W(t). The interpolation is then identical, +and in fact the same `toom3_interpolate' subroutine is used for both +squaring and multiplying. + + Toom-3 is asymptotically O(N^1.465), the exponent being +log(5)/log(3), representing 5 recursive multiplies of 1/3 the original +size each. This is an improvement over Karatsuba at O(N^1.585), though +Toom does more work in the evaluation and interpolation and so it only +realizes its advantage above a certain size. + + Near the crossover between Toom-3 and Karatsuba there's generally a +range of sizes where the difference between the two is small. +`MUL_TOOM33_THRESHOLD' is a somewhat arbitrary point in that range and +successive runs of the tune program can give different values due to +small variations in measuring. A graph of time versus size for the two +shows the effect, see `tune/README'. + + At the fairly small sizes where the Toom-3 thresholds occur it's +worth remembering that the asymptotic behaviour for Karatsuba and +Toom-3 can't be expected to make accurate predictions, due of course to +the big influence of all sorts of overheads, and the fact that only a +few recursions of each are being performed. Even at large sizes +there's a good chance machine dependent effects like cache architecture +will mean actual performance deviates from what might be predicted. + + The formula given for the Karatsuba algorithm (*note Karatsuba +Multiplication::) has an equivalent for Toom-3 involving only five +multiplies, but this would be complicated and unenlightening. + + An alternate view of Toom-3 can be found in Zuras (*note +References::), using a vector to represent the x and y splits and a +matrix multiplication for the evaluation and interpolation stages. The +matrix inverses are not meant to be actually used, and they have +elements with values much greater than in fact arise in the +interpolation steps. The diagram shown for the 3-way is attractive, +but again doesn't have to be implemented that way and for example with +a bit of rearrangement just one division by 6 can be done. + + +File: gmp.info, Node: Toom 4-Way Multiplication, Next: FFT Multiplication, Prev: Toom 3-Way Multiplication, Up: Multiplication Algorithms + +16.1.4 Toom 4-Way Multiplication +-------------------------------- + +Karatsuba and Toom-3 split the operands into 2 and 3 coefficients, +respectively. Toom-4 analogously splits the operands into 4 +coefficients. Using the notation from the section on Toom-3 +multiplication, we form two polynomials: + + X(t) = x3*t^3 + x2*t^2 + x1*t + x0 + Y(t) = y3*t^3 + y2*t^2 + y1*t + y0 + + X(t) and Y(t) are evaluated and multiplied at 7 points, giving +values of W(t) at those points. In GMP the following points are used, + + Point Value + t=0 x0 * y0, which gives w0 immediately + t=1/2 (x3+2*x2+4*x1+8*x0) * (y3+2*y2+4*y1+8*y0) + t=-1/2 (-x3+2*x2-4*x1+8*x0) * (-y3+2*y2-4*y1+8*y0) + t=1 (x3+x2+x1+x0) * (y3+y2+y1+y0) + t=-1 (-x3+x2-x1+x0) * (-y3+y2-y1+y0) + t=2 (8*x3+4*x2+2*x1+x0) * (8*y3+4*y2+2*y1+y0) + t=inf x3 * y3, which gives w6 immediately + + The number of additions and subtractions for Toom-4 is much larger +than for Toom-3. But several subexpressions occur multiple times, for +example x2+x0, occurs for both t=1 and t=-1. + + Toom-4 is asymptotically O(N^1.404), the exponent being +log(7)/log(4), representing 7 recursive multiplies of 1/4 the original +size each. + + +File: gmp.info, Node: FFT Multiplication, Next: Other Multiplication, Prev: Toom 4-Way Multiplication, Up: Multiplication Algorithms + +16.1.5 FFT Multiplication +------------------------- + +At large to very large sizes a Fermat style FFT multiplication is used, +following Scho"nhage and Strassen (*note References::). Descriptions +of FFTs in various forms can be found in many textbooks, for instance +Knuth section 4.3.3 part C or Lipson chapter IX. A brief description +of the form used in GMP is given here. + + The multiplication done is x*y mod 2^N+1, for a given N. A full +product x*y is obtained by choosing N>=bits(x)+bits(y) and padding x +and y with high zero limbs. The modular product is the native form for +the algorithm, so padding to get a full product is unavoidable. + + The algorithm follows a split, evaluate, pointwise multiply, +interpolate and combine similar to that described above for Karatsuba +and Toom-3. A k parameter controls the split, with an FFT-k splitting +into 2^k pieces of M=N/2^k bits each. N must be a multiple of +(2^k)*mp_bits_per_limb so the split falls on limb boundaries, avoiding +bit shifts in the split and combine stages. + + The evaluations, pointwise multiplications, and interpolation, are +all done modulo 2^N'+1 where N' is 2M+k+3 rounded up to a multiple of +2^k and of `mp_bits_per_limb'. The results of interpolation will be +the following negacyclic convolution of the input pieces, and the +choice of N' ensures these sums aren't truncated. + + --- + \ b + w[n] = / (-1) * x[i] * y[j] + --- + i+j==b*2^k+n + b=0,1 + + The points used for the evaluation are g^i for i=0 to 2^k-1 where +g=2^(2N'/2^k). g is a 2^k'th root of unity mod 2^N'+1, which produces +necessary cancellations at the interpolation stage, and it's also a +power of 2 so the fast Fourier transforms used for the evaluation and +interpolation do only shifts, adds and negations. + + The pointwise multiplications are done modulo 2^N'+1 and either +recurse into a further FFT or use a plain multiplication (Toom-3, +Karatsuba or basecase), whichever is optimal at the size N'. The +interpolation is an inverse fast Fourier transform. The resulting set +of sums of x[i]*y[j] are added at appropriate offsets to give the final +result. + + Squaring is the same, but x is the only input so it's one transform +at the evaluate stage and the pointwise multiplies are squares. The +interpolation is the same. + + For a mod 2^N+1 product, an FFT-k is an O(N^(k/(k-1))) algorithm, +the exponent representing 2^k recursed modular multiplies each +1/2^(k-1) the size of the original. Each successive k is an asymptotic +improvement, but overheads mean each is only faster at bigger and +bigger sizes. In the code, `MUL_FFT_TABLE' and `SQR_FFT_TABLE' are the +thresholds where each k is used. Each new k effectively swaps some +multiplying for some shifts, adds and overheads. + + A mod 2^N+1 product can be formed with a normal NxN->2N bit multiply +plus a subtraction, so an FFT and Toom-3 etc can be compared directly. +A k=4 FFT at O(N^1.333) can be expected to be the first faster than +Toom-3 at O(N^1.465). In practice this is what's found, with +`MUL_FFT_MODF_THRESHOLD' and `SQR_FFT_MODF_THRESHOLD' being between 300 +and 1000 limbs, depending on the CPU. So far it's been found that only +very large FFTs recurse into pointwise multiplies above these sizes. + + When an FFT is to give a full product, the change of N to 2N doesn't +alter the theoretical complexity for a given k, but for the purposes of +considering where an FFT might be first used it can be assumed that the +FFT is recursing into a normal multiply and that on that basis it's +doing 2^k recursed multiplies each 1/2^(k-2) the size of the inputs, +making it O(N^(k/(k-2))). This would mean k=7 at O(N^1.4) would be the +first FFT faster than Toom-3. In practice `MUL_FFT_THRESHOLD' and +`SQR_FFT_THRESHOLD' have been found to be in the k=8 range, somewhere +between 3000 and 10000 limbs. + + The way N is split into 2^k pieces and then 2M+k+3 is rounded up to +a multiple of 2^k and `mp_bits_per_limb' means that when +2^k>=mp_bits_per_limb the effective N is a multiple of 2^(2k-1) bits. +The +k+3 means some values of N just under such a multiple will be +rounded to the next. The complexity calculations above assume that a +favourable size is used, meaning one which isn't padded through +rounding, and it's also assumed that the extra +k+3 bits are negligible +at typical FFT sizes. + + The practical effect of the 2^(2k-1) constraint is to introduce a +step-effect into measured speeds. For example k=8 will round N up to a +multiple of 32768 bits, so for a 32-bit limb there'll be 512 limb +groups of sizes for which `mpn_mul_n' runs at the same speed. Or for +k=9 groups of 2048 limbs, k=10 groups of 8192 limbs, etc. In practice +it's been found each k is used at quite small multiples of its size +constraint and so the step effect is quite noticeable in a time versus +size graph. + + The threshold determinations currently measure at the mid-points of +size steps, but this is sub-optimal since at the start of a new step it +can happen that it's better to go back to the previous k for a while. +Something more sophisticated for `MUL_FFT_TABLE' and `SQR_FFT_TABLE' +will be needed. + + +File: gmp.info, Node: Other Multiplication, Next: Unbalanced Multiplication, Prev: FFT Multiplication, Up: Multiplication Algorithms + +16.1.6 Other Multiplication +--------------------------- + +The Toom algorithms described above (*note Toom 3-Way Multiplication::, +*note Toom 4-Way Multiplication::) generalizes to split into an +arbitrary number of pieces, as per Knuth section 4.3.3 algorithm C. +This is not currently used. The notes here are merely for interest. + + In general a split into r+1 pieces is made, and evaluations and +pointwise multiplications done at 2*r+1 points. A 4-way split does 7 +pointwise multiplies, 5-way does 9, etc. Asymptotically an (r+1)-way +algorithm is O(N^(log(2*r+1)/log(r+1))). Only the pointwise +multiplications count towards big-O complexity, but the time spent in +the evaluate and interpolate stages grows with r and has a significant +practical impact, with the asymptotic advantage of each r realized only +at bigger and bigger sizes. The overheads grow as O(N*r), whereas in +an r=2^k FFT they grow only as O(N*log(r)). + + Knuth algorithm C evaluates at points 0,1,2,...,2*r, but exercise 4 +uses -r,...,0,...,r and the latter saves some small multiplies in the +evaluate stage (or rather trades them for additions), and has a further +saving of nearly half the interpolate steps. The idea is to separate +odd and even final coefficients and then perform algorithm C steps C7 +and C8 on them separately. The divisors at step C7 become j^2 and the +multipliers at C8 become 2*t*j-j^2. + + Splitting odd and even parts through positive and negative points +can be thought of as using -1 as a square root of unity. If a 4th root +of unity was available then a further split and speedup would be +possible, but no such root exists for plain integers. Going to complex +integers with i=sqrt(-1) doesn't help, essentially because in Cartesian +form it takes three real multiplies to do a complex multiply. The +existence of 2^k'th roots of unity in a suitable ring or field lets the +fast Fourier transform keep splitting and get to O(N*log(r)). + + Floating point FFTs use complex numbers approximating Nth roots of +unity. Some processors have special support for such FFTs. But these +are not used in GMP since it's very difficult to guarantee an exact +result (to some number of bits). An occasional difference of 1 in the +last bit might not matter to a typical signal processing algorithm, but +is of course of vital importance to GMP. + + +File: gmp.info, Node: Unbalanced Multiplication, Prev: Other Multiplication, Up: Multiplication Algorithms + +16.1.7 Unbalanced Multiplication +-------------------------------- + +Multiplication of operands with different sizes, both below +`MUL_TOOM22_THRESHOLD' are done with plain schoolbook multiplication +(*note Basecase Multiplication::). + + For really large operands, we invoke FFT directly. + + For operands between these sizes, we use Toom inspired algorithms +suggested by Alberto Zanoni and Marco Bodrato. The idea is to split +the operands into polynomials of different degree. GMP currently +splits the smaller operand onto 2 coefficients, i.e., a polynomial of +degree 1, but the larger operand can be split into 2, 3, or 4 +coefficients, i.e., a polynomial of degree 1 to 3. + + +File: gmp.info, Node: Division Algorithms, Next: Greatest Common Divisor Algorithms, Prev: Multiplication Algorithms, Up: Algorithms + +16.2 Division Algorithms +======================== + +* Menu: + +* Single Limb Division:: +* Basecase Division:: +* Divide and Conquer Division:: +* Block-Wise Barrett Division:: +* Exact Division:: +* Exact Remainder:: +* Small Quotient Division:: + + +File: gmp.info, Node: Single Limb Division, Next: Basecase Division, Prev: Division Algorithms, Up: Division Algorithms + +16.2.1 Single Limb Division +--------------------------- + +Nx1 division is implemented using repeated 2x1 divisions from high to +low, either with a hardware divide instruction or a multiplication by +inverse, whichever is best on a given CPU. + + The multiply by inverse follows "Improved division by invariant +integers" by Mo"ller and Granlund (*note References::) and is +implemented as `udiv_qrnnd_preinv' in `gmp-impl.h'. The idea is to +have a fixed-point approximation to 1/d (see `invert_limb') and then +multiply by the high limb (plus one bit) of the dividend to get a +quotient q. With d normalized (high bit set), q is no more than 1 too +small. Subtracting q*d from the dividend gives a remainder, and +reveals whether q or q-1 is correct. + + The result is a division done with two multiplications and four or +five arithmetic operations. On CPUs with low latency multipliers this +can be much faster than a hardware divide, though the cost of +calculating the inverse at the start may mean it's only better on +inputs bigger than say 4 or 5 limbs. + + When a divisor must be normalized, either for the generic C +`__udiv_qrnnd_c' or the multiply by inverse, the division performed is +actually a*2^k by d*2^k where a is the dividend and k is the power +necessary to have the high bit of d*2^k set. The bit shifts for the +dividend are usually accomplished "on the fly" meaning by extracting +the appropriate bits at each step. Done this way the quotient limbs +come out aligned ready to store. When only the remainder is wanted, an +alternative is to take the dividend limbs unshifted and calculate r = a +mod d*2^k followed by an extra final step r*2^k mod d*2^k. This can +help on CPUs with poor bit shifts or few registers. + + The multiply by inverse can be done two limbs at a time. The +calculation is basically the same, but the inverse is two limbs and the +divisor treated as if padded with a low zero limb. This means more +work, since the inverse will need a 2x2 multiply, but the four 1x1s to +do that are independent and can therefore be done partly or wholly in +parallel. Likewise for a 2x1 calculating q*d. The net effect is to +process two limbs with roughly the same two multiplies worth of latency +that one limb at a time gives. This extends to 3 or 4 limbs at a time, +though the extra work to apply the inverse will almost certainly soon +reach the limits of multiplier throughput. + + A similar approach in reverse can be taken to process just half a +limb at a time if the divisor is only a half limb. In this case the +1x1 multiply for the inverse effectively becomes two (1/2)x1 for each +limb, which can be a saving on CPUs with a fast half limb multiply, or +in fact if the only multiply is a half limb, and especially if it's not +pipelined. + + +File: gmp.info, Node: Basecase Division, Next: Divide and Conquer Division, Prev: Single Limb Division, Up: Division Algorithms + +16.2.2 Basecase Division +------------------------ + +Basecase NxM division is like long division done by hand, but in base +2^mp_bits_per_limb. See Knuth section 4.3.1 algorithm D, and +`mpn/generic/sb_divrem_mn.c'. + + Briefly stated, while the dividend remains larger than the divisor, +a high quotient limb is formed and the Nx1 product q*d subtracted at +the top end of the dividend. With a normalized divisor (most +significant bit set), each quotient limb can be formed with a 2x1 +division and a 1x1 multiplication plus some subtractions. The 2x1 +division is by the high limb of the divisor and is done either with a +hardware divide or a multiply by inverse (the same as in *Note Single +Limb Division::) whichever is faster. Such a quotient is sometimes one +too big, requiring an addback of the divisor, but that happens rarely. + + With Q=N-M being the number of quotient limbs, this is an O(Q*M) +algorithm and will run at a speed similar to a basecase QxM +multiplication, differing in fact only in the extra multiply and divide +for each of the Q quotient limbs. + + +File: gmp.info, Node: Divide and Conquer Division, Next: Block-Wise Barrett Division, Prev: Basecase Division, Up: Division Algorithms + +16.2.3 Divide and Conquer Division +---------------------------------- + +For divisors larger than `DC_DIV_QR_THRESHOLD', division is done by +dividing. Or to be precise by a recursive divide and conquer algorithm +based on work by Moenck and Borodin, Jebelean, and Burnikel and Ziegler +(*note References::). + + The algorithm consists essentially of recognising that a 2NxN +division can be done with the basecase division algorithm (*note +Basecase Division::), but using N/2 limbs as a base, not just a single +limb. This way the multiplications that arise are (N/2)x(N/2) and can +take advantage of Karatsuba and higher multiplication algorithms (*note +Multiplication Algorithms::). The two "digits" of the quotient are +formed by recursive Nx(N/2) divisions. + + If the (N/2)x(N/2) multiplies are done with a basecase multiplication +then the work is about the same as a basecase division, but with more +function call overheads and with some subtractions separated from the +multiplies. These overheads mean that it's only when N/2 is above +`MUL_TOOM22_THRESHOLD' that divide and conquer is of use. + + `DC_DIV_QR_THRESHOLD' is based on the divisor size N, so it will be +somewhere above twice `MUL_TOOM22_THRESHOLD', but how much above +depends on the CPU. An optimized `mpn_mul_basecase' can lower +`DC_DIV_QR_THRESHOLD' a little by offering a ready-made advantage over +repeated `mpn_submul_1' calls. + + Divide and conquer is asymptotically O(M(N)*log(N)) where M(N) is +the time for an NxN multiplication done with FFTs. The actual time is +a sum over multiplications of the recursed sizes, as can be seen near +the end of section 2.2 of Burnikel and Ziegler. For example, within +the Toom-3 range, divide and conquer is 2.63*M(N). With higher +algorithms the M(N) term improves and the multiplier tends to log(N). +In practice, at moderate to large sizes, a 2NxN division is about 2 to +4 times slower than an NxN multiplication. + + +File: gmp.info, Node: Block-Wise Barrett Division, Next: Exact Division, Prev: Divide and Conquer Division, Up: Division Algorithms + +16.2.4 Block-Wise Barrett Division +---------------------------------- + +For the largest divisions, a block-wise Barrett division algorithm is +used. Here, the divisor is inverted to a precision determined by the +relative size of the dividend and divisor. Blocks of quotient limbs +are then generated by multiplying blocks from the dividend by the +inverse. + + Our block-wise algorithm computes a smaller inverse than in the +plain Barrett algorithm. For a 2n/n division, the inverse will be just +ceil(n/2) limbs. + + +File: gmp.info, Node: Exact Division, Next: Exact Remainder, Prev: Block-Wise Barrett Division, Up: Division Algorithms + +16.2.5 Exact Division +--------------------- + +A so-called exact division is when the dividend is known to be an exact +multiple of the divisor. Jebelean's exact division algorithm uses this +knowledge to make some significant optimizations (*note References::). + + The idea can be illustrated in decimal for example with 368154 +divided by 543. Because the low digit of the dividend is 4, the low +digit of the quotient must be 8. This is arrived at from 4*7 mod 10, +using the fact 7 is the modular inverse of 3 (the low digit of the +divisor), since 3*7 == 1 mod 10. So 8*543=4344 can be subtracted from +the dividend leaving 363810. Notice the low digit has become zero. + + The procedure is repeated at the second digit, with the next +quotient digit 7 (7 == 1*7 mod 10), subtracting 7*543=3801, leaving +325800. And finally at the third digit with quotient digit 6 (8*7 mod +10), subtracting 6*543=3258 leaving 0. So the quotient is 678. + + Notice however that the multiplies and subtractions don't need to +extend past the low three digits of the dividend, since that's enough +to determine the three quotient digits. For the last quotient digit no +subtraction is needed at all. On a 2NxN division like this one, only +about half the work of a normal basecase division is necessary. + + For an NxM exact division producing Q=N-M quotient limbs, the saving +over a normal basecase division is in two parts. Firstly, each of the +Q quotient limbs needs only one multiply, not a 2x1 divide and +multiply. Secondly, the crossproducts are reduced when Q>M to +Q*M-M*(M+1)/2, or when Q<=M to Q*(Q-1)/2. Notice the savings are +complementary. If Q is big then many divisions are saved, or if Q is +small then the crossproducts reduce to a small number. + + The modular inverse used is calculated efficiently by `binvert_limb' +in `gmp-impl.h'. This does four multiplies for a 32-bit limb, or six +for a 64-bit limb. `tune/modlinv.c' has some alternate implementations +that might suit processors better at bit twiddling than multiplying. + + The sub-quadratic exact division described by Jebelean in "Exact +Division with Karatsuba Complexity" is not currently implemented. It +uses a rearrangement similar to the divide and conquer for normal +division (*note Divide and Conquer Division::), but operating from low +to high. A further possibility not currently implemented is +"Bidirectional Exact Integer Division" by Krandick and Jebelean which +forms quotient limbs from both the high and low ends of the dividend, +and can halve once more the number of crossproducts needed in a 2NxN +division. + + A special case exact division by 3 exists in `mpn_divexact_by3', +supporting Toom-3 multiplication and `mpq' canonicalizations. It forms +quotient digits with a multiply by the modular inverse of 3 (which is +`0xAA..AAB') and uses two comparisons to determine a borrow for the next +limb. The multiplications don't need to be on the dependent chain, as +long as the effect of the borrows is applied, which can help chips with +pipelined multipliers. + + +File: gmp.info, Node: Exact Remainder, Next: Small Quotient Division, Prev: Exact Division, Up: Division Algorithms + +16.2.6 Exact Remainder +---------------------- + +If the exact division algorithm is done with a full subtraction at each +stage and the dividend isn't a multiple of the divisor, then low zero +limbs are produced but with a remainder in the high limbs. For +dividend a, divisor d, quotient q, and b = 2^mp_bits_per_limb, this +remainder r is of the form + + a = q*d + r*b^n + + n represents the number of zero limbs produced by the subtractions, +that being the number of limbs produced for q. r will be in the range +0<=rb*r+u2 condition appropriately relaxed. + + +File: gmp.info, Node: Greatest Common Divisor Algorithms, Next: Powering Algorithms, Prev: Division Algorithms, Up: Algorithms + +16.3 Greatest Common Divisor +============================ + +* Menu: + +* Binary GCD:: +* Lehmer's Algorithm:: +* Subquadratic GCD:: +* Extended GCD:: +* Jacobi Symbol:: + + +File: gmp.info, Node: Binary GCD, Next: Lehmer's Algorithm, Prev: Greatest Common Divisor Algorithms, Up: Greatest Common Divisor Algorithms + +16.3.1 Binary GCD +----------------- + +At small sizes GMP uses an O(N^2) binary style GCD. This is described +in many textbooks, for example Knuth section 4.5.2 algorithm B. It +simply consists of successively reducing odd operands a and b using + + a,b = abs(a-b),min(a,b) + strip factors of 2 from a + + The Euclidean GCD algorithm, as per Knuth algorithms E and A, +repeatedly computes the quotient q = floor(a/b) and replaces a,b by v, +u - q v. The binary algorithm has so far been found to be faster than +the Euclidean algorithm everywhere. One reason the binary method does +well is that the implied quotient at each step is usually small, so +often only one or two subtractions are needed to get the same effect as +a division. Quotients 1, 2 and 3 for example occur 67.7% of the time, +see Knuth section 4.5.3 Theorem E. + + When the implied quotient is large, meaning b is much smaller than +a, then a division is worthwhile. This is the basis for the initial a +mod b reductions in `mpn_gcd' and `mpn_gcd_1' (the latter for both Nx1 +and 1x1 cases). But after that initial reduction, big quotients occur +too rarely to make it worth checking for them. + + + The final 1x1 GCD in `mpn_gcd_1' is done in the generic C code as +described above. For two N-bit operands, the algorithm takes about +0.68 iterations per bit. For optimum performance some attention needs +to be paid to the way the factors of 2 are stripped from a. + + Firstly it may be noted that in twos complement the number of low +zero bits on a-b is the same as b-a, so counting or testing can begin on +a-b without waiting for abs(a-b) to be determined. + + A loop stripping low zero bits tends not to branch predict well, +since the condition is data dependent. But on average there's only a +few low zeros, so an option is to strip one or two bits arithmetically +then loop for more (as done for AMD K6). Or use a lookup table to get +a count for several bits then loop for more (as done for AMD K7). An +alternative approach is to keep just one of a or b odd and iterate + + a,b = abs(a-b), min(a,b) + a = a/2 if even + b = b/2 if even + + This requires about 1.25 iterations per bit, but stripping of a +single bit at each step avoids any branching. Repeating the bit strip +reduces to about 0.9 iterations per bit, which may be a worthwhile +tradeoff. + + Generally with the above approaches a speed of perhaps 6 cycles per +bit can be achieved, which is still not terribly fast with for instance +a 64-bit GCD taking nearly 400 cycles. It's this sort of time which +means it's not usually advantageous to combine a set of divisibility +tests into a GCD. + + Currently, the binary algorithm is used for GCD only when N < 3. + + +File: gmp.info, Node: Lehmer's Algorithm, Next: Subquadratic GCD, Prev: Binary GCD, Up: Greatest Common Divisor Algorithms + +16.3.2 Lehmer's algorithm +------------------------- + +Lehmer's improvement of the Euclidean algorithms is based on the +observation that the initial part of the quotient sequence depends only +on the most significant parts of the inputs. The variant of Lehmer's +algorithm used in GMP splits off the most significant two limbs, as +suggested, e.g., in "A Double-Digit Lehmer-Euclid Algorithm" by +Jebelean (*note References::). The quotients of two double-limb inputs +are collected as a 2 by 2 matrix with single-limb elements. This is +done by the function `mpn_hgcd2'. The resulting matrix is applied to +the inputs using `mpn_mul_1' and `mpn_submul_1'. Each iteration usually +reduces the inputs by almost one limb. In the rare case of a large +quotient, no progress can be made by examining just the most +significant two limbs, and the quotient is computing using plain +division. + + The resulting algorithm is asymptotically O(N^2), just as the +Euclidean algorithm and the binary algorithm. The quadratic part of the +work are the calls to `mpn_mul_1' and `mpn_submul_1'. For small sizes, +the linear work is also significant. There are roughly N calls to the +`mpn_hgcd2' function. This function uses a couple of important +optimizations: + + * It uses the same relaxed notion of correctness as `mpn_hgcd' (see + next section). This means that when called with the most + significant two limbs of two large numbers, the returned matrix + does not always correspond exactly to the initial quotient + sequence for the two large numbers; the final quotient may + sometimes be one off. + + * It takes advantage of the fact the quotients are usually small. + The division operator is not used, since the corresponding + assembler instruction is very slow on most architectures. (This + code could probably be improved further, it uses many branches + that are unfriendly to prediction). + + * It switches from double-limb calculations to single-limb + calculations half-way through, when the input numbers have been + reduced in size from two limbs to one and a half. + + + +File: gmp.info, Node: Subquadratic GCD, Next: Extended GCD, Prev: Lehmer's Algorithm, Up: Greatest Common Divisor Algorithms + +16.3.3 Subquadratic GCD +----------------------- + +For inputs larger than `GCD_DC_THRESHOLD', GCD is computed via the HGCD +(Half GCD) function, as a generalization to Lehmer's algorithm. + + Let the inputs a,b be of size N limbs each. Put S = floor(N/2) + 1. +Then HGCD(a,b) returns a transformation matrix T with non-negative +elements, and reduced numbers (c;d) = T^-1 (a;b). The reduced numbers +c,d must be larger than S limbs, while their difference abs(c-d) must +fit in S limbs. The matrix elements will also be of size roughly N/2. + + The HGCD base case uses Lehmer's algorithm, but with the above stop +condition that returns reduced numbers and the corresponding +transformation matrix half-way through. For inputs larger than +`HGCD_THRESHOLD', HGCD is computed recursively, using the divide and +conquer algorithm in "On Scho"nhage's algorithm and subquadratic +integer GCD computation" by Mo"ller (*note References::). The recursive +algorithm consists of these main steps. + + * Call HGCD recursively, on the most significant N/2 limbs. Apply the + resulting matrix T_1 to the full numbers, reducing them to a size + just above 3N/2. + + * Perform a small number of division or subtraction steps to reduce + the numbers to size below 3N/2. This is essential mainly for the + unlikely case of large quotients. + + * Call HGCD recursively, on the most significant N/2 limbs of the + reduced numbers. Apply the resulting matrix T_2 to the full + numbers, reducing them to a size just above N/2. + + * Compute T = T_1 T_2. + + * Perform a small number of division and subtraction steps to + satisfy the requirements, and return. + + GCD is then implemented as a loop around HGCD, similarly to Lehmer's +algorithm. Where Lehmer repeatedly chops off the top two limbs, calls +`mpn_hgcd2', and applies the resulting matrix to the full numbers, the +subquadratic GCD chops off the most significant third of the limbs (the +proportion is a tuning parameter, and 1/3 seems to be more efficient +than, e.g, 1/2), calls `mpn_hgcd', and applies the resulting matrix. +Once the input numbers are reduced to size below `GCD_DC_THRESHOLD', +Lehmer's algorithm is used for the rest of the work. + + The asymptotic running time of both HGCD and GCD is O(M(N)*log(N)), +where M(N) is the time for multiplying two N-limb numbers. + + +File: gmp.info, Node: Extended GCD, Next: Jacobi Symbol, Prev: Subquadratic GCD, Up: Greatest Common Divisor Algorithms + +16.3.4 Extended GCD +------------------- + +The extended GCD function, or GCDEXT, calculates gcd(a,b) and also +cofactors x and y satisfying a*x+b*y=gcd(a,b). All the algorithms used +for plain GCD are extended to handle this case. The binary algorithm is +used only for single-limb GCDEXT. Lehmer's algorithm is used for sizes +up to `GCDEXT_DC_THRESHOLD'. Above this threshold, GCDEXT is +implemented as a loop around HGCD, but with more book-keeping to keep +track of the cofactors. This gives the same asymptotic running time as +for GCD and HGCD, O(M(N)*log(N)) + + One difference to plain GCD is that while the inputs a and b are +reduced as the algorithm proceeds, the cofactors x and y grow in size. +This makes the tuning of the chopping-point more difficult. The current +code chops off the most significant half of the inputs for the call to +HGCD in the first iteration, and the most significant two thirds for +the remaining calls. This strategy could surely be improved. Also the +stop condition for the loop, where Lehmer's algorithm is invoked once +the inputs are reduced below `GCDEXT_DC_THRESHOLD', could maybe be +improved by taking into account the current size of the cofactors. + + +File: gmp.info, Node: Jacobi Symbol, Prev: Extended GCD, Up: Greatest Common Divisor Algorithms + +16.3.5 Jacobi Symbol +-------------------- + +`mpz_jacobi' and `mpz_kronecker' are currently implemented with a +simple binary algorithm similar to that described for the GCDs (*note +Binary GCD::). They're not very fast when both inputs are large. +Lehmer's multi-step improvement or a binary based multi-step algorithm +is likely to be better. + + When one operand fits a single limb, and that includes +`mpz_kronecker_ui' and friends, an initial reduction is done with +either `mpn_mod_1' or `mpn_modexact_1_odd', followed by the binary +algorithm on a single limb. The binary algorithm is well suited to a +single limb, and the whole calculation in this case is quite efficient. + + In all the routines sign changes for the result are accumulated +using some bit twiddling, avoiding table lookups or conditional jumps. + diff --git a/misc/builddeps/dp.win64/share/info/gmp.info-2 b/misc/builddeps/dp.win64/share/info/gmp.info-2 new file mode 100644 index 00000000..45846232 --- /dev/null +++ b/misc/builddeps/dp.win64/share/info/gmp.info-2 @@ -0,0 +1,3489 @@ +This is ../../gmp/doc/gmp.info, produced by makeinfo version 4.8 from +../../gmp/doc/gmp.texi. + + This manual describes how to install and use the GNU multiple +precision arithmetic library, version 5.0.1. + + Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, +2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free +Software Foundation, Inc. + + Permission is granted to copy, distribute and/or modify this +document under the terms of the GNU Free Documentation License, Version +1.3 or any later version published by the Free Software Foundation; +with no Invariant Sections, with the Front-Cover Texts being "A GNU +Manual", and with the Back-Cover Texts being "You have freedom to copy +and modify this GNU Manual, like GNU software". A copy of the license +is included in *Note GNU Free Documentation License::. + +INFO-DIR-SECTION GNU libraries +START-INFO-DIR-ENTRY +* gmp: (gmp). GNU Multiple Precision Arithmetic Library. +END-INFO-DIR-ENTRY + + +File: gmp.info, Node: Powering Algorithms, Next: Root Extraction Algorithms, Prev: Greatest Common Divisor Algorithms, Up: Algorithms + +16.4 Powering Algorithms +======================== + +* Menu: + +* Normal Powering Algorithm:: +* Modular Powering Algorithm:: + + +File: gmp.info, Node: Normal Powering Algorithm, Next: Modular Powering Algorithm, Prev: Powering Algorithms, Up: Powering Algorithms + +16.4.1 Normal Powering +---------------------- + +Normal `mpz' or `mpf' powering uses a simple binary algorithm, +successively squaring and then multiplying by the base when a 1 bit is +seen in the exponent, as per Knuth section 4.6.3. The "left to right" +variant described there is used rather than algorithm A, since it's +just as easy and can be done with somewhat less temporary memory. + + +File: gmp.info, Node: Modular Powering Algorithm, Prev: Normal Powering Algorithm, Up: Powering Algorithms + +16.4.2 Modular Powering +----------------------- + +Modular powering is implemented using a 2^k-ary sliding window +algorithm, as per "Handbook of Applied Cryptography" algorithm 14.85 +(*note References::). k is chosen according to the size of the +exponent. Larger exponents use larger values of k, the choice being +made to minimize the average number of multiplications that must +supplement the squaring. + + The modular multiplies and squares use either a simple division or +the REDC method by Montgomery (*note References::). REDC is a little +faster, essentially saving N single limb divisions in a fashion similar +to an exact remainder (*note Exact Remainder::). + + +File: gmp.info, Node: Root Extraction Algorithms, Next: Radix Conversion Algorithms, Prev: Powering Algorithms, Up: Algorithms + +16.5 Root Extraction Algorithms +=============================== + +* Menu: + +* Square Root Algorithm:: +* Nth Root Algorithm:: +* Perfect Square Algorithm:: +* Perfect Power Algorithm:: + + +File: gmp.info, Node: Square Root Algorithm, Next: Nth Root Algorithm, Prev: Root Extraction Algorithms, Up: Root Extraction Algorithms + +16.5.1 Square Root +------------------ + +Square roots are taken using the "Karatsuba Square Root" algorithm by +Paul Zimmermann (*note References::). + + An input n is split into four parts of k bits each, so with b=2^k we +have n = a3*b^3 + a2*b^2 + a1*b + a0. Part a3 must be "normalized" so +that either the high or second highest bit is set. In GMP, k is kept +on a limb boundary and the input is left shifted (by an even number of +bits) to normalize. + + The square root of the high two parts is taken, by recursive +application of the algorithm (bottoming out in a one-limb Newton's +method), + + s1,r1 = sqrtrem (a3*b + a2) + + This is an approximation to the desired root and is extended by a +division to give s,r, + + q,u = divrem (r1*b + a1, 2*s1) + s = s1*b + q + r = u*b + a0 - q^2 + + The normalization requirement on a3 means at this point s is either +correct or 1 too big. r is negative in the latter case, so + + if r < 0 then + r = r + 2*s - 1 + s = s - 1 + + The algorithm is expressed in a divide and conquer form, but as +noted in the paper it can also be viewed as a discrete variant of +Newton's method, or as a variation on the schoolboy method (no longer +taught) for square roots two digits at a time. + + If the remainder r is not required then usually only a few high limbs +of r and u need to be calculated to determine whether an adjustment to +s is required. This optimization is not currently implemented. + + In the Karatsuba multiplication range this algorithm is +O(1.5*M(N/2)), where M(n) is the time to multiply two numbers of n +limbs. In the FFT multiplication range this grows to a bound of +O(6*M(N/2)). In practice a factor of about 1.5 to 1.8 is found in the +Karatsuba and Toom-3 ranges, growing to 2 or 3 in the FFT range. + + The algorithm does all its calculations in integers and the resulting +`mpn_sqrtrem' is used for both `mpz_sqrt' and `mpf_sqrt'. The extended +precision given by `mpf_sqrt_ui' is obtained by padding with zero limbs. + + +File: gmp.info, Node: Nth Root Algorithm, Next: Perfect Square Algorithm, Prev: Square Root Algorithm, Up: Root Extraction Algorithms + +16.5.2 Nth Root +--------------- + +Integer Nth roots are taken using Newton's method with the following +iteration, where A is the input and n is the root to be taken. + + 1 A + a[i+1] = - * ( --------- + (n-1)*a[i] ) + n a[i]^(n-1) + + The initial approximation a[1] is generated bitwise by successively +powering a trial root with or without new 1 bits, aiming to be just +above the true root. The iteration converges quadratically when +started from a good approximation. When n is large more initial bits +are needed to get good convergence. The current implementation is not +particularly well optimized. + + +File: gmp.info, Node: Perfect Square Algorithm, Next: Perfect Power Algorithm, Prev: Nth Root Algorithm, Up: Root Extraction Algorithms + +16.5.3 Perfect Square +--------------------- + +A significant fraction of non-squares can be quickly identified by +checking whether the input is a quadratic residue modulo small integers. + + `mpz_perfect_square_p' first tests the input mod 256, which means +just examining the low byte. Only 44 different values occur for +squares mod 256, so 82.8% of inputs can be immediately identified as +non-squares. + + On a 32-bit system similar tests are done mod 9, 5, 7, 13 and 17, +for a total 99.25% of inputs identified as non-squares. On a 64-bit +system 97 is tested too, for a total 99.62%. + + These moduli are chosen because they're factors of 2^24-1 (or 2^48-1 +for 64-bits), and such a remainder can be quickly taken just using +additions (see `mpn_mod_34lsub1'). + + When nails are in use moduli are instead selected by the `gen-psqr.c' +program and applied with an `mpn_mod_1'. The same 2^24-1 or 2^48-1 +could be done with nails using some extra bit shifts, but this is not +currently implemented. + + In any case each modulus is applied to the `mpn_mod_34lsub1' or +`mpn_mod_1' remainder and a table lookup identifies non-squares. By +using a "modexact" style calculation, and suitably permuted tables, +just one multiply each is required, see the code for details. Moduli +are also combined to save operations, so long as the lookup tables +don't become too big. `gen-psqr.c' does all the pre-calculations. + + A square root must still be taken for any value that passes these +tests, to verify it's really a square and not one of the small fraction +of non-squares that get through (ie. a pseudo-square to all the tested +bases). + + Clearly more residue tests could be done, `mpz_perfect_square_p' only +uses a compact and efficient set. Big inputs would probably benefit +from more residue testing, small inputs might be better off with less. +The assumed distribution of squares versus non-squares in the input +would affect such considerations. + + +File: gmp.info, Node: Perfect Power Algorithm, Prev: Perfect Square Algorithm, Up: Root Extraction Algorithms + +16.5.4 Perfect Power +-------------------- + +Detecting perfect powers is required by some factorization algorithms. +Currently `mpz_perfect_power_p' is implemented using repeated Nth root +extractions, though naturally only prime roots need to be considered. +(*Note Nth Root Algorithm::.) + + If a prime divisor p with multiplicity e can be found, then only +roots which are divisors of e need to be considered, much reducing the +work necessary. To this end divisibility by a set of small primes is +checked. + + +File: gmp.info, Node: Radix Conversion Algorithms, Next: Other Algorithms, Prev: Root Extraction Algorithms, Up: Algorithms + +16.6 Radix Conversion +===================== + +Radix conversions are less important than other algorithms. A program +dominated by conversions should probably use a different data +representation. + +* Menu: + +* Binary to Radix:: +* Radix to Binary:: + + +File: gmp.info, Node: Binary to Radix, Next: Radix to Binary, Prev: Radix Conversion Algorithms, Up: Radix Conversion Algorithms + +16.6.1 Binary to Radix +---------------------- + +Conversions from binary to a power-of-2 radix use a simple and fast +O(N) bit extraction algorithm. + + Conversions from binary to other radices use one of two algorithms. +Sizes below `GET_STR_PRECOMPUTE_THRESHOLD' use a basic O(N^2) method. +Repeated divisions by b^n are made, where b is the radix and n is the +biggest power that fits in a limb. But instead of simply using the +remainder r from such divisions, an extra divide step is done to give a +fractional limb representing r/b^n. The digits of r can then be +extracted using multiplications by b rather than divisions. Special +case code is provided for decimal, allowing multiplications by 10 to +optimize to shifts and adds. + + Above `GET_STR_PRECOMPUTE_THRESHOLD' a sub-quadratic algorithm is +used. For an input t, powers b^(n*2^i) of the radix are calculated, +until a power between t and sqrt(t) is reached. t is then divided by +that largest power, giving a quotient which is the digits above that +power, and a remainder which is those below. These two parts are in +turn divided by the second highest power, and so on recursively. When +a piece has been divided down to less than `GET_STR_DC_THRESHOLD' +limbs, the basecase algorithm described above is used. + + The advantage of this algorithm is that big divisions can make use +of the sub-quadratic divide and conquer division (*note Divide and +Conquer Division::), and big divisions tend to have less overheads than +lots of separate single limb divisions anyway. But in any case the +cost of calculating the powers b^(n*2^i) must first be overcome. + + `GET_STR_PRECOMPUTE_THRESHOLD' and `GET_STR_DC_THRESHOLD' represent +the same basic thing, the point where it becomes worth doing a big +division to cut the input in half. `GET_STR_PRECOMPUTE_THRESHOLD' +includes the cost of calculating the radix power required, whereas +`GET_STR_DC_THRESHOLD' assumes that's already available, which is the +case when recursing. + + Since the base case produces digits from least to most significant +but they want to be stored from most to least, it's necessary to +calculate in advance how many digits there will be, or at least be sure +not to underestimate that. For GMP the number of input bits is +multiplied by `chars_per_bit_exactly' from `mp_bases', rounding up. +The result is either correct or one too big. + + Examining some of the high bits of the input could increase the +chance of getting the exact number of digits, but an exact result every +time would not be practical, since in general the difference between +numbers 100... and 99... is only in the last few bits and the work to +identify 99... might well be almost as much as a full conversion. + + `mpf_get_str' doesn't currently use the algorithm described here, it +multiplies or divides by a power of b to move the radix point to the +just above the highest non-zero digit (or at worst one above that +location), then multiplies by b^n to bring out digits. This is O(N^2) +and is certainly not optimal. + + The r/b^n scheme described above for using multiplications to bring +out digits might be useful for more than a single limb. Some brief +experiments with it on the base case when recursing didn't give a +noticeable improvement, but perhaps that was only due to the +implementation. Something similar would work for the sub-quadratic +divisions too, though there would be the cost of calculating a bigger +radix power. + + Another possible improvement for the sub-quadratic part would be to +arrange for radix powers that balanced the sizes of quotient and +remainder produced, ie. the highest power would be an b^(n*k) +approximately equal to sqrt(t), not restricted to a 2^i factor. That +ought to smooth out a graph of times against sizes, but may or may not +be a net speedup. + + +File: gmp.info, Node: Radix to Binary, Prev: Binary to Radix, Up: Radix Conversion Algorithms + +16.6.2 Radix to Binary +---------------------- + +*This section needs to be rewritten, it currently describes the +algorithms used before GMP 4.3.* + + Conversions from a power-of-2 radix into binary use a simple and fast +O(N) bitwise concatenation algorithm. + + Conversions from other radices use one of two algorithms. Sizes +below `SET_STR_PRECOMPUTE_THRESHOLD' use a basic O(N^2) method. Groups +of n digits are converted to limbs, where n is the biggest power of the +base b which will fit in a limb, then those groups are accumulated into +the result by multiplying by b^n and adding. This saves +multi-precision operations, as per Knuth section 4.4 part E (*note +References::). Some special case code is provided for decimal, giving +the compiler a chance to optimize multiplications by 10. + + Above `SET_STR_PRECOMPUTE_THRESHOLD' a sub-quadratic algorithm is +used. First groups of n digits are converted into limbs. Then adjacent +limbs are combined into limb pairs with x*b^n+y, where x and y are the +limbs. Adjacent limb pairs are combined into quads similarly with +x*b^(2n)+y. This continues until a single block remains, that being +the result. + + The advantage of this method is that the multiplications for each x +are big blocks, allowing Karatsuba and higher algorithms to be used. +But the cost of calculating the powers b^(n*2^i) must be overcome. +`SET_STR_PRECOMPUTE_THRESHOLD' usually ends up quite big, around 5000 +digits, and on some processors much bigger still. + + `SET_STR_PRECOMPUTE_THRESHOLD' is based on the input digits (and +tuned for decimal), though it might be better based on a limb count, so +as to be independent of the base. But that sort of count isn't used by +the base case and so would need some sort of initial calculation or +estimate. + + The main reason `SET_STR_PRECOMPUTE_THRESHOLD' is so much bigger +than the corresponding `GET_STR_PRECOMPUTE_THRESHOLD' is that +`mpn_mul_1' is much faster than `mpn_divrem_1' (often by a factor of 5, +or more). + + +File: gmp.info, Node: Other Algorithms, Next: Assembly Coding, Prev: Radix Conversion Algorithms, Up: Algorithms + +16.7 Other Algorithms +===================== + +* Menu: + +* Prime Testing Algorithm:: +* Factorial Algorithm:: +* Binomial Coefficients Algorithm:: +* Fibonacci Numbers Algorithm:: +* Lucas Numbers Algorithm:: +* Random Number Algorithms:: + + +File: gmp.info, Node: Prime Testing Algorithm, Next: Factorial Algorithm, Prev: Other Algorithms, Up: Other Algorithms + +16.7.1 Prime Testing +-------------------- + +The primality testing in `mpz_probab_prime_p' (*note Number Theoretic +Functions::) first does some trial division by small factors and then +uses the Miller-Rabin probabilistic primality testing algorithm, as +described in Knuth section 4.5.4 algorithm P (*note References::). + + For an odd input n, and with n = q*2^k+1 where q is odd, this +algorithm selects a random base x and tests whether x^q mod n is 1 or +-1, or an x^(q*2^j) mod n is 1, for 1<=j<=k. If so then n is probably +prime, if not then n is definitely composite. + + Any prime n will pass the test, but some composites do too. Such +composites are known as strong pseudoprimes to base x. No n is a +strong pseudoprime to more than 1/4 of all bases (see Knuth exercise +22), hence with x chosen at random there's no more than a 1/4 chance a +"probable prime" will in fact be composite. + + In fact strong pseudoprimes are quite rare, making the test much more +powerful than this analysis would suggest, but 1/4 is all that's proven +for an arbitrary n. + + +File: gmp.info, Node: Factorial Algorithm, Next: Binomial Coefficients Algorithm, Prev: Prime Testing Algorithm, Up: Other Algorithms + +16.7.2 Factorial +---------------- + +Factorials are calculated by a combination of removal of twos, +powering, and binary splitting. The procedure can be best illustrated +with an example, + + 23! = 1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23 + +has factors of two removed, + + 23! = 2^19.1.1.3.1.5.3.7.1.9.5.11.3.13.7.15.1.17.9.19.5.21.11.23 + +and the resulting terms collected up according to their multiplicity, + + 23! = 2^19.(3.5)^3.(7.9.11)^2.(13.15.17.19.21.23) + + Each sequence such as 13.15.17.19.21.23 is evaluated by splitting +into every second term, as for instance (13.17.21).(15.19.23), and the +same recursively on each half. This is implemented iteratively using +some bit twiddling. + + Such splitting is more efficient than repeated Nx1 multiplies since +it forms big multiplies, allowing Karatsuba and higher algorithms to be +used. And even below the Karatsuba threshold a big block of work can +be more efficient for the basecase algorithm. + + Splitting into subsequences of every second term keeps the resulting +products more nearly equal in size than would the simpler approach of +say taking the first half and second half of the sequence. Nearly +equal products are more efficient for the current multiply +implementation. + + +File: gmp.info, Node: Binomial Coefficients Algorithm, Next: Fibonacci Numbers Algorithm, Prev: Factorial Algorithm, Up: Other Algorithms + +16.7.3 Binomial Coefficients +---------------------------- + +Binomial coefficients C(n,k) are calculated by first arranging k <= n/2 +using C(n,k) = C(n,n-k) if necessary, and then evaluating the following +product simply from i=2 to i=k. + + k (n-k+i) + C(n,k) = (n-k+1) * prod ------- + i=2 i + + It's easy to show that each denominator i will divide the product so +far, so the exact division algorithm is used (*note Exact Division::). + + The numerators n-k+i and denominators i are first accumulated into +as many fit a limb, to save multi-precision operations, though for +`mpz_bin_ui' this applies only to the divisors, since n is an `mpz_t' +and n-k+i in general won't fit in a limb at all. + + +File: gmp.info, Node: Fibonacci Numbers Algorithm, Next: Lucas Numbers Algorithm, Prev: Binomial Coefficients Algorithm, Up: Other Algorithms + +16.7.4 Fibonacci Numbers +------------------------ + +The Fibonacci functions `mpz_fib_ui' and `mpz_fib2_ui' are designed for +calculating isolated F[n] or F[n],F[n-1] values efficiently. + + For small n, a table of single limb values in `__gmp_fib_table' is +used. On a 32-bit limb this goes up to F[47], or on a 64-bit limb up +to F[93]. For convenience the table starts at F[-1]. + + Beyond the table, values are generated with a binary powering +algorithm, calculating a pair F[n] and F[n-1] working from high to low +across the bits of n. The formulas used are + + F[2k+1] = 4*F[k]^2 - F[k-1]^2 + 2*(-1)^k + F[2k-1] = F[k]^2 + F[k-1]^2 + + F[2k] = F[2k+1] - F[2k-1] + + At each step, k is the high b bits of n. If the next bit of n is 0 +then F[2k],F[2k-1] is used, or if it's a 1 then F[2k+1],F[2k] is used, +and the process repeated until all bits of n are incorporated. Notice +these formulas require just two squares per bit of n. + + It'd be possible to handle the first few n above the single limb +table with simple additions, using the defining Fibonacci recurrence +F[k+1]=F[k]+F[k-1], but this is not done since it usually turns out to +be faster for only about 10 or 20 values of n, and including a block of +code for just those doesn't seem worthwhile. If they really mattered +it'd be better to extend the data table. + + Using a table avoids lots of calculations on small numbers, and +makes small n go fast. A bigger table would make more small n go fast, +it's just a question of balancing size against desired speed. For GMP +the code is kept compact, with the emphasis primarily on a good +powering algorithm. + + `mpz_fib2_ui' returns both F[n] and F[n-1], but `mpz_fib_ui' is only +interested in F[n]. In this case the last step of the algorithm can +become one multiply instead of two squares. One of the following two +formulas is used, according as n is odd or even. + + F[2k] = F[k]*(F[k]+2F[k-1]) + + F[2k+1] = (2F[k]+F[k-1])*(2F[k]-F[k-1]) + 2*(-1)^k + + F[2k+1] here is the same as above, just rearranged to be a multiply. +For interest, the 2*(-1)^k term both here and above can be applied +just to the low limb of the calculation, without a carry or borrow into +further limbs, which saves some code size. See comments with +`mpz_fib_ui' and the internal `mpn_fib2_ui' for how this is done. + + +File: gmp.info, Node: Lucas Numbers Algorithm, Next: Random Number Algorithms, Prev: Fibonacci Numbers Algorithm, Up: Other Algorithms + +16.7.5 Lucas Numbers +-------------------- + +`mpz_lucnum2_ui' derives a pair of Lucas numbers from a pair of +Fibonacci numbers with the following simple formulas. + + L[k] = F[k] + 2*F[k-1] + L[k-1] = 2*F[k] - F[k-1] + + `mpz_lucnum_ui' is only interested in L[n], and some work can be +saved. Trailing zero bits on n can be handled with a single square +each. + + L[2k] = L[k]^2 - 2*(-1)^k + + And the lowest 1 bit can be handled with one multiply of a pair of +Fibonacci numbers, similar to what `mpz_fib_ui' does. + + L[2k+1] = 5*F[k-1]*(2*F[k]+F[k-1]) - 4*(-1)^k + + +File: gmp.info, Node: Random Number Algorithms, Prev: Lucas Numbers Algorithm, Up: Other Algorithms + +16.7.6 Random Numbers +--------------------- + +For the `urandomb' functions, random numbers are generated simply by +concatenating bits produced by the generator. As long as the generator +has good randomness properties this will produce well-distributed N bit +numbers. + + For the `urandomm' functions, random numbers in a range 0<=R48 bit pieces is convenient. With +some care though six 21x32->53 bit products can be used, if one of the +lower two 21-bit pieces also uses the sign bit. + + For the `mpn_mul_1' family of functions on a 64-bit machine, the +invariant single limb is split at the start, into 3 or 4 pieces. +Inside the loop, the bignum operand is split into 32-bit pieces. Fast +conversion of these unsigned 32-bit pieces to floating point is highly +machine-dependent. In some cases, reading the data into the integer +unit, zero-extending to 64-bits, then transferring to the floating +point unit back via memory is the only option. + + Converting partial products back to 64-bit limbs is usually best +done as a signed conversion. Since all values are smaller than 2^53, +signed and unsigned are the same, but most processors lack unsigned +conversions. + + + + Here is a diagram showing 16x32 bit products for an `mpn_mul_1' or +`mpn_addmul_1' with a 64-bit limb. The single limb operand V is split +into four 16-bit parts. The multi-limb operand U is split in the loop +into two 32-bit parts. + + +---+---+---+---+ + |v48|v32|v16|v00| V operand + +---+---+---+---+ + + +-------+---+---+ + x | u32 | u00 | U operand (one limb) + +---------------+ + + --------------------------------- + + +-----------+ + | u00 x v00 | p00 48-bit products + +-----------+ + +-----------+ + | u00 x v16 | p16 + +-----------+ + +-----------+ + | u00 x v32 | p32 + +-----------+ + +-----------+ + | u00 x v48 | p48 + +-----------+ + +-----------+ + | u32 x v00 | r32 + +-----------+ + +-----------+ + | u32 x v16 | r48 + +-----------+ + +-----------+ + | u32 x v32 | r64 + +-----------+ + +-----------+ + | u32 x v48 | r80 + +-----------+ + + p32 and r32 can be summed using floating-point addition, and +likewise p48 and r48. p00 and p16 can be summed with r64 and r80 from +the previous iteration. + + For each loop then, four 49-bit quantities are transferred to the +integer unit, aligned as follows, + + |-----64bits----|-----64bits----| + +------------+ + | p00 + r64' | i00 + +------------+ + +------------+ + | p16 + r80' | i16 + +------------+ + +------------+ + | p32 + r32 | i32 + +------------+ + +------------+ + | p48 + r48 | i48 + +------------+ + + The challenge then is to sum these efficiently and add in a carry +limb, generating a low 64-bit result limb and a high 33-bit carry limb +(i48 extends 33 bits into the high half). + + +File: gmp.info, Node: Assembly SIMD Instructions, Next: Assembly Software Pipelining, Prev: Assembly Floating Point, Up: Assembly Coding + +16.8.7 SIMD Instructions +------------------------ + +The single-instruction multiple-data support in current microprocessors +is aimed at signal processing algorithms where each data point can be +treated more or less independently. There's generally not much support +for propagating the sort of carries that arise in GMP. + + SIMD multiplications of say four 16x16 bit multiplies only do as much +work as one 32x32 from GMP's point of view, and need some shifts and +adds besides. But of course if say the SIMD form is fully pipelined +and uses less instruction decoding then it may still be worthwhile. + + On the x86 chips, MMX has so far found a use in `mpn_rshift' and +`mpn_lshift', and is used in a special case for 16-bit multipliers in +the P55 `mpn_mul_1'. SSE2 is used for Pentium 4 `mpn_mul_1', +`mpn_addmul_1', and `mpn_submul_1'. + + +File: gmp.info, Node: Assembly Software Pipelining, Next: Assembly Loop Unrolling, Prev: Assembly SIMD Instructions, Up: Assembly Coding + +16.8.8 Software Pipelining +-------------------------- + +Software pipelining consists of scheduling instructions around the +branch point in a loop. For example a loop might issue a load not for +use in the present iteration but the next, thereby allowing extra +cycles for the data to arrive from memory. + + Naturally this is wanted only when doing things like loads or +multiplies that take several cycles to complete, and only where a CPU +has multiple functional units so that other work can be done in the +meantime. + + A pipeline with several stages will have a data value in progress at +each stage and each loop iteration moves them along one stage. This is +like juggling. + + If the latency of some instruction is greater than the loop time +then it will be necessary to unroll, so one register has a result ready +to use while another (or multiple others) are still in progress. +(*note Assembly Loop Unrolling::). + + +File: gmp.info, Node: Assembly Loop Unrolling, Next: Assembly Writing Guide, Prev: Assembly Software Pipelining, Up: Assembly Coding + +16.8.9 Loop Unrolling +--------------------- + +Loop unrolling consists of replicating code so that several limbs are +processed in each loop. At a minimum this reduces loop overheads by a +corresponding factor, but it can also allow better register usage, for +example alternately using one register combination and then another. +Judicious use of `m4' macros can help avoid lots of duplication in the +source code. + + Any amount of unrolling can be handled with a loop counter that's +decremented by N each time, stopping when the remaining count is less +than the further N the loop will process. Or by subtracting N at the +start, the termination condition becomes when the counter C is less +than 0 (and the count of remaining limbs is C+N). + + Alternately for a power of 2 unroll the loop count and remainder can +be established with a shift and mask. This is convenient if also +making a computed jump into the middle of a large loop. + + The limbs not a multiple of the unrolling can be handled in various +ways, for example + + * A simple loop at the end (or the start) to process the excess. + Care will be wanted that it isn't too much slower than the + unrolled part. + + * A set of binary tests, for example after an 8-limb unrolling, test + for 4 more limbs to process, then a further 2 more or not, and + finally 1 more or not. This will probably take more code space + than a simple loop. + + * A `switch' statement, providing separate code for each possible + excess, for example an 8-limb unrolling would have separate code + for 0 remaining, 1 remaining, etc, up to 7 remaining. This might + take a lot of code, but may be the best way to optimize all cases + in combination with a deep pipelined loop. + + * A computed jump into the middle of the loop, thus making the first + iteration handle the excess. This should make times smoothly + increase with size, which is attractive, but setups for the jump + and adjustments for pointers can be tricky and could become quite + difficult in combination with deep pipelining. + + +File: gmp.info, Node: Assembly Writing Guide, Prev: Assembly Loop Unrolling, Up: Assembly Coding + +16.8.10 Writing Guide +--------------------- + +This is a guide to writing software pipelined loops for processing limb +vectors in assembly. + + First determine the algorithm and which instructions are needed. +Code it without unrolling or scheduling, to make sure it works. On a +3-operand CPU try to write each new value to a new register, this will +greatly simplify later steps. + + Then note for each instruction the functional unit and/or issue port +requirements. If an instruction can use either of two units, like U0 +or U1 then make a category "U0/U1". Count the total using each unit +(or combined unit), and count all instructions. + + Figure out from those counts the best possible loop time. The goal +will be to find a perfect schedule where instruction latencies are +completely hidden. The total instruction count might be the limiting +factor, or perhaps a particular functional unit. It might be possible +to tweak the instructions to help the limiting factor. + + Suppose the loop time is N, then make N issue buckets, with the +final loop branch at the end of the last. Now fill the buckets with +dummy instructions using the functional units desired. Run this to +make sure the intended speed is reached. + + Now replace the dummy instructions with the real instructions from +the slow but correct loop you started with. The first will typically +be a load instruction. Then the instruction using that value is placed +in a bucket an appropriate distance down. Run the loop again, to check +it still runs at target speed. + + Keep placing instructions, frequently measuring the loop. After a +few you will need to wrap around from the last bucket back to the top +of the loop. If you used the new-register for new-value strategy above +then there will be no register conflicts. If not then take care not to +clobber something already in use. Changing registers at this time is +very error prone. + + The loop will overlap two or more of the original loop iterations, +and the computation of one vector element result will be started in one +iteration of the new loop, and completed one or several iterations +later. + + The final step is to create feed-in and wind-down code for the loop. +A good way to do this is to make a copy (or copies) of the loop at the +start and delete those instructions which don't have valid antecedents, +and at the end replicate and delete those whose results are unwanted +(including any further loads). + + The loop will have a minimum number of limbs loaded and processed, +so the feed-in code must test if the request size is smaller and skip +either to a suitable part of the wind-down or to special code for small +sizes. + + +File: gmp.info, Node: Internals, Next: Contributors, Prev: Algorithms, Up: Top + +17 Internals +************ + +*This chapter is provided only for informational purposes and the +various internals described here may change in future GMP releases. +Applications expecting to be compatible with future releases should use +only the documented interfaces described in previous chapters.* + +* Menu: + +* Integer Internals:: +* Rational Internals:: +* Float Internals:: +* Raw Output Internals:: +* C++ Interface Internals:: + + +File: gmp.info, Node: Integer Internals, Next: Rational Internals, Prev: Internals, Up: Internals + +17.1 Integer Internals +====================== + +`mpz_t' variables represent integers using sign and magnitude, in space +dynamically allocated and reallocated. The fields are as follows. + +`_mp_size' + The number of limbs, or the negative of that when representing a + negative integer. Zero is represented by `_mp_size' set to zero, + in which case the `_mp_d' data is unused. + +`_mp_d' + A pointer to an array of limbs which is the magnitude. These are + stored "little endian" as per the `mpn' functions, so `_mp_d[0]' + is the least significant limb and `_mp_d[ABS(_mp_size)-1]' is the + most significant. Whenever `_mp_size' is non-zero, the most + significant limb is non-zero. + + Currently there's always at least one limb allocated, so for + instance `mpz_set_ui' never needs to reallocate, and `mpz_get_ui' + can fetch `_mp_d[0]' unconditionally (though its value is then + only wanted if `_mp_size' is non-zero). + +`_mp_alloc' + `_mp_alloc' is the number of limbs currently allocated at `_mp_d', + and naturally `_mp_alloc >= ABS(_mp_size)'. When an `mpz' routine + is about to (or might be about to) increase `_mp_size', it checks + `_mp_alloc' to see whether there's enough space, and reallocates + if not. `MPZ_REALLOC' is generally used for this. + + The various bitwise logical functions like `mpz_and' behave as if +negative values were twos complement. But sign and magnitude is always +used internally, and necessary adjustments are made during the +calculations. Sometimes this isn't pretty, but sign and magnitude are +best for other routines. + + Some internal temporary variables are setup with `MPZ_TMP_INIT' and +these have `_mp_d' space obtained from `TMP_ALLOC' rather than the +memory allocation functions. Care is taken to ensure that these are +big enough that no reallocation is necessary (since it would have +unpredictable consequences). + + `_mp_size' and `_mp_alloc' are `int', although `mp_size_t' is +usually a `long'. This is done to make the fields just 32 bits on some +64 bits systems, thereby saving a few bytes of data space but still +providing plenty of range. + + +File: gmp.info, Node: Rational Internals, Next: Float Internals, Prev: Integer Internals, Up: Internals + +17.2 Rational Internals +======================= + +`mpq_t' variables represent rationals using an `mpz_t' numerator and +denominator (*note Integer Internals::). + + The canonical form adopted is denominator positive (and non-zero), +no common factors between numerator and denominator, and zero uniquely +represented as 0/1. + + It's believed that casting out common factors at each stage of a +calculation is best in general. A GCD is an O(N^2) operation so it's +better to do a few small ones immediately than to delay and have to do +a big one later. Knowing the numerator and denominator have no common +factors can be used for example in `mpq_mul' to make only two cross +GCDs necessary, not four. + + This general approach to common factors is badly sub-optimal in the +presence of simple factorizations or little prospect for cancellation, +but GMP has no way to know when this will occur. As per *Note +Efficiency::, that's left to applications. The `mpq_t' framework might +still suit, with `mpq_numref' and `mpq_denref' for direct access to the +numerator and denominator, or of course `mpz_t' variables can be used +directly. + + +File: gmp.info, Node: Float Internals, Next: Raw Output Internals, Prev: Rational Internals, Up: Internals + +17.3 Float Internals +==================== + +Efficient calculation is the primary aim of GMP floats and the use of +whole limbs and simple rounding facilitates this. + + `mpf_t' floats have a variable precision mantissa and a single +machine word signed exponent. The mantissa is represented using sign +and magnitude. + + most least + significant significant + limb limb + + _mp_d + |---- _mp_exp ---> | + _____ _____ _____ _____ _____ + |_____|_____|_____|_____|_____| + . <------------ radix point + + <-------- _mp_size ---------> + +The fields are as follows. + +`_mp_size' + The number of limbs currently in use, or the negative of that when + representing a negative value. Zero is represented by `_mp_size' + and `_mp_exp' both set to zero, and in that case the `_mp_d' data + is unused. (In the future `_mp_exp' might be undefined when + representing zero.) + +`_mp_prec' + The precision of the mantissa, in limbs. In any calculation the + aim is to produce `_mp_prec' limbs of result (the most significant + being non-zero). + +`_mp_d' + A pointer to the array of limbs which is the absolute value of the + mantissa. These are stored "little endian" as per the `mpn' + functions, so `_mp_d[0]' is the least significant limb and + `_mp_d[ABS(_mp_size)-1]' the most significant. + + The most significant limb is always non-zero, but there are no + other restrictions on its value, in particular the highest 1 bit + can be anywhere within the limb. + + `_mp_prec+1' limbs are allocated to `_mp_d', the extra limb being + for convenience (see below). There are no reallocations during a + calculation, only in a change of precision with `mpf_set_prec'. + +`_mp_exp' + The exponent, in limbs, determining the location of the implied + radix point. Zero means the radix point is just above the most + significant limb. Positive values mean a radix point offset + towards the lower limbs and hence a value >= 1, as for example in + the diagram above. Negative exponents mean a radix point further + above the highest limb. + + Naturally the exponent can be any value, it doesn't have to fall + within the limbs as the diagram shows, it can be a long way above + or a long way below. Limbs other than those included in the + `{_mp_d,_mp_size}' data are treated as zero. + + The `_mp_size' and `_mp_prec' fields are `int', although the +`mp_size_t' type is usually a `long'. The `_mp_exp' field is usually +`long'. This is done to make some fields just 32 bits on some 64 bits +systems, thereby saving a few bytes of data space but still providing +plenty of precision and a very large range. + + +The following various points should be noted. + +Low Zeros + The least significant limbs `_mp_d[0]' etc can be zero, though + such low zeros can always be ignored. Routines likely to produce + low zeros check and avoid them to save time in subsequent + calculations, but for most routines they're quite unlikely and + aren't checked. + +Mantissa Size Range + The `_mp_size' count of limbs in use can be less than `_mp_prec' if + the value can be represented in less. This means low precision + values or small integers stored in a high precision `mpf_t' can + still be operated on efficiently. + + `_mp_size' can also be greater than `_mp_prec'. Firstly a value is + allowed to use all of the `_mp_prec+1' limbs available at `_mp_d', + and secondly when `mpf_set_prec_raw' lowers `_mp_prec' it leaves + `_mp_size' unchanged and so the size can be arbitrarily bigger than + `_mp_prec'. + +Rounding + All rounding is done on limb boundaries. Calculating `_mp_prec' + limbs with the high non-zero will ensure the application requested + minimum precision is obtained. + + The use of simple "trunc" rounding towards zero is efficient, + since there's no need to examine extra limbs and increment or + decrement. + +Bit Shifts + Since the exponent is in limbs, there are no bit shifts in basic + operations like `mpf_add' and `mpf_mul'. When differing exponents + are encountered all that's needed is to adjust pointers to line up + the relevant limbs. + + Of course `mpf_mul_2exp' and `mpf_div_2exp' will require bit + shifts, but the choice is between an exponent in limbs which + requires shifts there, or one in bits which requires them almost + everywhere else. + +Use of `_mp_prec+1' Limbs + The extra limb on `_mp_d' (`_mp_prec+1' rather than just + `_mp_prec') helps when an `mpf' routine might get a carry from its + operation. `mpf_add' for instance will do an `mpn_add' of + `_mp_prec' limbs. If there's no carry then that's the result, but + if there is a carry then it's stored in the extra limb of space and + `_mp_size' becomes `_mp_prec+1'. + + Whenever `_mp_prec+1' limbs are held in a variable, the low limb + is not needed for the intended precision, only the `_mp_prec' high + limbs. But zeroing it out or moving the rest down is unnecessary. + Subsequent routines reading the value will simply take the high + limbs they need, and this will be `_mp_prec' if their target has + that same precision. This is no more than a pointer adjustment, + and must be checked anyway since the destination precision can be + different from the sources. + + Copy functions like `mpf_set' will retain a full `_mp_prec+1' limbs + if available. This ensures that a variable which has `_mp_size' + equal to `_mp_prec+1' will get its full exact value copied. + Strictly speaking this is unnecessary since only `_mp_prec' limbs + are needed for the application's requested precision, but it's + considered that an `mpf_set' from one variable into another of the + same precision ought to produce an exact copy. + +Application Precisions + `__GMPF_BITS_TO_PREC' converts an application requested precision + to an `_mp_prec'. The value in bits is rounded up to a whole limb + then an extra limb is added since the most significant limb of + `_mp_d' is only non-zero and therefore might contain only one bit. + + `__GMPF_PREC_TO_BITS' does the reverse conversion, and removes the + extra limb from `_mp_prec' before converting to bits. The net + effect of reading back with `mpf_get_prec' is simply the precision + rounded up to a multiple of `mp_bits_per_limb'. + + Note that the extra limb added here for the high only being + non-zero is in addition to the extra limb allocated to `_mp_d'. + For example with a 32-bit limb, an application request for 250 + bits will be rounded up to 8 limbs, then an extra added for the + high being only non-zero, giving an `_mp_prec' of 9. `_mp_d' then + gets 10 limbs allocated. Reading back with `mpf_get_prec' will + take `_mp_prec' subtract 1 limb and multiply by 32, giving 256 + bits. + + Strictly speaking, the fact the high limb has at least one bit + means that a float with, say, 3 limbs of 32-bits each will be + holding at least 65 bits, but for the purposes of `mpf_t' it's + considered simply to be 64 bits, a nice multiple of the limb size. + + +File: gmp.info, Node: Raw Output Internals, Next: C++ Interface Internals, Prev: Float Internals, Up: Internals + +17.4 Raw Output Internals +========================= + +`mpz_out_raw' uses the following format. + + +------+------------------------+ + | size | data bytes | + +------+------------------------+ + + The size is 4 bytes written most significant byte first, being the +number of subsequent data bytes, or the twos complement negative of +that when a negative integer is represented. The data bytes are the +absolute value of the integer, written most significant byte first. + + The most significant data byte is always non-zero, so the output is +the same on all systems, irrespective of limb size. + + In GMP 1, leading zero bytes were written to pad the data bytes to a +multiple of the limb size. `mpz_inp_raw' will still accept this, for +compatibility. + + The use of "big endian" for both the size and data fields is +deliberate, it makes the data easy to read in a hex dump of a file. +Unfortunately it also means that the limb data must be reversed when +reading or writing, so neither a big endian nor little endian system +can just read and write `_mp_d'. + + +File: gmp.info, Node: C++ Interface Internals, Prev: Raw Output Internals, Up: Internals + +17.5 C++ Interface Internals +============================ + +A system of expression templates is used to ensure something like +`a=b+c' turns into a simple call to `mpz_add' etc. For `mpf_class' the +scheme also ensures the precision of the final destination is used for +any temporaries within a statement like `f=w*x+y*z'. These are +important features which a naive implementation cannot provide. + + A simplified description of the scheme follows. The true scheme is +complicated by the fact that expressions have different return types. +For detailed information, refer to the source code. + + To perform an operation, say, addition, we first define a "function +object" evaluating it, + + struct __gmp_binary_plus + { + static void eval(mpf_t f, mpf_t g, mpf_t h) { mpf_add(f, g, h); } + }; + +And an "additive expression" object, + + __gmp_expr<__gmp_binary_expr > + operator+(const mpf_class &f, const mpf_class &g) + { + return __gmp_expr + <__gmp_binary_expr >(f, g); + } + + The seemingly redundant `__gmp_expr<__gmp_binary_expr<...>>' is used +to encapsulate any possible kind of expression into a single template +type. In fact even `mpf_class' etc are `typedef' specializations of +`__gmp_expr'. + + Next we define assignment of `__gmp_expr' to `mpf_class'. + + template + mpf_class & mpf_class::operator=(const __gmp_expr &expr) + { + expr.eval(this->get_mpf_t(), this->precision()); + return *this; + } + + template + void __gmp_expr<__gmp_binary_expr >::eval + (mpf_t f, mp_bitcnt_t precision) + { + Op::eval(f, expr.val1.get_mpf_t(), expr.val2.get_mpf_t()); + } + + where `expr.val1' and `expr.val2' are references to the expression's +operands (here `expr' is the `__gmp_binary_expr' stored within the +`__gmp_expr'). + + This way, the expression is actually evaluated only at the time of +assignment, when the required precision (that of `f') is known. +Furthermore the target `mpf_t' is now available, thus we can call +`mpf_add' directly with `f' as the output argument. + + Compound expressions are handled by defining operators taking +subexpressions as their arguments, like this: + + template + __gmp_expr + <__gmp_binary_expr<__gmp_expr, __gmp_expr, __gmp_binary_plus> > + operator+(const __gmp_expr &expr1, const __gmp_expr &expr2) + { + return __gmp_expr + <__gmp_binary_expr<__gmp_expr, __gmp_expr, __gmp_binary_plus> > + (expr1, expr2); + } + + And the corresponding specializations of `__gmp_expr::eval': + + template + void __gmp_expr + <__gmp_binary_expr<__gmp_expr, __gmp_expr, Op> >::eval + (mpf_t f, mp_bitcnt_t precision) + { + // declare two temporaries + mpf_class temp1(expr.val1, precision), temp2(expr.val2, precision); + Op::eval(f, temp1.get_mpf_t(), temp2.get_mpf_t()); + } + + The expression is thus recursively evaluated to any level of +complexity and all subexpressions are evaluated to the precision of `f'. + + +File: gmp.info, Node: Contributors, Next: References, Prev: Internals, Up: Top + +Appendix A Contributors +*********************** + +Torbjo"rn Granlund wrote the original GMP library and is still the main +developer. Code not explicitly attributed to others, was contributed by +Torbjo"rn. Several other individuals and organizations have contributed +GMP. Here is a list in chronological order on first contribution: + + Gunnar Sjo"din and Hans Riesel helped with mathematical problems in +early versions of the library. + + Richard Stallman helped with the interface design and revised the +first version of this manual. + + Brian Beuning and Doug Lea helped with testing of early versions of +the library and made creative suggestions. + + John Amanatides of York University in Canada contributed the function +`mpz_probab_prime_p'. + + Paul Zimmermann wrote the REDC-based mpz_powm code, the +Scho"nhage-Strassen FFT multiply code, and the Karatsuba square root +code. He also improved the Toom3 code for GMP 4.2. Paul sparked the +development of GMP 2, with his comparisons between bignum packages. +The ECMNET project Paul is organizing was a driving force behind many +of the optimizations in GMP 3. Paul also wrote the new GMP 4.3 nth +root code (with Torbjo"rn). + + Ken Weber (Kent State University, Universidade Federal do Rio Grande +do Sul) contributed now defunct versions of `mpz_gcd', `mpz_divexact', +`mpn_gcd', and `mpn_bdivmod', partially supported by CNPq (Brazil) +grant 301314194-2. + + Per Bothner of Cygnus Support helped to set up GMP to use Cygnus' +configure. He has also made valuable suggestions and tested numerous +intermediary releases. + + Joachim Hollman was involved in the design of the `mpf' interface, +and in the `mpz' design revisions for version 2. + + Bennet Yee contributed the initial versions of `mpz_jacobi' and +`mpz_legendre'. + + Andreas Schwab contributed the files `mpn/m68k/lshift.S' and +`mpn/m68k/rshift.S' (now in `.asm' form). + + Robert Harley of Inria, France and David Seal of ARM, England, +suggested clever improvements for population count. Robert also wrote +highly optimized Karatsuba and 3-way Toom multiplication functions for +GMP 3, and contributed the ARM assembly code. + + Torsten Ekedahl of the Mathematical department of Stockholm +University provided significant inspiration during several phases of +the GMP development. His mathematical expertise helped improve several +algorithms. + + Linus Nordberg wrote the new configure system based on autoconf and +implemented the new random functions. + + Kevin Ryde worked on a large number of things: optimized x86 code, +m4 asm macros, parameter tuning, speed measuring, the configure system, +function inlining, divisibility tests, bit scanning, Jacobi symbols, +Fibonacci and Lucas number functions, printf and scanf functions, perl +interface, demo expression parser, the algorithms chapter in the +manual, `gmpasm-mode.el', and various miscellaneous improvements +elsewhere. + + Kent Boortz made the Mac OS 9 port. + + Steve Root helped write the optimized alpha 21264 assembly code. + + Gerardo Ballabio wrote the `gmpxx.h' C++ class interface and the C++ +`istream' input routines. + + Jason Moxham rewrote `mpz_fac_ui'. + + Pedro Gimeno implemented the Mersenne Twister and made other random +number improvements. + + Niels Mo"ller wrote the sub-quadratic GCD and extended GCD code, the +quadratic Hensel division code, and (with Torbjo"rn) the new divide and +conquer division code for GMP 4.3. Niels also helped implement the new +Toom multiply code for GMP 4.3 and implemented helper functions to +simplify Toom evaluations for GMP 5.0. He wrote the original version +of mpn_mulmod_bnm1. + + Alberto Zanoni and Marco Bodrato suggested the unbalanced multiply +strategy, and found the optimal strategies for evaluation and +interpolation in Toom multiplication. + + Marco Bodrato helped implement the new Toom multiply code for GMP +4.3 and implemented most of the new Toom multiply and squaring code for +5.0. He is the main author of the current mpn_mulmod_bnm1 and +mpn_mullo_n. Marco also wrote the functions mpn_invert and +mpn_invertappr. + + David Harvey suggested the internal function `mpn_bdiv_dbm1', +implementing division relevant to Toom multiplication. He also worked +on fast assembly sequences, in particular on a fast AMD64 +`mpn_mul_basecase'. + + Martin Boij wrote `mpn_perfect_power_p'. + + (This list is chronological, not ordered after significance. If you +have contributed to GMP but are not listed above, please tell + about the omission!) + + The development of floating point functions of GNU MP 2, were +supported in part by the ESPRIT-BRA (Basic Research Activities) 6846 +project POSSO (POlynomial System SOlving). + + The development of GMP 2, 3, and 4 was supported in part by the IDA +Center for Computing Sciences. + + Thanks go to Hans Thorsen for donating an SGI system for the GMP +test system environment. + + +File: gmp.info, Node: References, Next: GNU Free Documentation License, Prev: Contributors, Up: Top + +Appendix B References +********************* + +B.1 Books +========= + + * Jonathan M. Borwein and Peter B. Borwein, "Pi and the AGM: A Study + in Analytic Number Theory and Computational Complexity", Wiley, + 1998. + + * Richard Crandall and Carl Pomerance, "Prime Numbers: A + Computational Perspective", 2nd edition, Springer-Verlag, 2005. + `http://math.dartmouth.edu/~carlp/' + + * Henri Cohen, "A Course in Computational Algebraic Number Theory", + Graduate Texts in Mathematics number 138, Springer-Verlag, 1993. + `http://www.math.u-bordeaux.fr/~cohen/' + + * Donald E. Knuth, "The Art of Computer Programming", volume 2, + "Seminumerical Algorithms", 3rd edition, Addison-Wesley, 1998. + `http://www-cs-faculty.stanford.edu/~knuth/taocp.html' + + * John D. Lipson, "Elements of Algebra and Algebraic Computing", The + Benjamin Cummings Publishing Company Inc, 1981. + + * Alfred J. Menezes, Paul C. van Oorschot and Scott A. Vanstone, + "Handbook of Applied Cryptography", + `http://www.cacr.math.uwaterloo.ca/hac/' + + * Richard M. Stallman and the GCC Developer Community, "Using the + GNU Compiler Collection", Free Software Foundation, 2008, + available online `http://gcc.gnu.org/onlinedocs/', and in the GCC + package `ftp://ftp.gnu.org/gnu/gcc/' + +B.2 Papers +========== + + * Yves Bertot, Nicolas Magaud and Paul Zimmermann, "A Proof of GMP + Square Root", Journal of Automated Reasoning, volume 29, 2002, pp. + 225-252. Also available online as INRIA Research Report 4475, + June 2001, `http://www.inria.fr/rrrt/rr-4475.html' + + * Christoph Burnikel and Joachim Ziegler, "Fast Recursive Division", + Max-Planck-Institut fuer Informatik Research Report MPI-I-98-1-022, + `http://data.mpi-sb.mpg.de/internet/reports.nsf/NumberView/1998-1-022' + + * Torbjo"rn Granlund and Peter L. Montgomery, "Division by Invariant + Integers using Multiplication", in Proceedings of the SIGPLAN + PLDI'94 Conference, June 1994. Also available + `ftp://ftp.cwi.nl/pub/pmontgom/divcnst.psa4.gz' (and .psl.gz). + + * Niels Mo"ller and Torbjo"rn Granlund, "Improved division by + invariant integers", to appear. + + * Torbjo"rn Granlund and Niels Mo"ller, "Division of integers large + and small", to appear. + + * Tudor Jebelean, "An algorithm for exact division", Journal of + Symbolic Computation, volume 15, 1993, pp. 169-180. Research + report version available + `ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1992/92-35.ps.gz' + + * Tudor Jebelean, "Exact Division with Karatsuba Complexity - + Extended Abstract", RISC-Linz technical report 96-31, + `ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1996/96-31.ps.gz' + + * Tudor Jebelean, "Practical Integer Division with Karatsuba + Complexity", ISSAC 97, pp. 339-341. Technical report available + `ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1996/96-29.ps.gz' + + * Tudor Jebelean, "A Generalization of the Binary GCD Algorithm", + ISSAC 93, pp. 111-116. Technical report version available + `ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1993/93-01.ps.gz' + + * Tudor Jebelean, "A Double-Digit Lehmer-Euclid Algorithm for + Finding the GCD of Long Integers", Journal of Symbolic + Computation, volume 19, 1995, pp. 145-157. Technical report + version also available + `ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1992/92-69.ps.gz' + + * Werner Krandick and Tudor Jebelean, "Bidirectional Exact Integer + Division", Journal of Symbolic Computation, volume 21, 1996, pp. + 441-455. Early technical report version also available + `ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1994/94-50.ps.gz' + + * Makoto Matsumoto and Takuji Nishimura, "Mersenne Twister: A + 623-dimensionally equidistributed uniform pseudorandom number + generator", ACM Transactions on Modelling and Computer Simulation, + volume 8, January 1998, pp. 3-30. Available online + `http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.ps.gz' + (or .pdf) + + * R. Moenck and A. Borodin, "Fast Modular Transforms via Division", + Proceedings of the 13th Annual IEEE Symposium on Switching and + Automata Theory, October 1972, pp. 90-96. Reprinted as "Fast + Modular Transforms", Journal of Computer and System Sciences, + volume 8, number 3, June 1974, pp. 366-386. + + * Niels Mo"ller, "On Scho"nhage's algorithm and subquadratic integer + GCD computation", in Mathematics of Computation, volume 77, + January 2008, pp. 589-607. + + * Peter L. Montgomery, "Modular Multiplication Without Trial + Division", in Mathematics of Computation, volume 44, number 170, + April 1985. + + * Arnold Scho"nhage and Volker Strassen, "Schnelle Multiplikation + grosser Zahlen", Computing 7, 1971, pp. 281-292. + + * Kenneth Weber, "The accelerated integer GCD algorithm", ACM + Transactions on Mathematical Software, volume 21, number 1, March + 1995, pp. 111-122. + + * Paul Zimmermann, "Karatsuba Square Root", INRIA Research Report + 3805, November 1999, `http://www.inria.fr/rrrt/rr-3805.html' + + * Paul Zimmermann, "A Proof of GMP Fast Division and Square Root + Implementations", + `http://www.loria.fr/~zimmerma/papers/proof-div-sqrt.ps.gz' + + * Dan Zuras, "On Squaring and Multiplying Large Integers", ARITH-11: + IEEE Symposium on Computer Arithmetic, 1993, pp. 260 to 271. + Reprinted as "More on Multiplying and Squaring Large Integers", + IEEE Transactions on Computers, volume 43, number 8, August 1994, + pp. 899-908. + + +File: gmp.info, Node: GNU Free Documentation License, Next: Concept Index, Prev: References, Up: Top + +Appendix C GNU Free Documentation License +***************************************** + + Version 1.3, 3 November 2008 + + Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. + `http://fsf.org/' + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + 0. PREAMBLE + + The purpose of this License is to make a manual, textbook, or other + functional and useful document "free" in the sense of freedom: to + assure everyone the effective freedom to copy and redistribute it, + with or without modifying it, either commercially or + noncommercially. Secondarily, this License preserves for the + author and publisher a way to get credit for their work, while not + being considered responsible for modifications made by others. + + This License is a kind of "copyleft", which means that derivative + works of the document must themselves be free in the same sense. + It complements the GNU General Public License, which is a copyleft + license designed for free software. + + We have designed this License in order to use it for manuals for + free software, because free software needs free documentation: a + free program should come with manuals providing the same freedoms + that the software does. But this License is not limited to + software manuals; it can be used for any textual work, regardless + of subject matter or whether it is published as a printed book. + We recommend this License principally for works whose purpose is + instruction or reference. + + 1. APPLICABILITY AND DEFINITIONS + + This License applies to any manual or other work, in any medium, + that contains a notice placed by the copyright holder saying it + can be distributed under the terms of this License. Such a notice + grants a world-wide, royalty-free license, unlimited in duration, + to use that work under the conditions stated herein. The + "Document", below, refers to any such manual or work. Any member + of the public is a licensee, and is addressed as "you". You + accept the license if you copy, modify or distribute the work in a + way requiring permission under copyright law. + + A "Modified Version" of the Document means any work containing the + Document or a portion of it, either copied verbatim, or with + modifications and/or translated into another language. + + A "Secondary Section" is a named appendix or a front-matter section + of the Document that deals exclusively with the relationship of the + publishers or authors of the Document to the Document's overall + subject (or to related matters) and contains nothing that could + fall directly within that overall subject. (Thus, if the Document + is in part a textbook of mathematics, a Secondary Section may not + explain any mathematics.) The relationship could be a matter of + historical connection with the subject or with related matters, or + of legal, commercial, philosophical, ethical or political position + regarding them. + + The "Invariant Sections" are certain Secondary Sections whose + titles are designated, as being those of Invariant Sections, in + the notice that says that the Document is released under this + License. If a section does not fit the above definition of + Secondary then it is not allowed to be designated as Invariant. + The Document may contain zero Invariant Sections. If the Document + does not identify any Invariant Sections then there are none. + + The "Cover Texts" are certain short passages of text that are + listed, as Front-Cover Texts or Back-Cover Texts, in the notice + that says that the Document is released under this License. A + Front-Cover Text may be at most 5 words, and a Back-Cover Text may + be at most 25 words. + + A "Transparent" copy of the Document means a machine-readable copy, + represented in a format whose specification is available to the + general public, that is suitable for revising the document + straightforwardly with generic text editors or (for images + composed of pixels) generic paint programs or (for drawings) some + widely available drawing editor, and that is suitable for input to + text formatters or for automatic translation to a variety of + formats suitable for input to text formatters. A copy made in an + otherwise Transparent file format whose markup, or absence of + markup, has been arranged to thwart or discourage subsequent + modification by readers is not Transparent. An image format is + not Transparent if used for any substantial amount of text. A + copy that is not "Transparent" is called "Opaque". + + Examples of suitable formats for Transparent copies include plain + ASCII without markup, Texinfo input format, LaTeX input format, + SGML or XML using a publicly available DTD, and + standard-conforming simple HTML, PostScript or PDF designed for + human modification. Examples of transparent image formats include + PNG, XCF and JPG. Opaque formats include proprietary formats that + can be read and edited only by proprietary word processors, SGML or + XML for which the DTD and/or processing tools are not generally + available, and the machine-generated HTML, PostScript or PDF + produced by some word processors for output purposes only. + + The "Title Page" means, for a printed book, the title page itself, + plus such following pages as are needed to hold, legibly, the + material this License requires to appear in the title page. For + works in formats which do not have any title page as such, "Title + Page" means the text near the most prominent appearance of the + work's title, preceding the beginning of the body of the text. + + The "publisher" means any person or entity that distributes copies + of the Document to the public. + + A section "Entitled XYZ" means a named subunit of the Document + whose title either is precisely XYZ or contains XYZ in parentheses + following text that translates XYZ in another language. (Here XYZ + stands for a specific section name mentioned below, such as + "Acknowledgements", "Dedications", "Endorsements", or "History".) + To "Preserve the Title" of such a section when you modify the + Document means that it remains a section "Entitled XYZ" according + to this definition. + + The Document may include Warranty Disclaimers next to the notice + which states that this License applies to the Document. These + Warranty Disclaimers are considered to be included by reference in + this License, but only as regards disclaiming warranties: any other + implication that these Warranty Disclaimers may have is void and + has no effect on the meaning of this License. + + 2. VERBATIM COPYING + + You may copy and distribute the Document in any medium, either + commercially or noncommercially, provided that this License, the + copyright notices, and the license notice saying this License + applies to the Document are reproduced in all copies, and that you + add no other conditions whatsoever to those of this License. You + may not use technical measures to obstruct or control the reading + or further copying of the copies you make or distribute. However, + you may accept compensation in exchange for copies. If you + distribute a large enough number of copies you must also follow + the conditions in section 3. + + You may also lend copies, under the same conditions stated above, + and you may publicly display copies. + + 3. COPYING IN QUANTITY + + If you publish printed copies (or copies in media that commonly + have printed covers) of the Document, numbering more than 100, and + the Document's license notice requires Cover Texts, you must + enclose the copies in covers that carry, clearly and legibly, all + these Cover Texts: Front-Cover Texts on the front cover, and + Back-Cover Texts on the back cover. Both covers must also clearly + and legibly identify you as the publisher of these copies. The + front cover must present the full title with all words of the + title equally prominent and visible. You may add other material + on the covers in addition. Copying with changes limited to the + covers, as long as they preserve the title of the Document and + satisfy these conditions, can be treated as verbatim copying in + other respects. + + If the required texts for either cover are too voluminous to fit + legibly, you should put the first ones listed (as many as fit + reasonably) on the actual cover, and continue the rest onto + adjacent pages. + + If you publish or distribute Opaque copies of the Document + numbering more than 100, you must either include a + machine-readable Transparent copy along with each Opaque copy, or + state in or with each Opaque copy a computer-network location from + which the general network-using public has access to download + using public-standard network protocols a complete Transparent + copy of the Document, free of added material. If you use the + latter option, you must take reasonably prudent steps, when you + begin distribution of Opaque copies in quantity, to ensure that + this Transparent copy will remain thus accessible at the stated + location until at least one year after the last time you + distribute an Opaque copy (directly or through your agents or + retailers) of that edition to the public. + + It is requested, but not required, that you contact the authors of + the Document well before redistributing any large number of + copies, to give them a chance to provide you with an updated + version of the Document. + + 4. MODIFICATIONS + + You may copy and distribute a Modified Version of the Document + under the conditions of sections 2 and 3 above, provided that you + release the Modified Version under precisely this License, with + the Modified Version filling the role of the Document, thus + licensing distribution and modification of the Modified Version to + whoever possesses a copy of it. In addition, you must do these + things in the Modified Version: + + A. Use in the Title Page (and on the covers, if any) a title + distinct from that of the Document, and from those of + previous versions (which should, if there were any, be listed + in the History section of the Document). You may use the + same title as a previous version if the original publisher of + that version gives permission. + + B. List on the Title Page, as authors, one or more persons or + entities responsible for authorship of the modifications in + the Modified Version, together with at least five of the + principal authors of the Document (all of its principal + authors, if it has fewer than five), unless they release you + from this requirement. + + C. State on the Title page the name of the publisher of the + Modified Version, as the publisher. + + D. Preserve all the copyright notices of the Document. + + E. Add an appropriate copyright notice for your modifications + adjacent to the other copyright notices. + + F. Include, immediately after the copyright notices, a license + notice giving the public permission to use the Modified + Version under the terms of this License, in the form shown in + the Addendum below. + + G. Preserve in that license notice the full lists of Invariant + Sections and required Cover Texts given in the Document's + license notice. + + H. Include an unaltered copy of this License. + + I. Preserve the section Entitled "History", Preserve its Title, + and add to it an item stating at least the title, year, new + authors, and publisher of the Modified Version as given on + the Title Page. If there is no section Entitled "History" in + the Document, create one stating the title, year, authors, + and publisher of the Document as given on its Title Page, + then add an item describing the Modified Version as stated in + the previous sentence. + + J. Preserve the network location, if any, given in the Document + for public access to a Transparent copy of the Document, and + likewise the network locations given in the Document for + previous versions it was based on. These may be placed in + the "History" section. You may omit a network location for a + work that was published at least four years before the + Document itself, or if the original publisher of the version + it refers to gives permission. + + K. For any section Entitled "Acknowledgements" or "Dedications", + Preserve the Title of the section, and preserve in the + section all the substance and tone of each of the contributor + acknowledgements and/or dedications given therein. + + L. Preserve all the Invariant Sections of the Document, + unaltered in their text and in their titles. Section numbers + or the equivalent are not considered part of the section + titles. + + M. Delete any section Entitled "Endorsements". Such a section + may not be included in the Modified Version. + + N. Do not retitle any existing section to be Entitled + "Endorsements" or to conflict in title with any Invariant + Section. + + O. Preserve any Warranty Disclaimers. + + If the Modified Version includes new front-matter sections or + appendices that qualify as Secondary Sections and contain no + material copied from the Document, you may at your option + designate some or all of these sections as invariant. To do this, + add their titles to the list of Invariant Sections in the Modified + Version's license notice. These titles must be distinct from any + other section titles. + + You may add a section Entitled "Endorsements", provided it contains + nothing but endorsements of your Modified Version by various + parties--for example, statements of peer review or that the text + has been approved by an organization as the authoritative + definition of a standard. + + You may add a passage of up to five words as a Front-Cover Text, + and a passage of up to 25 words as a Back-Cover Text, to the end + of the list of Cover Texts in the Modified Version. Only one + passage of Front-Cover Text and one of Back-Cover Text may be + added by (or through arrangements made by) any one entity. If the + Document already includes a cover text for the same cover, + previously added by you or by arrangement made by the same entity + you are acting on behalf of, you may not add another; but you may + replace the old one, on explicit permission from the previous + publisher that added the old one. + + The author(s) and publisher(s) of the Document do not by this + License give permission to use their names for publicity for or to + assert or imply endorsement of any Modified Version. + + 5. COMBINING DOCUMENTS + + You may combine the Document with other documents released under + this License, under the terms defined in section 4 above for + modified versions, provided that you include in the combination + all of the Invariant Sections of all of the original documents, + unmodified, and list them all as Invariant Sections of your + combined work in its license notice, and that you preserve all + their Warranty Disclaimers. + + The combined work need only contain one copy of this License, and + multiple identical Invariant Sections may be replaced with a single + copy. If there are multiple Invariant Sections with the same name + but different contents, make the title of each such section unique + by adding at the end of it, in parentheses, the name of the + original author or publisher of that section if known, or else a + unique number. Make the same adjustment to the section titles in + the list of Invariant Sections in the license notice of the + combined work. + + In the combination, you must combine any sections Entitled + "History" in the various original documents, forming one section + Entitled "History"; likewise combine any sections Entitled + "Acknowledgements", and any sections Entitled "Dedications". You + must delete all sections Entitled "Endorsements." + + 6. COLLECTIONS OF DOCUMENTS + + You may make a collection consisting of the Document and other + documents released under this License, and replace the individual + copies of this License in the various documents with a single copy + that is included in the collection, provided that you follow the + rules of this License for verbatim copying of each of the + documents in all other respects. + + You may extract a single document from such a collection, and + distribute it individually under this License, provided you insert + a copy of this License into the extracted document, and follow + this License in all other respects regarding verbatim copying of + that document. + + 7. AGGREGATION WITH INDEPENDENT WORKS + + A compilation of the Document or its derivatives with other + separate and independent documents or works, in or on a volume of + a storage or distribution medium, is called an "aggregate" if the + copyright resulting from the compilation is not used to limit the + legal rights of the compilation's users beyond what the individual + works permit. When the Document is included in an aggregate, this + License does not apply to the other works in the aggregate which + are not themselves derivative works of the Document. + + If the Cover Text requirement of section 3 is applicable to these + copies of the Document, then if the Document is less than one half + of the entire aggregate, the Document's Cover Texts may be placed + on covers that bracket the Document within the aggregate, or the + electronic equivalent of covers if the Document is in electronic + form. Otherwise they must appear on printed covers that bracket + the whole aggregate. + + 8. TRANSLATION + + Translation is considered a kind of modification, so you may + distribute translations of the Document under the terms of section + 4. Replacing Invariant Sections with translations requires special + permission from their copyright holders, but you may include + translations of some or all Invariant Sections in addition to the + original versions of these Invariant Sections. You may include a + translation of this License, and all the license notices in the + Document, and any Warranty Disclaimers, provided that you also + include the original English version of this License and the + original versions of those notices and disclaimers. In case of a + disagreement between the translation and the original version of + this License or a notice or disclaimer, the original version will + prevail. + + If a section in the Document is Entitled "Acknowledgements", + "Dedications", or "History", the requirement (section 4) to + Preserve its Title (section 1) will typically require changing the + actual title. + + 9. TERMINATION + + You may not copy, modify, sublicense, or distribute the Document + except as expressly provided under this License. Any attempt + otherwise to copy, modify, sublicense, or distribute it is void, + and will automatically terminate your rights under this License. + + However, if you cease all violation of this License, then your + license from a particular copyright holder is reinstated (a) + provisionally, unless and until the copyright holder explicitly + and finally terminates your license, and (b) permanently, if the + copyright holder fails to notify you of the violation by some + reasonable means prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is + reinstated permanently if the copyright holder notifies you of the + violation by some reasonable means, this is the first time you have + received notice of violation of this License (for any work) from + that copyright holder, and you cure the violation prior to 30 days + after your receipt of the notice. + + Termination of your rights under this section does not terminate + the licenses of parties who have received copies or rights from + you under this License. If your rights have been terminated and + not permanently reinstated, receipt of a copy of some or all of + the same material does not give you any rights to use it. + + 10. FUTURE REVISIONS OF THIS LICENSE + + The Free Software Foundation may publish new, revised versions of + the GNU Free Documentation License from time to time. Such new + versions will be similar in spirit to the present version, but may + differ in detail to address new problems or concerns. See + `http://www.gnu.org/copyleft/'. + + Each version of the License is given a distinguishing version + number. If the Document specifies that a particular numbered + version of this License "or any later version" applies to it, you + have the option of following the terms and conditions either of + that specified version or of any later version that has been + published (not as a draft) by the Free Software Foundation. If + the Document does not specify a version number of this License, + you may choose any version ever published (not as a draft) by the + Free Software Foundation. If the Document specifies that a proxy + can decide which future versions of this License can be used, that + proxy's public statement of acceptance of a version permanently + authorizes you to choose that version for the Document. + + 11. RELICENSING + + "Massive Multiauthor Collaboration Site" (or "MMC Site") means any + World Wide Web server that publishes copyrightable works and also + provides prominent facilities for anybody to edit those works. A + public wiki that anybody can edit is an example of such a server. + A "Massive Multiauthor Collaboration" (or "MMC") contained in the + site means any set of copyrightable works thus published on the MMC + site. + + "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 + license published by Creative Commons Corporation, a not-for-profit + corporation with a principal place of business in San Francisco, + California, as well as future copyleft versions of that license + published by that same organization. + + "Incorporate" means to publish or republish a Document, in whole or + in part, as part of another Document. + + An MMC is "eligible for relicensing" if it is licensed under this + License, and if all works that were first published under this + License somewhere other than this MMC, and subsequently + incorporated in whole or in part into the MMC, (1) had no cover + texts or invariant sections, and (2) were thus incorporated prior + to November 1, 2008. + + The operator of an MMC Site may republish an MMC contained in the + site under CC-BY-SA on the same site at any time before August 1, + 2009, provided the MMC is eligible for relicensing. + + +ADDENDUM: How to use this License for your documents +==================================================== + +To use this License in a document you have written, include a copy of +the License in the document and put the following copyright and license +notices just after the title page: + + Copyright (C) YEAR YOUR NAME. + Permission is granted to copy, distribute and/or modify this document + under the terms of the GNU Free Documentation License, Version 1.3 + or any later version published by the Free Software Foundation; + with no Invariant Sections, no Front-Cover Texts, and no Back-Cover + Texts. A copy of the license is included in the section entitled ``GNU + Free Documentation License''. + + If you have Invariant Sections, Front-Cover Texts and Back-Cover +Texts, replace the "with...Texts." line with this: + + with the Invariant Sections being LIST THEIR TITLES, with + the Front-Cover Texts being LIST, and with the Back-Cover Texts + being LIST. + + If you have Invariant Sections without Cover Texts, or some other +combination of the three, merge those two alternatives to suit the +situation. + + If your document contains nontrivial examples of program code, we +recommend releasing these examples in parallel under your choice of +free software license, such as the GNU General Public License, to +permit their use in free software. + + +File: gmp.info, Node: Concept Index, Next: Function Index, Prev: GNU Free Documentation License, Up: Top + +Concept Index +************* + +[index] +* Menu: + +* #include: Headers and Libraries. + (line 6) +* --build: Build Options. (line 52) +* --disable-fft: Build Options. (line 317) +* --disable-shared: Build Options. (line 45) +* --disable-static: Build Options. (line 45) +* --enable-alloca: Build Options. (line 278) +* --enable-assert: Build Options. (line 327) +* --enable-cxx: Build Options. (line 230) +* --enable-fat: Build Options. (line 164) +* --enable-mpbsd: Build Options. (line 322) +* --enable-profiling <1>: Profiling. (line 6) +* --enable-profiling: Build Options. (line 331) +* --exec-prefix: Build Options. (line 32) +* --host: Build Options. (line 66) +* --prefix: Build Options. (line 32) +* -finstrument-functions: Profiling. (line 66) +* 2exp functions: Efficiency. (line 43) +* 68000: Notes for Particular Systems. + (line 80) +* 80x86: Notes for Particular Systems. + (line 126) +* ABI <1>: Build Options. (line 171) +* ABI: ABI and ISA. (line 6) +* About this manual: Introduction to GMP. (line 58) +* AC_CHECK_LIB: Autoconf. (line 11) +* AIX <1>: ABI and ISA. (line 184) +* AIX <2>: Notes for Particular Systems. + (line 7) +* AIX: ABI and ISA. (line 169) +* Algorithms: Algorithms. (line 6) +* alloca: Build Options. (line 278) +* Allocation of memory: Custom Allocation. (line 6) +* AMD64: ABI and ISA. (line 44) +* Anonymous FTP of latest version: Introduction to GMP. (line 38) +* Application Binary Interface: ABI and ISA. (line 6) +* Arithmetic functions <1>: Float Arithmetic. (line 6) +* Arithmetic functions <2>: Integer Arithmetic. (line 6) +* Arithmetic functions: Rational Arithmetic. (line 6) +* ARM: Notes for Particular Systems. + (line 20) +* Assembly cache handling: Assembly Cache Handling. + (line 6) +* Assembly carry propagation: Assembly Carry Propagation. + (line 6) +* Assembly code organisation: Assembly Code Organisation. + (line 6) +* Assembly coding: Assembly Coding. (line 6) +* Assembly floating Point: Assembly Floating Point. + (line 6) +* Assembly loop unrolling: Assembly Loop Unrolling. + (line 6) +* Assembly SIMD: Assembly SIMD Instructions. + (line 6) +* Assembly software pipelining: Assembly Software Pipelining. + (line 6) +* Assembly writing guide: Assembly Writing Guide. + (line 6) +* Assertion checking <1>: Debugging. (line 79) +* Assertion checking: Build Options. (line 327) +* Assignment functions <1>: Assigning Floats. (line 6) +* Assignment functions <2>: Initializing Rationals. + (line 6) +* Assignment functions <3>: Simultaneous Integer Init & Assign. + (line 6) +* Assignment functions <4>: Simultaneous Float Init & Assign. + (line 6) +* Assignment functions: Assigning Integers. (line 6) +* Autoconf: Autoconf. (line 6) +* Basics: GMP Basics. (line 6) +* Berkeley MP compatible functions <1>: Build Options. (line 322) +* Berkeley MP compatible functions: BSD Compatible Functions. + (line 6) +* Binomial coefficient algorithm: Binomial Coefficients Algorithm. + (line 6) +* Binomial coefficient functions: Number Theoretic Functions. + (line 100) +* Binutils strip: Known Build Problems. + (line 28) +* Bit manipulation functions: Integer Logic and Bit Fiddling. + (line 6) +* Bit scanning functions: Integer Logic and Bit Fiddling. + (line 38) +* Bit shift left: Integer Arithmetic. (line 35) +* Bit shift right: Integer Division. (line 53) +* Bits per limb: Useful Macros and Constants. + (line 7) +* BSD MP compatible functions <1>: Build Options. (line 322) +* BSD MP compatible functions: BSD Compatible Functions. + (line 6) +* Bug reporting: Reporting Bugs. (line 6) +* Build directory: Build Options. (line 19) +* Build notes for binary packaging: Notes for Package Builds. + (line 6) +* Build notes for particular systems: Notes for Particular Systems. + (line 6) +* Build options: Build Options. (line 6) +* Build problems known: Known Build Problems. + (line 6) +* Build system: Build Options. (line 52) +* Building GMP: Installing GMP. (line 6) +* Bus error: Debugging. (line 7) +* C compiler: Build Options. (line 182) +* C++ compiler: Build Options. (line 254) +* C++ interface: C++ Class Interface. (line 6) +* C++ interface internals: C++ Interface Internals. + (line 6) +* C++ istream input: C++ Formatted Input. (line 6) +* C++ ostream output: C++ Formatted Output. + (line 6) +* C++ support: Build Options. (line 230) +* CC: Build Options. (line 182) +* CC_FOR_BUILD: Build Options. (line 217) +* CFLAGS: Build Options. (line 182) +* Checker: Debugging. (line 115) +* checkergcc: Debugging. (line 122) +* Code organisation: Assembly Code Organisation. + (line 6) +* Compaq C++: Notes for Particular Systems. + (line 25) +* Comparison functions <1>: Integer Comparisons. (line 6) +* Comparison functions <2>: Comparing Rationals. (line 6) +* Comparison functions: Float Comparison. (line 6) +* Compatibility with older versions: Compatibility with older versions. + (line 6) +* Conditions for copying GNU MP: Copying. (line 6) +* Configuring GMP: Installing GMP. (line 6) +* Congruence algorithm: Exact Remainder. (line 29) +* Congruence functions: Integer Division. (line 124) +* Constants: Useful Macros and Constants. + (line 6) +* Contributors: Contributors. (line 6) +* Conventions for parameters: Parameter Conventions. + (line 6) +* Conventions for variables: Variable Conventions. + (line 6) +* Conversion functions <1>: Converting Integers. (line 6) +* Conversion functions <2>: Converting Floats. (line 6) +* Conversion functions: Rational Conversions. + (line 6) +* Copying conditions: Copying. (line 6) +* CPPFLAGS: Build Options. (line 208) +* CPU types <1>: Introduction to GMP. (line 24) +* CPU types: Build Options. (line 108) +* Cross compiling: Build Options. (line 66) +* Custom allocation: Custom Allocation. (line 6) +* CXX: Build Options. (line 254) +* CXXFLAGS: Build Options. (line 254) +* Cygwin: Notes for Particular Systems. + (line 43) +* Darwin: Known Build Problems. + (line 51) +* Debugging: Debugging. (line 6) +* Demonstration programs: Demonstration Programs. + (line 6) +* Digits in an integer: Miscellaneous Integer Functions. + (line 23) +* Divisibility algorithm: Exact Remainder. (line 29) +* Divisibility functions: Integer Division. (line 124) +* Divisibility testing: Efficiency. (line 91) +* Division algorithms: Division Algorithms. (line 6) +* Division functions <1>: Rational Arithmetic. (line 22) +* Division functions <2>: Integer Division. (line 6) +* Division functions: Float Arithmetic. (line 33) +* DJGPP <1>: Notes for Particular Systems. + (line 43) +* DJGPP: Known Build Problems. + (line 18) +* DLLs: Notes for Particular Systems. + (line 56) +* DocBook: Build Options. (line 354) +* Documentation formats: Build Options. (line 347) +* Documentation license: GNU Free Documentation License. + (line 6) +* DVI: Build Options. (line 350) +* Efficiency: Efficiency. (line 6) +* Emacs: Emacs. (line 6) +* Exact division functions: Integer Division. (line 102) +* Exact remainder: Exact Remainder. (line 6) +* Example programs: Demonstration Programs. + (line 6) +* Exec prefix: Build Options. (line 32) +* Execution profiling <1>: Profiling. (line 6) +* Execution profiling: Build Options. (line 331) +* Exponentiation functions <1>: Integer Exponentiation. + (line 6) +* Exponentiation functions: Float Arithmetic. (line 41) +* Export: Integer Import and Export. + (line 45) +* Expression parsing demo: Demonstration Programs. + (line 18) +* Extended GCD: Number Theoretic Functions. + (line 45) +* Factor removal functions: Number Theoretic Functions. + (line 90) +* Factorial algorithm: Factorial Algorithm. (line 6) +* Factorial functions: Number Theoretic Functions. + (line 95) +* Factorization demo: Demonstration Programs. + (line 25) +* Fast Fourier Transform: FFT Multiplication. (line 6) +* Fat binary: Build Options. (line 164) +* FFT multiplication <1>: FFT Multiplication. (line 6) +* FFT multiplication: Build Options. (line 317) +* Fibonacci number algorithm: Fibonacci Numbers Algorithm. + (line 6) +* Fibonacci sequence functions: Number Theoretic Functions. + (line 108) +* Float arithmetic functions: Float Arithmetic. (line 6) +* Float assignment functions <1>: Simultaneous Float Init & Assign. + (line 6) +* Float assignment functions: Assigning Floats. (line 6) +* Float comparison functions: Float Comparison. (line 6) +* Float conversion functions: Converting Floats. (line 6) +* Float functions: Floating-point Functions. + (line 6) +* Float initialization functions <1>: Simultaneous Float Init & Assign. + (line 6) +* Float initialization functions: Initializing Floats. (line 6) +* Float input and output functions: I/O of Floats. (line 6) +* Float internals: Float Internals. (line 6) +* Float miscellaneous functions: Miscellaneous Float Functions. + (line 6) +* Float random number functions: Miscellaneous Float Functions. + (line 27) +* Float rounding functions: Miscellaneous Float Functions. + (line 9) +* Float sign tests: Float Comparison. (line 33) +* Floating point mode: Notes for Particular Systems. + (line 34) +* Floating-point functions: Floating-point Functions. + (line 6) +* Floating-point number: Nomenclature and Types. + (line 21) +* fnccheck: Profiling. (line 77) +* Formatted input: Formatted Input. (line 6) +* Formatted output: Formatted Output. (line 6) +* Free Documentation License: GNU Free Documentation License. + (line 6) +* frexp <1>: Converting Floats. (line 23) +* frexp: Converting Integers. (line 42) +* FTP of latest version: Introduction to GMP. (line 38) +* Function classes: Function Classes. (line 6) +* FunctionCheck: Profiling. (line 77) +* GCC Checker: Debugging. (line 115) +* GCD algorithms: Greatest Common Divisor Algorithms. + (line 6) +* GCD extended: Number Theoretic Functions. + (line 45) +* GCD functions: Number Theoretic Functions. + (line 30) +* GDB: Debugging. (line 58) +* Generic C: Build Options. (line 153) +* GMP Perl module: Demonstration Programs. + (line 35) +* GMP version number: Useful Macros and Constants. + (line 12) +* gmp.h: Headers and Libraries. + (line 6) +* gmpxx.h: C++ Interface General. + (line 8) +* GNU Debugger: Debugging. (line 58) +* GNU Free Documentation License: GNU Free Documentation License. + (line 6) +* GNU strip: Known Build Problems. + (line 28) +* gprof: Profiling. (line 41) +* Greatest common divisor algorithms: Greatest Common Divisor Algorithms. + (line 6) +* Greatest common divisor functions: Number Theoretic Functions. + (line 30) +* Hardware floating point mode: Notes for Particular Systems. + (line 34) +* Headers: Headers and Libraries. + (line 6) +* Heap problems: Debugging. (line 24) +* Home page: Introduction to GMP. (line 34) +* Host system: Build Options. (line 66) +* HP-UX: ABI and ISA. (line 107) +* HPPA: ABI and ISA. (line 68) +* I/O functions <1>: I/O of Integers. (line 6) +* I/O functions <2>: I/O of Rationals. (line 6) +* I/O functions: I/O of Floats. (line 6) +* i386: Notes for Particular Systems. + (line 126) +* IA-64: ABI and ISA. (line 107) +* Import: Integer Import and Export. + (line 11) +* In-place operations: Efficiency. (line 57) +* Include files: Headers and Libraries. + (line 6) +* info-lookup-symbol: Emacs. (line 6) +* Initialization functions <1>: Initializing Integers. + (line 6) +* Initialization functions <2>: Initializing Rationals. + (line 6) +* Initialization functions <3>: Random State Initialization. + (line 6) +* Initialization functions <4>: Simultaneous Float Init & Assign. + (line 6) +* Initialization functions <5>: Simultaneous Integer Init & Assign. + (line 6) +* Initialization functions: Initializing Floats. (line 6) +* Initializing and clearing: Efficiency. (line 21) +* Input functions <1>: I/O of Integers. (line 6) +* Input functions <2>: I/O of Rationals. (line 6) +* Input functions <3>: I/O of Floats. (line 6) +* Input functions: Formatted Input Functions. + (line 6) +* Install prefix: Build Options. (line 32) +* Installing GMP: Installing GMP. (line 6) +* Instruction Set Architecture: ABI and ISA. (line 6) +* instrument-functions: Profiling. (line 66) +* Integer: Nomenclature and Types. + (line 6) +* Integer arithmetic functions: Integer Arithmetic. (line 6) +* Integer assignment functions <1>: Simultaneous Integer Init & Assign. + (line 6) +* Integer assignment functions: Assigning Integers. (line 6) +* Integer bit manipulation functions: Integer Logic and Bit Fiddling. + (line 6) +* Integer comparison functions: Integer Comparisons. (line 6) +* Integer conversion functions: Converting Integers. (line 6) +* Integer division functions: Integer Division. (line 6) +* Integer exponentiation functions: Integer Exponentiation. + (line 6) +* Integer export: Integer Import and Export. + (line 45) +* Integer functions: Integer Functions. (line 6) +* Integer import: Integer Import and Export. + (line 11) +* Integer initialization functions <1>: Simultaneous Integer Init & Assign. + (line 6) +* Integer initialization functions: Initializing Integers. + (line 6) +* Integer input and output functions: I/O of Integers. (line 6) +* Integer internals: Integer Internals. (line 6) +* Integer logical functions: Integer Logic and Bit Fiddling. + (line 6) +* Integer miscellaneous functions: Miscellaneous Integer Functions. + (line 6) +* Integer random number functions: Integer Random Numbers. + (line 6) +* Integer root functions: Integer Roots. (line 6) +* Integer sign tests: Integer Comparisons. (line 28) +* Integer special functions: Integer Special Functions. + (line 6) +* Interix: Notes for Particular Systems. + (line 51) +* Internals: Internals. (line 6) +* Introduction: Introduction to GMP. (line 6) +* Inverse modulo functions: Number Theoretic Functions. + (line 60) +* IRIX <1>: Known Build Problems. + (line 38) +* IRIX: ABI and ISA. (line 132) +* ISA: ABI and ISA. (line 6) +* istream input: C++ Formatted Input. (line 6) +* Jacobi symbol algorithm: Jacobi Symbol. (line 6) +* Jacobi symbol functions: Number Theoretic Functions. + (line 66) +* Karatsuba multiplication: Karatsuba Multiplication. + (line 6) +* Karatsuba square root algorithm: Square Root Algorithm. + (line 6) +* Kronecker symbol functions: Number Theoretic Functions. + (line 78) +* Language bindings: Language Bindings. (line 6) +* Latest version of GMP: Introduction to GMP. (line 38) +* LCM functions: Number Theoretic Functions. + (line 55) +* Least common multiple functions: Number Theoretic Functions. + (line 55) +* Legendre symbol functions: Number Theoretic Functions. + (line 69) +* libgmp: Headers and Libraries. + (line 22) +* libgmpxx: Headers and Libraries. + (line 27) +* Libraries: Headers and Libraries. + (line 22) +* Libtool: Headers and Libraries. + (line 33) +* Libtool versioning: Notes for Package Builds. + (line 9) +* License conditions: Copying. (line 6) +* Limb: Nomenclature and Types. + (line 31) +* Limb size: Useful Macros and Constants. + (line 7) +* Linear congruential algorithm: Random Number Algorithms. + (line 25) +* Linear congruential random numbers: Random State Initialization. + (line 32) +* Linking: Headers and Libraries. + (line 22) +* Logical functions: Integer Logic and Bit Fiddling. + (line 6) +* Low-level functions: Low-level Functions. (line 6) +* Lucas number algorithm: Lucas Numbers Algorithm. + (line 6) +* Lucas number functions: Number Theoretic Functions. + (line 119) +* MacOS X: Known Build Problems. + (line 51) +* Mailing lists: Introduction to GMP. (line 45) +* Malloc debugger: Debugging. (line 30) +* Malloc problems: Debugging. (line 24) +* Memory allocation: Custom Allocation. (line 6) +* Memory management: Memory Management. (line 6) +* Mersenne twister algorithm: Random Number Algorithms. + (line 17) +* Mersenne twister random numbers: Random State Initialization. + (line 13) +* MINGW: Notes for Particular Systems. + (line 43) +* MIPS: ABI and ISA. (line 132) +* Miscellaneous float functions: Miscellaneous Float Functions. + (line 6) +* Miscellaneous integer functions: Miscellaneous Integer Functions. + (line 6) +* MMX: Notes for Particular Systems. + (line 132) +* Modular inverse functions: Number Theoretic Functions. + (line 60) +* Most significant bit: Miscellaneous Integer Functions. + (line 34) +* mp.h: BSD Compatible Functions. + (line 21) +* MPN_PATH: Build Options. (line 335) +* MS Windows: Notes for Particular Systems. + (line 56) +* MS-DOS: Notes for Particular Systems. + (line 43) +* Multi-threading: Reentrancy. (line 6) +* Multiplication algorithms: Multiplication Algorithms. + (line 6) +* Nails: Low-level Functions. (line 478) +* Native compilation: Build Options. (line 52) +* NeXT: Known Build Problems. + (line 57) +* Next prime function: Number Theoretic Functions. + (line 23) +* Nomenclature: Nomenclature and Types. + (line 6) +* Non-Unix systems: Build Options. (line 11) +* Nth root algorithm: Nth Root Algorithm. (line 6) +* Number sequences: Efficiency. (line 147) +* Number theoretic functions: Number Theoretic Functions. + (line 6) +* Numerator and denominator: Applying Integer Functions. + (line 6) +* obstack output: Formatted Output Functions. + (line 81) +* OpenBSD: Notes for Particular Systems. + (line 86) +* Optimizing performance: Performance optimization. + (line 6) +* ostream output: C++ Formatted Output. + (line 6) +* Other languages: Language Bindings. (line 6) +* Output functions <1>: I/O of Floats. (line 6) +* Output functions <2>: I/O of Rationals. (line 6) +* Output functions <3>: Formatted Output Functions. + (line 6) +* Output functions: I/O of Integers. (line 6) +* Packaged builds: Notes for Package Builds. + (line 6) +* Parameter conventions: Parameter Conventions. + (line 6) +* Parsing expressions demo: Demonstration Programs. + (line 21) +* Particular systems: Notes for Particular Systems. + (line 6) +* Past GMP versions: Compatibility with older versions. + (line 6) +* PDF: Build Options. (line 350) +* Perfect power algorithm: Perfect Power Algorithm. + (line 6) +* Perfect power functions: Integer Roots. (line 27) +* Perfect square algorithm: Perfect Square Algorithm. + (line 6) +* Perfect square functions: Integer Roots. (line 36) +* perl: Demonstration Programs. + (line 35) +* Perl module: Demonstration Programs. + (line 35) +* Postscript: Build Options. (line 350) +* Power/PowerPC <1>: Known Build Problems. + (line 63) +* Power/PowerPC: Notes for Particular Systems. + (line 92) +* Powering algorithms: Powering Algorithms. (line 6) +* Powering functions <1>: Float Arithmetic. (line 41) +* Powering functions: Integer Exponentiation. + (line 6) +* PowerPC: ABI and ISA. (line 167) +* Precision of floats: Floating-point Functions. + (line 6) +* Precision of hardware floating point: Notes for Particular Systems. + (line 34) +* Prefix: Build Options. (line 32) +* Prime testing algorithms: Prime Testing Algorithm. + (line 6) +* Prime testing functions: Number Theoretic Functions. + (line 7) +* printf formatted output: Formatted Output. (line 6) +* Probable prime testing functions: Number Theoretic Functions. + (line 7) +* prof: Profiling. (line 24) +* Profiling: Profiling. (line 6) +* Radix conversion algorithms: Radix Conversion Algorithms. + (line 6) +* Random number algorithms: Random Number Algorithms. + (line 6) +* Random number functions <1>: Integer Random Numbers. + (line 6) +* Random number functions <2>: Miscellaneous Float Functions. + (line 27) +* Random number functions: Random Number Functions. + (line 6) +* Random number seeding: Random State Seeding. + (line 6) +* Random number state: Random State Initialization. + (line 6) +* Random state: Nomenclature and Types. + (line 46) +* Rational arithmetic: Efficiency. (line 113) +* Rational arithmetic functions: Rational Arithmetic. (line 6) +* Rational assignment functions: Initializing Rationals. + (line 6) +* Rational comparison functions: Comparing Rationals. (line 6) +* Rational conversion functions: Rational Conversions. + (line 6) +* Rational initialization functions: Initializing Rationals. + (line 6) +* Rational input and output functions: I/O of Rationals. (line 6) +* Rational internals: Rational Internals. (line 6) +* Rational number: Nomenclature and Types. + (line 16) +* Rational number functions: Rational Number Functions. + (line 6) +* Rational numerator and denominator: Applying Integer Functions. + (line 6) +* Rational sign tests: Comparing Rationals. (line 27) +* Raw output internals: Raw Output Internals. + (line 6) +* Reallocations: Efficiency. (line 30) +* Reentrancy: Reentrancy. (line 6) +* References: References. (line 6) +* Remove factor functions: Number Theoretic Functions. + (line 90) +* Reporting bugs: Reporting Bugs. (line 6) +* Root extraction algorithm: Nth Root Algorithm. (line 6) +* Root extraction algorithms: Root Extraction Algorithms. + (line 6) +* Root extraction functions <1>: Float Arithmetic. (line 37) +* Root extraction functions: Integer Roots. (line 6) +* Root testing functions: Integer Roots. (line 36) +* Rounding functions: Miscellaneous Float Functions. + (line 9) +* Sample programs: Demonstration Programs. + (line 6) +* Scan bit functions: Integer Logic and Bit Fiddling. + (line 38) +* scanf formatted input: Formatted Input. (line 6) +* SCO: Known Build Problems. + (line 38) +* Seeding random numbers: Random State Seeding. + (line 6) +* Segmentation violation: Debugging. (line 7) +* Sequent Symmetry: Known Build Problems. + (line 68) +* Services for Unix: Notes for Particular Systems. + (line 51) +* Shared library versioning: Notes for Package Builds. + (line 9) +* Sign tests <1>: Float Comparison. (line 33) +* Sign tests <2>: Integer Comparisons. (line 28) +* Sign tests: Comparing Rationals. (line 27) +* Size in digits: Miscellaneous Integer Functions. + (line 23) +* Small operands: Efficiency. (line 7) +* Solaris <1>: ABI and ISA. (line 201) +* Solaris: Known Build Problems. + (line 78) +* Sparc: Notes for Particular Systems. + (line 108) +* Sparc V9: ABI and ISA. (line 201) +* Special integer functions: Integer Special Functions. + (line 6) +* Square root algorithm: Square Root Algorithm. + (line 6) +* SSE2: Notes for Particular Systems. + (line 132) +* Stack backtrace: Debugging. (line 50) +* Stack overflow <1>: Debugging. (line 7) +* Stack overflow: Build Options. (line 278) +* Static linking: Efficiency. (line 14) +* stdarg.h: Headers and Libraries. + (line 17) +* stdio.h: Headers and Libraries. + (line 11) +* Stripped libraries: Known Build Problems. + (line 28) +* Sun: ABI and ISA. (line 201) +* SunOS: Notes for Particular Systems. + (line 120) +* Systems: Notes for Particular Systems. + (line 6) +* Temporary memory: Build Options. (line 278) +* Texinfo: Build Options. (line 347) +* Text input/output: Efficiency. (line 153) +* Thread safety: Reentrancy. (line 6) +* Toom multiplication <1>: Other Multiplication. + (line 6) +* Toom multiplication <2>: Toom 4-Way Multiplication. + (line 6) +* Toom multiplication: Toom 3-Way Multiplication. + (line 6) +* Types: Nomenclature and Types. + (line 6) +* ui and si functions: Efficiency. (line 50) +* Unbalanced multiplication: Unbalanced Multiplication. + (line 6) +* Upward compatibility: Compatibility with older versions. + (line 6) +* Useful macros and constants: Useful Macros and Constants. + (line 6) +* User-defined precision: Floating-point Functions. + (line 6) +* Valgrind: Debugging. (line 130) +* Variable conventions: Variable Conventions. + (line 6) +* Version number: Useful Macros and Constants. + (line 12) +* Web page: Introduction to GMP. (line 34) +* Windows: Notes for Particular Systems. + (line 56) +* x86: Notes for Particular Systems. + (line 126) +* x87: Notes for Particular Systems. + (line 34) +* XML: Build Options. (line 354) + + +File: gmp.info, Node: Function Index, Prev: Concept Index, Up: Top + +Function and Type Index +*********************** + +[index] +* Menu: + +* __GMP_CC: Useful Macros and Constants. + (line 23) +* __GMP_CFLAGS: Useful Macros and Constants. + (line 24) +* __GNU_MP_VERSION: Useful Macros and Constants. + (line 10) +* __GNU_MP_VERSION_MINOR: Useful Macros and Constants. + (line 11) +* __GNU_MP_VERSION_PATCHLEVEL: Useful Macros and Constants. + (line 12) +* _mpz_realloc: Integer Special Functions. + (line 51) +* abs <1>: C++ Interface Rationals. + (line 43) +* abs <2>: C++ Interface Integers. + (line 42) +* abs: C++ Interface Floats. + (line 70) +* ceil: C++ Interface Floats. + (line 71) +* cmp <1>: C++ Interface Floats. + (line 72) +* cmp <2>: C++ Interface Rationals. + (line 44) +* cmp <3>: C++ Interface Integers. + (line 44) +* cmp: C++ Interface Rationals. + (line 45) +* floor: C++ Interface Floats. + (line 80) +* gcd: BSD Compatible Functions. + (line 82) +* gmp_asprintf: Formatted Output Functions. + (line 65) +* gmp_errno: Random State Initialization. + (line 55) +* GMP_ERROR_INVALID_ARGUMENT: Random State Initialization. + (line 55) +* GMP_ERROR_UNSUPPORTED_ARGUMENT: Random State Initialization. + (line 55) +* gmp_fprintf: Formatted Output Functions. + (line 29) +* gmp_fscanf: Formatted Input Functions. + (line 25) +* GMP_LIMB_BITS: Low-level Functions. (line 508) +* GMP_NAIL_BITS: Low-level Functions. (line 506) +* GMP_NAIL_MASK: Low-level Functions. (line 516) +* GMP_NUMB_BITS: Low-level Functions. (line 507) +* GMP_NUMB_MASK: Low-level Functions. (line 517) +* GMP_NUMB_MAX: Low-level Functions. (line 525) +* gmp_obstack_printf: Formatted Output Functions. + (line 79) +* gmp_obstack_vprintf: Formatted Output Functions. + (line 81) +* gmp_printf: Formatted Output Functions. + (line 24) +* GMP_RAND_ALG_DEFAULT: Random State Initialization. + (line 49) +* GMP_RAND_ALG_LC: Random State Initialization. + (line 49) +* gmp_randclass: C++ Interface Random Numbers. + (line 7) +* gmp_randclass::get_f: C++ Interface Random Numbers. + (line 45) +* gmp_randclass::get_z_bits: C++ Interface Random Numbers. + (line 39) +* gmp_randclass::get_z_range: C++ Interface Random Numbers. + (line 42) +* gmp_randclass::gmp_randclass: C++ Interface Random Numbers. + (line 13) +* gmp_randclass::seed: C++ Interface Random Numbers. + (line 33) +* gmp_randclear: Random State Initialization. + (line 62) +* gmp_randinit: Random State Initialization. + (line 47) +* gmp_randinit_default: Random State Initialization. + (line 7) +* gmp_randinit_lc_2exp: Random State Initialization. + (line 18) +* gmp_randinit_lc_2exp_size: Random State Initialization. + (line 32) +* gmp_randinit_mt: Random State Initialization. + (line 13) +* gmp_randinit_set: Random State Initialization. + (line 43) +* gmp_randseed: Random State Seeding. + (line 7) +* gmp_randseed_ui: Random State Seeding. + (line 9) +* gmp_randstate_t: Nomenclature and Types. + (line 46) +* gmp_scanf: Formatted Input Functions. + (line 21) +* gmp_snprintf: Formatted Output Functions. + (line 46) +* gmp_sprintf: Formatted Output Functions. + (line 34) +* gmp_sscanf: Formatted Input Functions. + (line 29) +* gmp_urandomb_ui: Random State Miscellaneous. + (line 8) +* gmp_urandomm_ui: Random State Miscellaneous. + (line 14) +* gmp_vasprintf: Formatted Output Functions. + (line 66) +* gmp_version: Useful Macros and Constants. + (line 18) +* gmp_vfprintf: Formatted Output Functions. + (line 30) +* gmp_vfscanf: Formatted Input Functions. + (line 26) +* gmp_vprintf: Formatted Output Functions. + (line 25) +* gmp_vscanf: Formatted Input Functions. + (line 22) +* gmp_vsnprintf: Formatted Output Functions. + (line 48) +* gmp_vsprintf: Formatted Output Functions. + (line 35) +* gmp_vsscanf: Formatted Input Functions. + (line 31) +* hypot: C++ Interface Floats. + (line 81) +* itom: BSD Compatible Functions. + (line 29) +* madd: BSD Compatible Functions. + (line 43) +* mcmp: BSD Compatible Functions. + (line 85) +* mdiv: BSD Compatible Functions. + (line 53) +* mfree: BSD Compatible Functions. + (line 105) +* min: BSD Compatible Functions. + (line 89) +* MINT: BSD Compatible Functions. + (line 21) +* mout: BSD Compatible Functions. + (line 94) +* move: BSD Compatible Functions. + (line 39) +* mp_bitcnt_t: Nomenclature and Types. + (line 42) +* mp_bits_per_limb: Useful Macros and Constants. + (line 7) +* mp_exp_t: Nomenclature and Types. + (line 27) +* mp_get_memory_functions: Custom Allocation. (line 93) +* mp_limb_t: Nomenclature and Types. + (line 31) +* mp_set_memory_functions: Custom Allocation. (line 21) +* mp_size_t: Nomenclature and Types. + (line 37) +* mpf_abs: Float Arithmetic. (line 47) +* mpf_add: Float Arithmetic. (line 7) +* mpf_add_ui: Float Arithmetic. (line 9) +* mpf_ceil: Miscellaneous Float Functions. + (line 7) +* mpf_class: C++ Interface General. + (line 20) +* mpf_class::fits_sint_p: C++ Interface Floats. + (line 74) +* mpf_class::fits_slong_p: C++ Interface Floats. + (line 75) +* mpf_class::fits_sshort_p: C++ Interface Floats. + (line 76) +* mpf_class::fits_uint_p: C++ Interface Floats. + (line 77) +* mpf_class::fits_ulong_p: C++ Interface Floats. + (line 78) +* mpf_class::fits_ushort_p: C++ Interface Floats. + (line 79) +* mpf_class::get_d: C++ Interface Floats. + (line 82) +* mpf_class::get_mpf_t: C++ Interface General. + (line 66) +* mpf_class::get_prec: C++ Interface Floats. + (line 100) +* mpf_class::get_si: C++ Interface Floats. + (line 83) +* mpf_class::get_str: C++ Interface Floats. + (line 85) +* mpf_class::get_ui: C++ Interface Floats. + (line 86) +* mpf_class::mpf_class: C++ Interface Floats. + (line 38) +* mpf_class::operator=: C++ Interface Floats. + (line 47) +* mpf_class::set_prec: C++ Interface Floats. + (line 101) +* mpf_class::set_prec_raw: C++ Interface Floats. + (line 102) +* mpf_class::set_str: C++ Interface Floats. + (line 88) +* mpf_clear: Initializing Floats. (line 37) +* mpf_clears: Initializing Floats. (line 41) +* mpf_cmp: Float Comparison. (line 7) +* mpf_cmp_d: Float Comparison. (line 8) +* mpf_cmp_si: Float Comparison. (line 10) +* mpf_cmp_ui: Float Comparison. (line 9) +* mpf_div: Float Arithmetic. (line 29) +* mpf_div_2exp: Float Arithmetic. (line 53) +* mpf_div_ui: Float Arithmetic. (line 33) +* mpf_eq: Float Comparison. (line 17) +* mpf_fits_sint_p: Miscellaneous Float Functions. + (line 20) +* mpf_fits_slong_p: Miscellaneous Float Functions. + (line 18) +* mpf_fits_sshort_p: Miscellaneous Float Functions. + (line 22) +* mpf_fits_uint_p: Miscellaneous Float Functions. + (line 19) +* mpf_fits_ulong_p: Miscellaneous Float Functions. + (line 17) +* mpf_fits_ushort_p: Miscellaneous Float Functions. + (line 21) +* mpf_floor: Miscellaneous Float Functions. + (line 8) +* mpf_get_d: Converting Floats. (line 7) +* mpf_get_d_2exp: Converting Floats. (line 16) +* mpf_get_default_prec: Initializing Floats. (line 12) +* mpf_get_prec: Initializing Floats. (line 62) +* mpf_get_si: Converting Floats. (line 27) +* mpf_get_str: Converting Floats. (line 37) +* mpf_get_ui: Converting Floats. (line 28) +* mpf_init: Initializing Floats. (line 19) +* mpf_init2: Initializing Floats. (line 26) +* mpf_init_set: Simultaneous Float Init & Assign. + (line 16) +* mpf_init_set_d: Simultaneous Float Init & Assign. + (line 19) +* mpf_init_set_si: Simultaneous Float Init & Assign. + (line 18) +* mpf_init_set_str: Simultaneous Float Init & Assign. + (line 25) +* mpf_init_set_ui: Simultaneous Float Init & Assign. + (line 17) +* mpf_inits: Initializing Floats. (line 31) +* mpf_inp_str: I/O of Floats. (line 37) +* mpf_integer_p: Miscellaneous Float Functions. + (line 14) +* mpf_mul: Float Arithmetic. (line 19) +* mpf_mul_2exp: Float Arithmetic. (line 50) +* mpf_mul_ui: Float Arithmetic. (line 21) +* mpf_neg: Float Arithmetic. (line 44) +* mpf_out_str: I/O of Floats. (line 17) +* mpf_pow_ui: Float Arithmetic. (line 41) +* mpf_random2: Miscellaneous Float Functions. + (line 36) +* mpf_reldiff: Float Comparison. (line 29) +* mpf_set: Assigning Floats. (line 10) +* mpf_set_d: Assigning Floats. (line 13) +* mpf_set_default_prec: Initializing Floats. (line 7) +* mpf_set_prec: Initializing Floats. (line 65) +* mpf_set_prec_raw: Initializing Floats. (line 72) +* mpf_set_q: Assigning Floats. (line 15) +* mpf_set_si: Assigning Floats. (line 12) +* mpf_set_str: Assigning Floats. (line 18) +* mpf_set_ui: Assigning Floats. (line 11) +* mpf_set_z: Assigning Floats. (line 14) +* mpf_sgn: Float Comparison. (line 33) +* mpf_sqrt: Float Arithmetic. (line 36) +* mpf_sqrt_ui: Float Arithmetic. (line 37) +* mpf_sub: Float Arithmetic. (line 12) +* mpf_sub_ui: Float Arithmetic. (line 16) +* mpf_swap: Assigning Floats. (line 52) +* mpf_t: Nomenclature and Types. + (line 21) +* mpf_trunc: Miscellaneous Float Functions. + (line 9) +* mpf_ui_div: Float Arithmetic. (line 31) +* mpf_ui_sub: Float Arithmetic. (line 14) +* mpf_urandomb: Miscellaneous Float Functions. + (line 27) +* mpn_add: Low-level Functions. (line 69) +* mpn_add_1: Low-level Functions. (line 64) +* mpn_add_n: Low-level Functions. (line 54) +* mpn_addmul_1: Low-level Functions. (line 148) +* mpn_and_n: Low-level Functions. (line 420) +* mpn_andn_n: Low-level Functions. (line 435) +* mpn_cmp: Low-level Functions. (line 284) +* mpn_com: Low-level Functions. (line 460) +* mpn_copyd: Low-level Functions. (line 469) +* mpn_copyi: Low-level Functions. (line 465) +* mpn_divexact_by3: Low-level Functions. (line 229) +* mpn_divexact_by3c: Low-level Functions. (line 231) +* mpn_divmod: Low-level Functions. (line 224) +* mpn_divmod_1: Low-level Functions. (line 208) +* mpn_divrem: Low-level Functions. (line 182) +* mpn_divrem_1: Low-level Functions. (line 206) +* mpn_gcd: Low-level Functions. (line 289) +* mpn_gcd_1: Low-level Functions. (line 299) +* mpn_gcdext: Low-level Functions. (line 305) +* mpn_get_str: Low-level Functions. (line 346) +* mpn_hamdist: Low-level Functions. (line 410) +* mpn_ior_n: Low-level Functions. (line 425) +* mpn_iorn_n: Low-level Functions. (line 440) +* mpn_lshift: Low-level Functions. (line 260) +* mpn_mod_1: Low-level Functions. (line 255) +* mpn_mul: Low-level Functions. (line 114) +* mpn_mul_1: Low-level Functions. (line 133) +* mpn_mul_n: Low-level Functions. (line 103) +* mpn_nand_n: Low-level Functions. (line 445) +* mpn_neg: Low-level Functions. (line 98) +* mpn_nior_n: Low-level Functions. (line 450) +* mpn_perfect_square_p: Low-level Functions. (line 416) +* mpn_popcount: Low-level Functions. (line 406) +* mpn_random: Low-level Functions. (line 395) +* mpn_random2: Low-level Functions. (line 396) +* mpn_rshift: Low-level Functions. (line 272) +* mpn_scan0: Low-level Functions. (line 380) +* mpn_scan1: Low-level Functions. (line 388) +* mpn_set_str: Low-level Functions. (line 361) +* mpn_sqr: Low-level Functions. (line 125) +* mpn_sqrtrem: Low-level Functions. (line 328) +* mpn_sub: Low-level Functions. (line 90) +* mpn_sub_1: Low-level Functions. (line 85) +* mpn_sub_n: Low-level Functions. (line 76) +* mpn_submul_1: Low-level Functions. (line 159) +* mpn_tdiv_qr: Low-level Functions. (line 171) +* mpn_xnor_n: Low-level Functions. (line 455) +* mpn_xor_n: Low-level Functions. (line 430) +* mpn_zero: Low-level Functions. (line 472) +* mpq_abs: Rational Arithmetic. (line 31) +* mpq_add: Rational Arithmetic. (line 7) +* mpq_canonicalize: Rational Number Functions. + (line 22) +* mpq_class: C++ Interface General. + (line 19) +* mpq_class::canonicalize: C++ Interface Rationals. + (line 37) +* mpq_class::get_d: C++ Interface Rationals. + (line 46) +* mpq_class::get_den: C++ Interface Rationals. + (line 58) +* mpq_class::get_den_mpz_t: C++ Interface Rationals. + (line 68) +* mpq_class::get_mpq_t: C++ Interface General. + (line 65) +* mpq_class::get_num: C++ Interface Rationals. + (line 57) +* mpq_class::get_num_mpz_t: C++ Interface Rationals. + (line 67) +* mpq_class::get_str: C++ Interface Rationals. + (line 47) +* mpq_class::mpq_class: C++ Interface Rationals. + (line 22) +* mpq_class::set_str: C++ Interface Rationals. + (line 49) +* mpq_clear: Initializing Rationals. + (line 16) +* mpq_clears: Initializing Rationals. + (line 20) +* mpq_cmp: Comparing Rationals. (line 7) +* mpq_cmp_si: Comparing Rationals. (line 17) +* mpq_cmp_ui: Comparing Rationals. (line 15) +* mpq_denref: Applying Integer Functions. + (line 18) +* mpq_div: Rational Arithmetic. (line 22) +* mpq_div_2exp: Rational Arithmetic. (line 25) +* mpq_equal: Comparing Rationals. (line 33) +* mpq_get_d: Rational Conversions. + (line 7) +* mpq_get_den: Applying Integer Functions. + (line 24) +* mpq_get_num: Applying Integer Functions. + (line 23) +* mpq_get_str: Rational Conversions. + (line 22) +* mpq_init: Initializing Rationals. + (line 7) +* mpq_inits: Initializing Rationals. + (line 12) +* mpq_inp_str: I/O of Rationals. (line 23) +* mpq_inv: Rational Arithmetic. (line 34) +* mpq_mul: Rational Arithmetic. (line 15) +* mpq_mul_2exp: Rational Arithmetic. (line 18) +* mpq_neg: Rational Arithmetic. (line 28) +* mpq_numref: Applying Integer Functions. + (line 17) +* mpq_out_str: I/O of Rationals. (line 15) +* mpq_set: Initializing Rationals. + (line 24) +* mpq_set_d: Rational Conversions. + (line 17) +* mpq_set_den: Applying Integer Functions. + (line 26) +* mpq_set_f: Rational Conversions. + (line 18) +* mpq_set_num: Applying Integer Functions. + (line 25) +* mpq_set_si: Initializing Rationals. + (line 31) +* mpq_set_str: Initializing Rationals. + (line 36) +* mpq_set_ui: Initializing Rationals. + (line 29) +* mpq_set_z: Initializing Rationals. + (line 25) +* mpq_sgn: Comparing Rationals. (line 27) +* mpq_sub: Rational Arithmetic. (line 11) +* mpq_swap: Initializing Rationals. + (line 56) +* mpq_t: Nomenclature and Types. + (line 16) +* mpz_abs: Integer Arithmetic. (line 42) +* mpz_add: Integer Arithmetic. (line 7) +* mpz_add_ui: Integer Arithmetic. (line 9) +* mpz_addmul: Integer Arithmetic. (line 25) +* mpz_addmul_ui: Integer Arithmetic. (line 27) +* mpz_and: Integer Logic and Bit Fiddling. + (line 11) +* mpz_array_init: Integer Special Functions. + (line 11) +* mpz_bin_ui: Number Theoretic Functions. + (line 98) +* mpz_bin_uiui: Number Theoretic Functions. + (line 100) +* mpz_cdiv_q: Integer Division. (line 13) +* mpz_cdiv_q_2exp: Integer Division. (line 24) +* mpz_cdiv_q_ui: Integer Division. (line 17) +* mpz_cdiv_qr: Integer Division. (line 15) +* mpz_cdiv_qr_ui: Integer Division. (line 21) +* mpz_cdiv_r: Integer Division. (line 14) +* mpz_cdiv_r_2exp: Integer Division. (line 25) +* mpz_cdiv_r_ui: Integer Division. (line 19) +* mpz_cdiv_ui: Integer Division. (line 23) +* mpz_class: C++ Interface General. + (line 18) +* mpz_class::fits_sint_p: C++ Interface Integers. + (line 45) +* mpz_class::fits_slong_p: C++ Interface Integers. + (line 46) +* mpz_class::fits_sshort_p: C++ Interface Integers. + (line 47) +* mpz_class::fits_uint_p: C++ Interface Integers. + (line 48) +* mpz_class::fits_ulong_p: C++ Interface Integers. + (line 49) +* mpz_class::fits_ushort_p: C++ Interface Integers. + (line 50) +* mpz_class::get_d: C++ Interface Integers. + (line 51) +* mpz_class::get_mpz_t: C++ Interface General. + (line 64) +* mpz_class::get_si: C++ Interface Integers. + (line 52) +* mpz_class::get_str: C++ Interface Integers. + (line 53) +* mpz_class::get_ui: C++ Interface Integers. + (line 54) +* mpz_class::mpz_class: C++ Interface Integers. + (line 7) +* mpz_class::set_str: C++ Interface Integers. + (line 56) +* mpz_clear: Initializing Integers. + (line 44) +* mpz_clears: Initializing Integers. + (line 48) +* mpz_clrbit: Integer Logic and Bit Fiddling. + (line 54) +* mpz_cmp: Integer Comparisons. (line 7) +* mpz_cmp_d: Integer Comparisons. (line 8) +* mpz_cmp_si: Integer Comparisons. (line 9) +* mpz_cmp_ui: Integer Comparisons. (line 10) +* mpz_cmpabs: Integer Comparisons. (line 18) +* mpz_cmpabs_d: Integer Comparisons. (line 19) +* mpz_cmpabs_ui: Integer Comparisons. (line 20) +* mpz_com: Integer Logic and Bit Fiddling. + (line 20) +* mpz_combit: Integer Logic and Bit Fiddling. + (line 57) +* mpz_congruent_2exp_p: Integer Division. (line 124) +* mpz_congruent_p: Integer Division. (line 121) +* mpz_congruent_ui_p: Integer Division. (line 123) +* mpz_divexact: Integer Division. (line 101) +* mpz_divexact_ui: Integer Division. (line 102) +* mpz_divisible_2exp_p: Integer Division. (line 112) +* mpz_divisible_p: Integer Division. (line 110) +* mpz_divisible_ui_p: Integer Division. (line 111) +* mpz_even_p: Miscellaneous Integer Functions. + (line 18) +* mpz_export: Integer Import and Export. + (line 45) +* mpz_fac_ui: Number Theoretic Functions. + (line 95) +* mpz_fdiv_q: Integer Division. (line 27) +* mpz_fdiv_q_2exp: Integer Division. (line 38) +* mpz_fdiv_q_ui: Integer Division. (line 31) +* mpz_fdiv_qr: Integer Division. (line 29) +* mpz_fdiv_qr_ui: Integer Division. (line 35) +* mpz_fdiv_r: Integer Division. (line 28) +* mpz_fdiv_r_2exp: Integer Division. (line 39) +* mpz_fdiv_r_ui: Integer Division. (line 33) +* mpz_fdiv_ui: Integer Division. (line 37) +* mpz_fib2_ui: Number Theoretic Functions. + (line 108) +* mpz_fib_ui: Number Theoretic Functions. + (line 106) +* mpz_fits_sint_p: Miscellaneous Integer Functions. + (line 10) +* mpz_fits_slong_p: Miscellaneous Integer Functions. + (line 8) +* mpz_fits_sshort_p: Miscellaneous Integer Functions. + (line 12) +* mpz_fits_uint_p: Miscellaneous Integer Functions. + (line 9) +* mpz_fits_ulong_p: Miscellaneous Integer Functions. + (line 7) +* mpz_fits_ushort_p: Miscellaneous Integer Functions. + (line 11) +* mpz_gcd: Number Theoretic Functions. + (line 30) +* mpz_gcd_ui: Number Theoretic Functions. + (line 35) +* mpz_gcdext: Number Theoretic Functions. + (line 45) +* mpz_get_d: Converting Integers. (line 27) +* mpz_get_d_2exp: Converting Integers. (line 35) +* mpz_get_si: Converting Integers. (line 18) +* mpz_get_str: Converting Integers. (line 46) +* mpz_get_ui: Converting Integers. (line 11) +* mpz_getlimbn: Integer Special Functions. + (line 60) +* mpz_hamdist: Integer Logic and Bit Fiddling. + (line 29) +* mpz_import: Integer Import and Export. + (line 11) +* mpz_init: Initializing Integers. + (line 26) +* mpz_init2: Initializing Integers. + (line 33) +* mpz_init_set: Simultaneous Integer Init & Assign. + (line 27) +* mpz_init_set_d: Simultaneous Integer Init & Assign. + (line 30) +* mpz_init_set_si: Simultaneous Integer Init & Assign. + (line 29) +* mpz_init_set_str: Simultaneous Integer Init & Assign. + (line 34) +* mpz_init_set_ui: Simultaneous Integer Init & Assign. + (line 28) +* mpz_inits: Initializing Integers. + (line 29) +* mpz_inp_raw: I/O of Integers. (line 59) +* mpz_inp_str: I/O of Integers. (line 28) +* mpz_invert: Number Theoretic Functions. + (line 60) +* mpz_ior: Integer Logic and Bit Fiddling. + (line 14) +* mpz_jacobi: Number Theoretic Functions. + (line 66) +* mpz_kronecker: Number Theoretic Functions. + (line 74) +* mpz_kronecker_si: Number Theoretic Functions. + (line 75) +* mpz_kronecker_ui: Number Theoretic Functions. + (line 76) +* mpz_lcm: Number Theoretic Functions. + (line 54) +* mpz_lcm_ui: Number Theoretic Functions. + (line 55) +* mpz_legendre: Number Theoretic Functions. + (line 69) +* mpz_lucnum2_ui: Number Theoretic Functions. + (line 119) +* mpz_lucnum_ui: Number Theoretic Functions. + (line 117) +* mpz_mod: Integer Division. (line 91) +* mpz_mod_ui: Integer Division. (line 93) +* mpz_mul: Integer Arithmetic. (line 19) +* mpz_mul_2exp: Integer Arithmetic. (line 35) +* mpz_mul_si: Integer Arithmetic. (line 20) +* mpz_mul_ui: Integer Arithmetic. (line 22) +* mpz_neg: Integer Arithmetic. (line 39) +* mpz_nextprime: Number Theoretic Functions. + (line 23) +* mpz_odd_p: Miscellaneous Integer Functions. + (line 17) +* mpz_out_raw: I/O of Integers. (line 43) +* mpz_out_str: I/O of Integers. (line 16) +* mpz_perfect_power_p: Integer Roots. (line 27) +* mpz_perfect_square_p: Integer Roots. (line 36) +* mpz_popcount: Integer Logic and Bit Fiddling. + (line 23) +* mpz_pow_ui: Integer Exponentiation. + (line 31) +* mpz_powm: Integer Exponentiation. + (line 8) +* mpz_powm_sec: Integer Exponentiation. + (line 18) +* mpz_powm_ui: Integer Exponentiation. + (line 10) +* mpz_probab_prime_p: Number Theoretic Functions. + (line 7) +* mpz_random: Integer Random Numbers. + (line 42) +* mpz_random2: Integer Random Numbers. + (line 51) +* mpz_realloc2: Initializing Integers. + (line 52) +* mpz_remove: Number Theoretic Functions. + (line 90) +* mpz_root: Integer Roots. (line 7) +* mpz_rootrem: Integer Roots. (line 13) +* mpz_rrandomb: Integer Random Numbers. + (line 31) +* mpz_scan0: Integer Logic and Bit Fiddling. + (line 37) +* mpz_scan1: Integer Logic and Bit Fiddling. + (line 38) +* mpz_set: Assigning Integers. (line 10) +* mpz_set_d: Assigning Integers. (line 13) +* mpz_set_f: Assigning Integers. (line 15) +* mpz_set_q: Assigning Integers. (line 14) +* mpz_set_si: Assigning Integers. (line 12) +* mpz_set_str: Assigning Integers. (line 21) +* mpz_set_ui: Assigning Integers. (line 11) +* mpz_setbit: Integer Logic and Bit Fiddling. + (line 51) +* mpz_sgn: Integer Comparisons. (line 28) +* mpz_si_kronecker: Number Theoretic Functions. + (line 77) +* mpz_size: Integer Special Functions. + (line 68) +* mpz_sizeinbase: Miscellaneous Integer Functions. + (line 23) +* mpz_sqrt: Integer Roots. (line 17) +* mpz_sqrtrem: Integer Roots. (line 20) +* mpz_sub: Integer Arithmetic. (line 12) +* mpz_sub_ui: Integer Arithmetic. (line 14) +* mpz_submul: Integer Arithmetic. (line 30) +* mpz_submul_ui: Integer Arithmetic. (line 32) +* mpz_swap: Assigning Integers. (line 37) +* mpz_t: Nomenclature and Types. + (line 6) +* mpz_tdiv_q: Integer Division. (line 41) +* mpz_tdiv_q_2exp: Integer Division. (line 52) +* mpz_tdiv_q_ui: Integer Division. (line 45) +* mpz_tdiv_qr: Integer Division. (line 43) +* mpz_tdiv_qr_ui: Integer Division. (line 49) +* mpz_tdiv_r: Integer Division. (line 42) +* mpz_tdiv_r_2exp: Integer Division. (line 53) +* mpz_tdiv_r_ui: Integer Division. (line 47) +* mpz_tdiv_ui: Integer Division. (line 51) +* mpz_tstbit: Integer Logic and Bit Fiddling. + (line 60) +* mpz_ui_kronecker: Number Theoretic Functions. + (line 78) +* mpz_ui_pow_ui: Integer Exponentiation. + (line 33) +* mpz_ui_sub: Integer Arithmetic. (line 16) +* mpz_urandomb: Integer Random Numbers. + (line 14) +* mpz_urandomm: Integer Random Numbers. + (line 23) +* mpz_xor: Integer Logic and Bit Fiddling. + (line 17) +* msqrt: BSD Compatible Functions. + (line 63) +* msub: BSD Compatible Functions. + (line 46) +* mtox: BSD Compatible Functions. + (line 98) +* mult: BSD Compatible Functions. + (line 49) +* operator%: C++ Interface Integers. + (line 30) +* operator/: C++ Interface Integers. + (line 29) +* operator<<: C++ Formatted Output. + (line 20) +* operator>> <1>: C++ Formatted Input. (line 11) +* operator>>: C++ Interface Rationals. + (line 77) +* pow: BSD Compatible Functions. + (line 71) +* rpow: BSD Compatible Functions. + (line 79) +* sdiv: BSD Compatible Functions. + (line 55) +* sgn <1>: C++ Interface Rationals. + (line 50) +* sgn <2>: C++ Interface Integers. + (line 57) +* sgn: C++ Interface Floats. + (line 89) +* sqrt <1>: C++ Interface Integers. + (line 58) +* sqrt: C++ Interface Floats. + (line 90) +* trunc: C++ Interface Floats. + (line 91) +* xtom: BSD Compatible Functions. + (line 34) + + -- 2.39.2