ApfelTeeSaft/reactos
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/reactos.git synced 2026-09-02 04:13:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Create this branch to work on loading of different Kernel-Debugger DLL providers, and see whether it is possible to move KDBG from ntoskrnl to a new DLL called, say, KDROSDBG.DLL.

Browse Source 
The idea then would be to have the following behaviour (when specifying the following options in the kernel command line):

/DEBUGPORT=COMi --> load KDCOM.DLL and use COMi port (i == 1,2,3,4) if possible.
/DEBUGPORT=FOO  --> load KDFOO.DLL (useful for KDUSB.DLL, KD1394.DLL, KDBAZIS.DLL for VirtualKD, etc...)
/DEBUGPORT=ROSDBG:[COMi|SCREEN|FILE|GDB|...] --> load KDROSDBG.DLL which contains the ROS kernel debugger, and use COMi or SCREEN or... as output port.

svn path=/branches/kd++/; revision=58883
This commit is contained in:
Hermès Bélusca-Maïto
2013-04-28 13:26:45 +00:00
parent 1a40619b16
commit e1ef078741
20518 changed files with 0 additions and 1211539 deletions
Download Patch File Download Diff File Expand all files Collapse all files
reactos/include/GL/gl.h
-2236
View File
File diff suppressed because it is too large Load Diff
reactos/include/GL/glext.h
-11823
View File
File diff suppressed because it is too large Load Diff
reactos/include/GL/glu.h
-286
View File
@@ -1,286 +0,0 @@
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
*/
#ifndef __glu_h__
#define __glu_h__
#define _GLU_H
#include <stddef.h> /* for wchar_t */
#include <GL/gl.h>
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************/
/* Boolean */
#define GLU_FALSE 0
#define GLU_TRUE 1
/* Version */
#define GLU_VERSION_1_1 1
#define GLU_VERSION_1_2 1
/* StringName */
#define GLU_VERSION 100800
#define GLU_EXTENSIONS 100801
/* ErrorCode */
#define GLU_INVALID_ENUM 100900
#define GLU_INVALID_VALUE 100901
#define GLU_OUT_OF_MEMORY 100902
#define GLU_INVALID_OPERATION 100904
/* NurbsDisplay */
/* GLU_FILL */
#define GLU_OUTLINE_POLYGON 100240
#define GLU_OUTLINE_PATCH 100241
/* NurbsError */
#define GLU_NURBS_ERROR1 100251
#define GLU_NURBS_ERROR2 100252
#define GLU_NURBS_ERROR3 100253
#define GLU_NURBS_ERROR4 100254
#define GLU_NURBS_ERROR5 100255
#define GLU_NURBS_ERROR6 100256
#define GLU_NURBS_ERROR7 100257
#define GLU_NURBS_ERROR8 100258
#define GLU_NURBS_ERROR9 100259
#define GLU_NURBS_ERROR10 100260
#define GLU_NURBS_ERROR11 100261
#define GLU_NURBS_ERROR12 100262
#define GLU_NURBS_ERROR13 100263
#define GLU_NURBS_ERROR14 100264
#define GLU_NURBS_ERROR15 100265
#define GLU_NURBS_ERROR16 100266
#define GLU_NURBS_ERROR17 100267
#define GLU_NURBS_ERROR18 100268
#define GLU_NURBS_ERROR19 100269
#define GLU_NURBS_ERROR20 100270
#define GLU_NURBS_ERROR21 100271
#define GLU_NURBS_ERROR22 100272
#define GLU_NURBS_ERROR23 100273
#define GLU_NURBS_ERROR24 100274
#define GLU_NURBS_ERROR25 100275
#define GLU_NURBS_ERROR26 100276
#define GLU_NURBS_ERROR27 100277
#define GLU_NURBS_ERROR28 100278
#define GLU_NURBS_ERROR29 100279
#define GLU_NURBS_ERROR30 100280
#define GLU_NURBS_ERROR31 100281
#define GLU_NURBS_ERROR32 100282
#define GLU_NURBS_ERROR33 100283
#define GLU_NURBS_ERROR34 100284
#define GLU_NURBS_ERROR35 100285
#define GLU_NURBS_ERROR36 100286
#define GLU_NURBS_ERROR37 100287
/* NurbsProperty */
#define GLU_AUTO_LOAD_MATRIX 100200
#define GLU_CULLING 100201
#define GLU_SAMPLING_TOLERANCE 100203
#define GLU_DISPLAY_MODE 100204
#define GLU_PARAMETRIC_TOLERANCE 100202
#define GLU_SAMPLING_METHOD 100205
#define GLU_U_STEP 100206
#define GLU_V_STEP 100207
/* NurbsSampling */
#define GLU_PATH_LENGTH 100215
#define GLU_PARAMETRIC_ERROR 100216
#define GLU_DOMAIN_DISTANCE 100217
/* NurbsTrim */
#define GLU_MAP1_TRIM_2 100210
#define GLU_MAP1_TRIM_3 100211
/* QuadricDrawStyle */
#define GLU_POINT 100010
#define GLU_LINE 100011
#define GLU_FILL 100012
#define GLU_SILHOUETTE 100013
/* QuadricCallback */
#define GLU_ERROR 100103
/* QuadricNormal */
#define GLU_SMOOTH 100000
#define GLU_FLAT 100001
#define GLU_NONE 100002
/* QuadricOrientation */
#define GLU_OUTSIDE 100020
#define GLU_INSIDE 100021
/* TessCallback */
#define GLU_TESS_BEGIN 100100
#define GLU_BEGIN 100100
#define GLU_TESS_VERTEX 100101
#define GLU_VERTEX 100101
#define GLU_TESS_END 100102
#define GLU_END 100102
#define GLU_TESS_ERROR 100103
#define GLU_TESS_EDGE_FLAG 100104
#define GLU_EDGE_FLAG 100104
#define GLU_TESS_COMBINE 100105
#define GLU_TESS_BEGIN_DATA 100106
#define GLU_TESS_VERTEX_DATA 100107
#define GLU_TESS_END_DATA 100108
#define GLU_TESS_ERROR_DATA 100109
#define GLU_TESS_EDGE_FLAG_DATA 100110
#define GLU_TESS_COMBINE_DATA 100111
/* TessContour */
#define GLU_CW 100120
#define GLU_CCW 100121
#define GLU_INTERIOR 100122
#define GLU_EXTERIOR 100123
#define GLU_UNKNOWN 100124
/* TessProperty */
#define GLU_TESS_WINDING_RULE 100140
#define GLU_TESS_BOUNDARY_ONLY 100141
#define GLU_TESS_TOLERANCE 100142
/* TessError */
#define GLU_TESS_ERROR1 100151
#define GLU_TESS_ERROR2 100152
#define GLU_TESS_ERROR3 100153
#define GLU_TESS_ERROR4 100154
#define GLU_TESS_ERROR5 100155
#define GLU_TESS_ERROR6 100156
#define GLU_TESS_ERROR7 100157
#define GLU_TESS_ERROR8 100158
#define GLU_TESS_MISSING_BEGIN_POLYGON 100151
#define GLU_TESS_MISSING_BEGIN_CONTOUR 100152
#define GLU_TESS_MISSING_END_POLYGON 100153
#define GLU_TESS_MISSING_END_CONTOUR 100154
#define GLU_TESS_COORD_TOO_LARGE 100155
#define GLU_TESS_NEED_COMBINE_CALLBACK 100156
/* TessWinding */
#define GLU_TESS_WINDING_ODD 100130
#define GLU_TESS_WINDING_NONZERO 100131
#define GLU_TESS_WINDING_POSITIVE 100132
#define GLU_TESS_WINDING_NEGATIVE 100133
#define GLU_TESS_WINDING_ABS_GEQ_TWO 100134
/* Obsolete. For compatibility with previous Sun OpenGL versions */
#define GLU_INCOMPATIBLE_GL_VERSION 100903
/*************************************************************/
#ifdef __cplusplus
class GLUnurbs;
class GLUquadric;
class GLUtesselator;
#else
typedef struct GLUnurbs GLUnurbs;
typedef struct GLUquadric GLUquadric;
typedef struct GLUtesselator GLUtesselator;
#endif
typedef GLUnurbs GLUnurbsObj;
typedef GLUquadric GLUquadricObj;
typedef GLUtesselator GLUtesselatorObj;
typedef GLUtesselator GLUtriangulatorObj;
#define GLU_TESS_MAX_COORD 1.0e150
/* Internal convenience typedefs */
typedef void (APIENTRY *_GLUfuncptr)();
GLAPI void APIENTRY gluBeginCurve (GLUnurbs* nurb);
GLAPI void APIENTRY gluBeginPolygon (GLUtesselator* tess);
GLAPI void APIENTRY gluBeginSurface (GLUnurbs* nurb);
GLAPI void APIENTRY gluBeginTrim (GLUnurbs* nurb);
GLAPI GLint APIENTRY gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data);
GLAPI GLint APIENTRY gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY gluCylinder (GLUquadric* quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks);
GLAPI void APIENTRY gluDeleteNurbsRenderer (GLUnurbs* nurb);
GLAPI void APIENTRY gluDeleteQuadric (GLUquadric* quad);
GLAPI void APIENTRY gluDeleteTess (GLUtesselator* tess);
GLAPI void APIENTRY gluDisk (GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops);
GLAPI void APIENTRY gluEndCurve (GLUnurbs* nurb);
GLAPI void APIENTRY gluEndPolygon (GLUtesselator* tess);
GLAPI void APIENTRY gluEndSurface (GLUnurbs* nurb);
GLAPI void APIENTRY gluEndTrim (GLUnurbs* nurb);
GLAPI const GLubyte * APIENTRY gluErrorString (GLenum error);
GLAPI const wchar_t * APIENTRY gluErrorUnicodeStringEXT (GLenum error);
GLAPI void APIENTRY gluGetNurbsProperty (GLUnurbs* nurb, GLenum property, GLfloat* data);
GLAPI const GLubyte * APIENTRY gluGetString (GLenum name);
GLAPI void APIENTRY gluGetTessProperty (GLUtesselator* tess, GLenum which, GLdouble* data);
GLAPI void APIENTRY gluLoadSamplingMatrices (GLUnurbs* nurb, const GLfloat *model, const GLfloat *perspective, const GLint *view);
GLAPI void APIENTRY gluLookAt (GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ);
GLAPI GLUnurbs* APIENTRY gluNewNurbsRenderer (void);
GLAPI GLUquadric* APIENTRY gluNewQuadric (void);
GLAPI GLUtesselator* APIENTRY gluNewTess (void);
GLAPI void APIENTRY gluNextContour (GLUtesselator* tess, GLenum type);
GLAPI void APIENTRY gluNurbsCallback (GLUnurbs* nurb, GLenum which, _GLUfuncptr CallBackFunc);
GLAPI void APIENTRY gluNurbsCurve (GLUnurbs* nurb, GLint knotCount, GLfloat *knots, GLint stride, GLfloat *control, GLint order, GLenum type);
GLAPI void APIENTRY gluNurbsProperty (GLUnurbs* nurb, GLenum property, GLfloat value);
GLAPI void APIENTRY gluNurbsSurface (GLUnurbs* nurb, GLint sKnotCount, GLfloat* sKnots, GLint tKnotCount, GLfloat* tKnots, GLint sStride, GLint tStride, GLfloat* control, GLint sOrder, GLint tOrder, GLenum type);
GLAPI void APIENTRY gluOrtho2D (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);
GLAPI void APIENTRY gluPartialDisk (GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep);
GLAPI void APIENTRY gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
GLAPI void APIENTRY gluPickMatrix (GLdouble x, GLdouble y, GLdouble delX, GLdouble delY, GLint *viewport);
GLAPI GLint APIENTRY gluProject (GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble* winX, GLdouble* winY, GLdouble* winZ);
GLAPI void APIENTRY gluPwlCurve (GLUnurbs* nurb, GLint count, GLfloat* data, GLint stride, GLenum type);
GLAPI void APIENTRY gluQuadricCallback (GLUquadric* quad, GLenum which, _GLUfuncptr CallBackFunc);
GLAPI void APIENTRY gluQuadricDrawStyle (GLUquadric* quad, GLenum draw);
GLAPI void APIENTRY gluQuadricNormals (GLUquadric* quad, GLenum normal);
GLAPI void APIENTRY gluQuadricOrientation (GLUquadric* quad, GLenum orientation);
GLAPI void APIENTRY gluQuadricTexture (GLUquadric* quad, GLboolean texture);
GLAPI GLint APIENTRY gluScaleImage (GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid* dataOut);
GLAPI void APIENTRY gluSphere (GLUquadric* quad, GLdouble radius, GLint slices, GLint stacks);
GLAPI void APIENTRY gluTessBeginContour (GLUtesselator* tess);
GLAPI void APIENTRY gluTessBeginPolygon (GLUtesselator* tess, GLvoid* data);
GLAPI void APIENTRY gluTessCallback (GLUtesselator* tess, GLenum which, _GLUfuncptr CallBackFunc);
GLAPI void APIENTRY gluTessEndContour (GLUtesselator* tess);
GLAPI void APIENTRY gluTessEndPolygon (GLUtesselator* tess);
GLAPI void APIENTRY gluTessNormal (GLUtesselator* tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ);
GLAPI void APIENTRY gluTessProperty (GLUtesselator* tess, GLenum which, GLdouble data);
GLAPI void APIENTRY gluTessVertex (GLUtesselator* tess, GLdouble *location, GLvoid* data);
GLAPI GLint APIENTRY gluUnProject (GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble* objX, GLdouble* objY, GLdouble* objZ);
GLAPI GLint APIENTRY gluUnProject4 (GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble nearVal, GLdouble farVal, GLdouble* objX, GLdouble* objY, GLdouble* objZ, GLdouble* objW);
#ifdef UNICODE
#define gluErrorStringWIN gluErrorUnicodeStringEXT
#else
#define gluErrorStringWIN gluErrorString
#endif
#ifdef __cplusplus
}
#endif
#endif /* __glu_h__ */
reactos/include/asm/CMakeLists.txt
-27
View File
@@ -1,27 +0,0 @@
add_library(genincdata SHARED genincdata.c)
set_entrypoint(genincdata 0)
add_dependencies(genincdata bugcodes)
if(MSVC)
set(OPT_MS "-ms")
else()
set(OPT_MS "")
endif()
if(ARCH STREQUAL "i386")
set(_filename ks386)
elseif(ARCH STREQUAL "amd64")
set(_filename ksamd64)
endif()
get_target_property(genincdata_dll genincdata LOCATION)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_filename}.inc
COMMAND native-geninc ${genincdata_dll} ${CMAKE_CURRENT_BINARY_DIR}/${_filename}.inc ${OPT_MS}
DEPENDS genincdata native-geninc)
add_custom_target(asm
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_filename}.inc)
reactos/include/asm/asm.inc
-352
View File
@@ -1,352 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel
* FILE: ntoskrnl/include/amd64/asmmacro.S
* PURPOSE: ASM macros for for GAS and MASM/ML64
* PROGRAMMERS: Timo Kreuzer ([email protected])
*/
#ifdef _USE_ML
/* Allow ".name" identifiers */
OPTION DOTNAME
#ifdef _M_IX86
.686P
.XMM
.MODEL FLAT
ASSUME CS:NOTHING, DS:NOTHING, ES:NOTHING, FS:NOTHING, GS:NOTHING
#endif
/* Hex numbers need to be in 01ABh format */
#define HEX(x) 0##x##h
/* Macro values need to be marked */
#define VAL(x) x
/* MASM/ML doesn't want explicit [rip] addressing */
rip = 0
/* Due to MASM's reverse syntax, we are forced to use a precompiler macro */
#define MACRO(name, ...) name MACRO __VA_ARGS__
/* To avoid reverse syntax we provide a new macro .PROC, replacing PROC... */
.PROC MACRO name
__current_function_name EQU %name
#ifdef _M_IX86
%name PROC
#else
%name PROC FRAME
#endif
ENDM
#define FUNC .PROC
/* ... and .ENDP, replacing ENDP */
.ENDP MACRO
%__current_function_name ENDP
ENDM
#define ENDFUNC .ENDP
/* check http://msdn.microsoft.com/en-us/library/9c9k076y%28VS.80%29.aspx
and http://msdn.microsoft.com/en-us/library/ms679352%28VS.85%29.aspx */
FPO MACRO cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame
.FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame)
ENDM
/* MASM doesn't have an ASCII macro */
.ASCII MACRO text:VARARG
DB text
ENDM
.ascii MACRO text:VARARG
DB text
ENDM
/* MASM doesn't have an ASCIZ macro */
.ASCIZ MACRO text:VARARG
DB text
DB 0
ENDM
.asciz MACRO text:VARARG
DB text
DB 0
ENDM
.code64 MACRO
.code
ENDM
.code32 MACRO
.code
.586P
ENDM
.code16 MACRO
ASSUME nothing
.text SEGMENT use16
.586P
ENDM
.endcode16 MACRO
.text ENDS
ENDM
.bss MACRO
.DATA?
ASSUME nothing
ENDM
//.text MACRO
//ENDM
.align MACRO alignment
ALIGN alignment
ENDM
.byte MACRO args:VARARG
db args
ENDM
.short MACRO args:VARARG
dw args
ENDM
.word MACRO args:VARARG
dw args
ENDM
.long MACRO args:VARARG
dd args
ENDM
.double MACRO args:VARARG
dq args
ENDM
.org MACRO value
ORG value
ENDM
.fill MACRO count, size, value
REPEAT count
if (size EQ 1)
DB value
elseif (size EQ 2)
DW value
elseif (size EQ 4)
DD value
endif
ENDM
ENDM
.space MACRO count
DB 0 DUP (count)
ENDM
ljmp MACRO segment, offset
DB 0EAh
DD offset
DW segment
ENDM
ljmp16 MACRO segment, offset
DB 0EAh
DW offset
DW segment
ENDM
data32 MACRO opcode:VARARG
DB 66h
opcode
ENDM
UNIMPLEMENTED MACRO name
ENDM
absolute MACRO address
__absolute__address__ = address
ENDM
resb MACRO name, size
name = __absolute__address__
__absolute__address__ = __absolute__address__ + size
ENDM
/* We need this to distinguish repeat from macros */
#define ENDR ENDM
#define CR 13
#define LF 10
#define NUL 0
#else /***********************************************************************/
/* Force intel syntax */
.intel_syntax noprefix
.altmacro
/* Hex numbers need to be in 0x1AB format */
#define HEX(y) 0x##y
/* Macro values need to be marked */
#define VAL(x) \x
/* Due to MASM's reverse syntax, we are forced to use a precompiler macro */
#define MACRO(...) .macro __VA_ARGS__
#define ENDM .endm
/* To avoid reverse syntax we provide a new macro .PROC, replacing PROC... */
.macro .PROC name
.func \name
#ifdef _X86_
/* x86 gas expects a label with _ prefix */
_\name:
#endif
\name:
.cfi_startproc
.equ cfa_current_offset, -8
.endm
#define FUNC .PROC
/* ... and .ENDP, replacing ENDP */
.macro .ENDP
.cfi_endproc
.endfunc
.endm
#define ENDFUNC .ENDP
/* MASM compatible PUBLIC */
.macro PUBLIC symbol
.global \symbol
.endm
/* Dummy ASSUME */
.macro ASSUME p1 p2 p3 p4 p5 p6 p7 p8
.endm
/* MASM needs an end tag for segments */
.macro .endcode16
.endm
/* MASM compatible ALIGN */
#define ALIGN .align
/* MASM compatible REPEAT, additional ENDR */
#define REPEAT .rept
#define ENDR .endr
.macro ljmp segment, offset
jmp far ptr \segment:\offset
.endm
.macro ljmp16 segment, offset
jmp far ptr \segment:\offset
.endm
/* MASM compatible EXTERN */
.macro EXTERN name
.endm
/* MASM needs an END tag */
#define END
.macro .MODEL model
.endm
.macro .code
.text
.endm
/* check http://msdn.microsoft.com/en-us/library/9c9k076y%28VS.80%29.aspx
and http://msdn.microsoft.com/en-us/library/ms679352%28VS.85%29.aspx */
.macro FPO cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame
/* dummy */
.endm
/* Macros for x64 stack unwind OPs */
.macro .allocstack size
.cfi_adjust_cfa_offset \size
.set cfa_current_offset, cfa_current_offset - \size
.endm
code = 1
.macro .pushframe param=0
.if (\param)
.cfi_adjust_cfa_offset 0x30
.set cfa_current_offset, cfa_current_offset - 0x30
.else
.cfi_adjust_cfa_offset 0x28
.set cfa_current_offset, cfa_current_offset - 0x28
.endif
.endm
.macro .pushreg reg
.cfi_adjust_cfa_offset 8
.equ cfa_current_offset, cfa_current_offset - 8
.cfi_offset \reg, cfa_current_offset
.endm
.macro .savereg reg, offset
// checkme!!!
.cfi_offset \reg, \offset
.endm
.macro .savexmm128 reg, offset
// checkme!!!
.cfi_offset \reg, \offset
.endm
.macro .setframe reg, offset
.cfi_def_cfa reg, \offset
.equ cfa_current_offset, \offset
.endm
.macro .endprolog
.endm
.macro absolute address
__absolute__address__ = \address
ENDM
.macro resb name, size
\name = __absolute__address__
__absolute__address__ = __absolute__address__ + \size
ENDM
.macro UNIMPLEMENTED2 file, line, func
jmp 3f
1: .asciz "\func"
2: .asciz \file
3:
sub rsp, 0x20
lea rcx, MsgUnimplemented[rip]
lea rdx, 1b[rip]
lea r8, 2b[rip]
mov r9, \line
call DbgPrint
add rsp, 0x20
.endm
#define UNIMPLEMENTED UNIMPLEMENTED2 __FILE__, __LINE__,
/* MASM/ML uses ".if" for runtime conditionals, and "if" for compile time
conditionals. We therefore use "if", too. .if shouldn't be used at all */
#define if .if
#define endif .endif
#define else .else
#define elseif .elseif
#define CR "\r"
#define LF "\n"
#define NUL "\0"
#endif
/* Common definitions for FPO macro
see http://msdn.microsoft.com/en-us/library/ms679352%28VS.85%29.aspx */
#define FRAME_FPO 0
#define FRAME_TRAP 1
#define FRAME_TSS 2
#define FRAME_NONFPO 3
reactos/include/asm/genincdata.c
-91
View File
@@ -1,91 +0,0 @@
#undef __MSVCRT__
#include <psdk/ntverp.h>
/* DDK/IFS/NDK Headers */
#include <excpt.h>
#include <setjmp.h>
#include <ntdef.h>
#include <ntifs.h>
#include <arc/arc.h>
#include <ntndk.h>
#include <bugcodes.h>
/* KD Support */
#define NOEXTAPI
#include <windbgkd.h>
#include <wdbgexts.h>
#include <kddll.h>
#ifdef _M_AMD64
enum
{
P1Home = 1 * sizeof(PVOID),
P2Home = 2 * sizeof(PVOID),
P3Home = 3 * sizeof(PVOID),
P4Home = 4 * sizeof(PVOID),
};
#endif
// FIXME: where to put this?
typedef struct _FIBER /* Field offsets: */
{ /* 32 bit 64 bit */
/* this must be the first field */
PVOID Parameter; /* 0x00 0x00 */
PEXCEPTION_REGISTRATION_RECORD ExceptionList; /* 0x04 0x08 */
PVOID StackBase; /* 0x08 0x10 */
PVOID StackLimit; /* 0x0C 0x18 */
PVOID DeallocationStack; /* 0x10 0x20 */
CONTEXT Context; /* 0x14 0x28 */
ULONG GuaranteedStackBytes; /* 0x2E0 */
PVOID FlsData; /* 0x2E4 */
PVOID /* PACTIVATION_CONTEXT_STACK */ ActivationContextStack; /* 0x2E8 */
} FIBER, *PFIBER;
typedef struct
{
char Type;
char Name[55];
ULONGLONG Value;
} ASMGENDATA;
#define TYPE_END 0
#define TYPE_RAW 1
#define TYPE_CONSTANT 2
#define TYPE_HEADER 3
#define RAW(x) {TYPE_RAW, x, 0}
#define CONSTANT(name) {TYPE_CONSTANT, #name, (ULONG)name}
#define CONSTANT64(name) {TYPE_CONSTANT, #name, (ULONGLONG)name}
#define CONSTANTPTR(name) {TYPE_CONSTANT, #name, (ULONG_PTR)name}
#define CONSTANTX(name, value) {TYPE_CONSTANT, #name, value}
#define OFFSET(name, struct, member) {TYPE_CONSTANT, #name, FIELD_OFFSET(struct, member)}
#define RELOFFSET(name, struct, member, to) {TYPE_CONSTANT, #name, FIELD_OFFSET(struct, member) - FIELD_OFFSET(struct, to)}
#define SIZE(name, struct) {TYPE_CONSTANT, #name, sizeof(struct)}
#define HEADER(x) {TYPE_HEADER, x, 0}
#if defined(_MSC_VER)
#pragma section(".asmdef")
__declspec(allocate(".asmdef"))
#elif defined(__GNUC__)
__attribute__ ((section(".asmdef")))
#else
#error Your compiler is not supported.
#endif
ASMGENDATA Table[] =
{
/* PORTABLE CONSTANTS ********************************************************/
#include "ksx.template.h"
/* ARCHITECTURE SPECIFIC CONTSTANTS ******************************************/
#ifdef _M_IX86
#include "ks386.template.h"
#elif defined(_M_AMD64)
#include "ksamd64.template.h"
#endif
/* End of list */
{TYPE_END, "", 0}
};
reactos/include/asm/ks386.template.h
-468
View File
@@ -1,468 +0,0 @@
HEADER("CR0 flags"),
CONSTANT(CR0_PE),
CONSTANT(CR0_MP),
CONSTANT(CR0_EM),
CONSTANT(CR0_TS),
CONSTANT(CR0_ET),
CONSTANT(CR0_NE),
CONSTANT(CR0_WP),
CONSTANT(CR0_AM),
CONSTANT(CR0_NW),
CONSTANT(CR0_CD),
CONSTANT(CR0_PG),
HEADER("CR4 flags"),
CONSTANT(CR4_VME),
CONSTANT(CR4_PVI),
CONSTANT(CR4_TSD),
CONSTANT(CR4_DE),
CONSTANT(CR4_PSE),
CONSTANT(CR4_PAE),
CONSTANT(CR4_MCE),
CONSTANT(CR4_PGE),
CONSTANT(CR4_FXSR),
CONSTANT(CR4_XMMEXCPT),
//CONSTANT(CR4_PGE_V),
//CONSTANT(CR4_XSAVE),
HEADER("KeFeatureBits flags"),
CONSTANT(KF_RDTSC),
CONSTANT(KF_CR4),
CONSTANT(KF_GLOBAL_PAGE),
CONSTANT(KF_LARGE_PAGE),
CONSTANT(KF_CMPXCHG8B),
CONSTANT(KF_FAST_SYSCALL),
CONSTANT(KF_V86_VIS),
//CONSTANT(KF_XSTATE),
HEADER("Machine type definitions"),
CONSTANT(MACHINE_TYPE_ISA),
CONSTANT(MACHINE_TYPE_EISA),
CONSTANT(MACHINE_TYPE_MCA),
HEADER("EFLAGS"),
CONSTANT(EFLAGS_TF),
CONSTANT(EFLAGS_INTERRUPT_MASK),
CONSTANT(EFLAGS_V86_MASK),
CONSTANT(EFLAGS_ALIGN_CHECK),
CONSTANT(EFLAGS_VIF),
CONSTANT(EFLAGS_VIP),
CONSTANT(EFLAGS_USER_SANITIZE),
HEADER("KDGT selectors"),
CONSTANT(KGDT_R3_DATA),
CONSTANT(KGDT_R3_CODE),
CONSTANT(KGDT_R0_CODE),
CONSTANT(KGDT_R0_DATA),
CONSTANT(KGDT_R0_PCR),
//CONSTANT(KGDT_STACK16),
//CONSTANT(KGDT_CODE16),
CONSTANT(KGDT_TSS),
CONSTANT(KGDT_R3_TEB),
CONSTANT(KGDT_DF_TSS),
CONSTANT(KGDT_NMI_TSS),
CONSTANT(KGDT_LDT),
CONSTANT(NPX_STATE_NOT_LOADED),
CONSTANT(NPX_STATE_LOADED),
//CONSTANT(NPX_MASK_LAZY),
/*
HEADER("VDM constants"),
CONSTANT(VDM_INDEX_Invalid),
CONSTANT(VDM_INDEX_0F),
CONSTANT(VDM_INDEX_ESPrefix),
CONSTANT(VDM_INDEX_CSPrefix),
CONSTANT(VDM_INDEX_SSPrefix),
CONSTANT(VDM_INDEX_DSPrefix),
CONSTANT(VDM_INDEX_FSPrefix),
CONSTANT(VDM_INDEX_GSPrefix),
CONSTANT(VDM_INDEX_OPER32Prefix),
CONSTANT(VDM_INDEX_ADDR32Prefix),
CONSTANT(VDM_INDEX_INSB),
CONSTANT(VDM_INDEX_INSW),
CONSTANT(VDM_INDEX_OUTSB),
CONSTANT(VDM_INDEX_OUTSW),
CONSTANT(VDM_INDEX_PUSHF),
CONSTANT(VDM_INDEX_POPF),
CONSTANT(VDM_INDEX_INTnn),
CONSTANT(VDM_INDEX_INTO),
CONSTANT(VDM_INDEX_IRET),
CONSTANT(VDM_INDEX_NPX),
CONSTANT(VDM_INDEX_INBimm),
CONSTANT(VDM_INDEX_INWimm),
CONSTANT(VDM_INDEX_OUTBimm),
CONSTANT(VDM_INDEX_OUTWimm),
CONSTANT(VDM_INDEX_INB),
CONSTANT(VDM_INDEX_INW),
CONSTANT(VDM_INDEX_OUTB),
CONSTANT(VDM_INDEX_OUTW),
CONSTANT(VDM_INDEX_LOCKPrefix),
CONSTANT(VDM_INDEX_REPNEPrefix),
CONSTANT(VDM_INDEX_REPPrefix),
CONSTANT(VDM_INDEX_CLI),
CONSTANT(VDM_INDEX_STI),
CONSTANT(VDM_INDEX_HLT),
CONSTANT(MAX_VDM_INDEX),
*/
CONSTANT(PF_XMMI_INSTRUCTIONS_AVAILABLE),
CONSTANT(EFLAG_SELECT),
//CONSTANT(IPI_FREEZE),
//CONSTANT(XSAVE_PRESENT),
HEADER("CONTEXT"),
OFFSET(CsContextFlags, CONTEXT, ContextFlags),
OFFSET(CsDr0, CONTEXT, Dr0),
OFFSET(CsDr1, CONTEXT, Dr1),
OFFSET(CsDr2, CONTEXT, Dr2),
OFFSET(CsDr3, CONTEXT, Dr3),
OFFSET(CsDr6, CONTEXT, Dr6),
OFFSET(CsDr7, CONTEXT, Dr7),
OFFSET(CsFloatSave, CONTEXT, FloatSave),
OFFSET(CsSegGs, CONTEXT, SegGs),
OFFSET(CsSegFs, CONTEXT, SegFs),
OFFSET(CsSegEs, CONTEXT, SegEs),
OFFSET(CsSegDs, CONTEXT, SegDs),
OFFSET(CsEdi, CONTEXT, Edi),
OFFSET(CsEsi, CONTEXT, Esi),
OFFSET(CsEbx, CONTEXT, Ebx),
OFFSET(CsEdx, CONTEXT, Edx),
OFFSET(CsEcx, CONTEXT, Ecx),
OFFSET(CsEax, CONTEXT, Eax),
OFFSET(CsEbp, CONTEXT, Ebp),
OFFSET(CsEip, CONTEXT, Eip),
OFFSET(CsSegCs, CONTEXT, SegCs),
OFFSET(CsEflags, CONTEXT, EFlags),
OFFSET(CsEsp, CONTEXT, Esp),
OFFSET(CsSegSs, CONTEXT, SegSs),
OFFSET(CsExtendedRegisters, CONTEXT, ExtendedRegisters),
SIZE(ContextFrameLength, CONTEXT),
SIZE(CONTEXT_LENGTH, CONTEXT),
HEADER("KGDTENTRY"),
OFFSET(KgdtBaseLow, KGDTENTRY, BaseLow),
OFFSET(KgdtBaseMid, KGDTENTRY, HighWord.Bytes.BaseMid),
OFFSET(KgdtBaseHi, KGDTENTRY, HighWord.Bytes.BaseHi),
OFFSET(KgdtLimitHi, KGDTENTRY, HighWord.Bytes.Flags2),
OFFSET(KgdtLimitLow, KGDTENTRY, LimitLow),
HEADER("KTRAP_FRAME"),
OFFSET(TsExceptionList, KTRAP_FRAME, ExceptionList),
OFFSET(TsPreviousPreviousMode, KTRAP_FRAME, PreviousPreviousMode),
OFFSET(TsSegGs, KTRAP_FRAME, SegGs),
OFFSET(TsSegFs, KTRAP_FRAME, SegFs),
OFFSET(TsSegEs, KTRAP_FRAME, SegEs),
OFFSET(TsSegDs, KTRAP_FRAME, SegDs),
OFFSET(TsEdi, KTRAP_FRAME, Edi),
OFFSET(TsEsi, KTRAP_FRAME, Esi),
OFFSET(TsEbp, KTRAP_FRAME, Ebp),
OFFSET(TsEbx, KTRAP_FRAME, Ebx),
OFFSET(TsEdx, KTRAP_FRAME, Edx),
OFFSET(TsEcx, KTRAP_FRAME, Ecx),
OFFSET(TsEax, KTRAP_FRAME, Eax),
OFFSET(TsErrCode, KTRAP_FRAME, ErrCode),
OFFSET(TsEip, KTRAP_FRAME, Eip),
OFFSET(TsSegCs, KTRAP_FRAME, SegCs),
OFFSET(TsEflags, KTRAP_FRAME, EFlags),
OFFSET(TsHardwareEsp, KTRAP_FRAME, HardwareEsp),
OFFSET(TsHardwareSegSs, KTRAP_FRAME, HardwareSegSs),
OFFSET(TsTempSegCs, KTRAP_FRAME, TempSegCs),
//OFFSET(TsLogging, KTRAP_FRAME, Logging),
OFFSET(TsTempEsp, KTRAP_FRAME, TempEsp),
OFFSET(TsDbgEbp, KTRAP_FRAME, DbgEbp),
OFFSET(TsDbgEip, KTRAP_FRAME, DbgEip),
OFFSET(TsDbgArgMark, KTRAP_FRAME, DbgArgMark),
OFFSET(TsDbgArgPointer, KTRAP_FRAME, DbgArgPointer),
OFFSET(TsDr0, KTRAP_FRAME, Dr0),
OFFSET(TsDr1, KTRAP_FRAME, Dr1),
OFFSET(TsDr2, KTRAP_FRAME, Dr2),
OFFSET(TsDr3, KTRAP_FRAME, Dr3),
OFFSET(TsDr6, KTRAP_FRAME, Dr6),
OFFSET(TsDr7, KTRAP_FRAME, Dr7),
OFFSET(TsV86Es, KTRAP_FRAME, V86Es),
OFFSET(TsV86Ds, KTRAP_FRAME, V86Ds),
OFFSET(TsV86Fs, KTRAP_FRAME, V86Fs),
OFFSET(TsV86Gs, KTRAP_FRAME, V86Gs),
SIZE(KTRAP_FRAME_LENGTH, KTRAP_FRAME),
CONSTANT(KTRAP_FRAME_ALIGN),
CONSTANT(FRAME_EDITED),
HEADER("KTSS"),
OFFSET(TssEsp0, KTSS, Esp0),
OFFSET(TssCR3, KTSS, CR3),
OFFSET(TssEip, KTSS, Eip),
OFFSET(TssEFlags, KTSS, EFlags),
OFFSET(TssEax, KTSS, Eax),
OFFSET(TssEbx, KTSS, Ebx),
OFFSET(TssEcx, KTSS, Ecx),
OFFSET(TssEdx, KTSS, Edx),
OFFSET(TssEsp, KTSS, Esp),
OFFSET(TssEbp, KTSS, Ebp),
OFFSET(TssEsi, KTSS, Esi),
OFFSET(TssEdi, KTSS, Edi),
OFFSET(TssEs, KTSS, Es),
OFFSET(TssCs, KTSS, Cs),
OFFSET(TssSs, KTSS, Ss),
OFFSET(TssDs, KTSS, Ds),
OFFSET(TssFs, KTSS, Fs),
OFFSET(TssGs, KTSS, Gs),
OFFSET(TssLDT, KTSS, LDT),
OFFSET(TssIoMapBase, KTSS, IoMapBase),
OFFSET(TssIoMaps, KTSS, IoMaps),
SIZE(TssLength, KTSS),
// ReactOS stuff here
HEADER("KPCR"),
OFFSET(KPCR_EXCEPTION_LIST, KPCR, NtTib.ExceptionList),
//KPCR_INITIAL_STACK
//KPCR_STACK_LIMIT
OFFSET(KPCR_PERF_GLOBAL_GROUP_MASK, KIPCR, PerfGlobalGroupMask),
OFFSET(KPCR_CONTEXT_SWITCHES, KPCR, ContextSwitches),
// KPCR_SET_MEMBER_COPY
OFFSET(KPCR_TEB, KIPCR, Used_Self),
OFFSET(KPCR_SELF, KIPCR, Self),
OFFSET(KPCR_PRCB, KPCR, Prcb),
//KPCR_IRQL
//KPCR_IRR
//KPCR_IRR_ACTIVE
//KPCR_IDR
//KPCR_KD_VERSION_BLOCK
OFFSET(KPCR_IDT, KIPCR, IDT),
OFFSET(KPCR_GDT, KIPCR, GDT),
OFFSET(KPCR_TSS, KPCR, TSS),
OFFSET(KPCR_STALL_SCALE_FACTOR, KPCR, StallScaleFactor),
//KPCR_SET_MEMBER
//KPCR_NUMBER
//KPCR_VDM_ALERT
OFFSET(KPCR_PRCB_DATA, KIPCR, PrcbData),
OFFSET(KPCR_CURRENT_THREAD, KIPCR, PrcbData.CurrentThread),
OFFSET(KPCR_PRCB_NEXT_THREAD, KIPCR, PrcbData.NextThread),
//KPCR_PRCB_IDLE_THREAD
//KPCR_PROCESSOR_NUMBER
//KPCR_PRCB_SET_MEMBER
//KPCR_PRCB_CPU_TYPE
//KPCR_PRCB_PRCB_LOCK
//KPCR_NPX_THREAD
//KPCR_DR6
//KPCR_DR7
//KPCR_PRCB_INTERRUPT_COUNT 0x644
//KPCR_PRCB_KERNEL_TIME 0x648
//KPCR_PRCB_USER_TIME 0x64C
//KPCR_PRCB_DPC_TIME 0x650
//KPCR_PRCB_DEBUG_DPC_TIME 0x654
//KPCR_PRCB_INTERRUPT_TIME 0x658
//KPCR_PRCB_ADJUST_DPC_THRESHOLD 0x65C
//KPCR_PRCB_SKIP_TICK 0x664
//KPCR_SYSTEM_CALLS 0x6B8
OFFSET(KPCR_PRCB_DPC_QUEUE_DEPTH, KIPCR, PrcbData.DpcData[0].DpcQueueDepth),
//KPCR_PRCB_DPC_COUNT 0xA50
OFFSET(KPCR_PRCB_DPC_STACK, KIPCR, PrcbData.DpcStack),
OFFSET(KPCR_PRCB_MAXIMUM_DPC_QUEUE_DEPTH, KIPCR, PrcbData.MaximumDpcQueueDepth),
//KPCR_PRCB_MAXIMUM_DPC_QUEUE_DEPTH 0xA6C
//KPCR_PRCB_DPC_REQUEST_RATE 0xA70
//KPCR_PRCB_DPC_INTERRUPT_REQUESTED 0xA78
OFFSET(KPCR_PRCB_DPC_ROUTINE_ACTIVE, KIPCR, PrcbData.DpcRoutineActive),
//KPCR_PRCB_DPC_LAST_COUNT 0xA80
OFFSET(KPCR_PRCB_TIMER_REQUEST, KIPCR, PrcbData.TimerRequest),
OFFSET(KPCR_PRCB_QUANTUM_END, KIPCR, PrcbData.QuantumEnd),
//KPCR_PRCB_IDLE_SCHEDULE 0xAA3
OFFSET(KPCR_PRCB_DEFERRED_READY_LIST_HEAD, KIPCR, PrcbData.DeferredReadyListHead),
OFFSET(KPCR_PRCB_POWER_STATE_IDLE_FUNCTION, KIPCR, PrcbData.PowerState.IdleFunction),
HEADER("KTRAP_FRAME"),
OFFSET(KTRAP_FRAME_DEBUGEBP, KTRAP_FRAME, DbgEbp),
OFFSET(KTRAP_FRAME_DEBUGEIP, KTRAP_FRAME, DbgEip),
//OFFSET(KTRAP_FRAME_DEBUGARGMARK 0x8
//OFFSET(KTRAP_FRAME_DEBUGPOINTER 0xC
//OFFSET(KTRAP_FRAME_TEMPCS 0x10
OFFSET(KTRAP_FRAME_TEMPESP, KTRAP_FRAME, TempEsp),
OFFSET(KTRAP_FRAME_DR0, KTRAP_FRAME, Dr0),
OFFSET(KTRAP_FRAME_DR1, KTRAP_FRAME, Dr1),
OFFSET(KTRAP_FRAME_DR2, KTRAP_FRAME, Dr2),
OFFSET(KTRAP_FRAME_DR3, KTRAP_FRAME, Dr3),
OFFSET(KTRAP_FRAME_DR6, KTRAP_FRAME, Dr6),
OFFSET(KTRAP_FRAME_DR7, KTRAP_FRAME, Dr7),
OFFSET(KTRAP_FRAME_GS, KTRAP_FRAME, SegGs),
//OFFSET(KTRAP_FRAME_RESERVED1 0x32
OFFSET(KTRAP_FRAME_ES, KTRAP_FRAME, SegEs),
//OFFSET(KTRAP_FRAME_RESERVED2 0x36
OFFSET(KTRAP_FRAME_DS, KTRAP_FRAME, SegDs),
//OFFSET(KTRAP_FRAME_RESERVED3 0x3A
OFFSET(KTRAP_FRAME_EDX, KTRAP_FRAME, Edx),
OFFSET(KTRAP_FRAME_ECX, KTRAP_FRAME, Ecx),
OFFSET(KTRAP_FRAME_EAX, KTRAP_FRAME, Eax),
OFFSET(KTRAP_FRAME_PREVIOUS_MODE, KTRAP_FRAME, PreviousPreviousMode),
OFFSET(KTRAP_FRAME_EXCEPTION_LIST, KTRAP_FRAME, ExceptionList),
OFFSET(KTRAP_FRAME_FS, KTRAP_FRAME, SegFs),
//OFFSET(KTRAP_FRAME_RESERVED4 0x52
OFFSET(KTRAP_FRAME_EDI, KTRAP_FRAME, Edi),
OFFSET(KTRAP_FRAME_ESI, KTRAP_FRAME, Esi),
OFFSET(KTRAP_FRAME_EBX, KTRAP_FRAME, Ebx),
OFFSET(KTRAP_FRAME_EBP, KTRAP_FRAME, Ebp),
OFFSET(KTRAP_FRAME_ERROR_CODE, KTRAP_FRAME, ErrCode),
OFFSET(KTRAP_FRAME_EIP, KTRAP_FRAME, Eip),
//OFFSET(KTRAP_FRAME_CS 0x6C
OFFSET(KTRAP_FRAME_EFLAGS, KTRAP_FRAME, EFlags),
OFFSET(KTRAP_FRAME_ESP, KTRAP_FRAME, HardwareEsp),
OFFSET(KTRAP_FRAME_SS, KTRAP_FRAME, HardwareSegSs),
//OFFSET(KTRAP_FRAME_RESERVED5 0x7A
OFFSET(KTRAP_FRAME_V86_ES, KTRAP_FRAME, V86Es),
//OFFSET(KTRAP_FRAME_RESERVED6 0x7E
OFFSET(KTRAP_FRAME_V86_DS, KTRAP_FRAME, V86Ds),
//OFFSET(KTRAP_FRAME_RESERVED7 0x82
OFFSET(KTRAP_FRAME_V86_FS, KTRAP_FRAME, V86Fs),
//OFFSET(KTRAP_FRAME_RESERVED8 0x86
OFFSET(KTRAP_FRAME_V86_GS, KTRAP_FRAME, V86Gs),
//OFFSET(KTRAP_FRAME_RESERVED9 0x8A
//OFFSET(KTRAP_FRAME_SIZE 0x8C
//OFFSET(KTRAP_FRAME_LENGTH 0x8C
//OFFSET(KTRAP_FRAME_ALIGN 0x04
SIZE(KTRAP_FRAME_SIZE, KTRAP_FRAME),
CONSTANT(FRAME_EDITED),
// ok
HEADER("CONTEXT"),
OFFSET(CONTEXT_FLAGS, CONTEXT, ContextFlags),
//OFFSET(CONTEXT_DR6 0x14
//OFFSET(CONTEXT_FLOAT_SAVE 0x1C
OFFSET(CONTEXT_SEGGS, CONTEXT, SegGs),
OFFSET(CONTEXT_SEGFS, CONTEXT, SegFs),
OFFSET(CONTEXT_SEGES, CONTEXT, SegEs),
OFFSET(CONTEXT_SEGDS, CONTEXT, SegDs),
OFFSET(CONTEXT_EDI, CONTEXT, Edi),
OFFSET(CONTEXT_ESI, CONTEXT, Esi),
OFFSET(CONTEXT_EBX, CONTEXT, Ebx),
OFFSET(CONTEXT_EDX, CONTEXT, Edx),
OFFSET(CONTEXT_ECX, CONTEXT, Ecx),
OFFSET(CONTEXT_EAX, CONTEXT, Eax),
OFFSET(CONTEXT_EBP, CONTEXT, Ebp),
OFFSET(CONTEXT_EIP, CONTEXT, Eip),
OFFSET(CONTEXT_SEGCS, CONTEXT, SegCs),
OFFSET(CONTEXT_EFLAGS, CONTEXT, EFlags),
OFFSET(CONTEXT_ESP, CONTEXT, Esp),
OFFSET(CONTEXT_SEGSS, CONTEXT, SegSs),
//OFFSET(CONTEXT_FLOAT_SAVE_CONTROL_WORD CONTEXT_FLOAT_SAVE + FP_CONTROL_WORD
//OFFSET(CONTEXT_FLOAT_SAVE_STATUS_WORD CONTEXT_FLOAT_SAVE + FP_STATUS_WORD
//OFFSET(CONTEXT_FLOAT_SAVE_TAG_WORD CONTEXT_FLOAT_SAVE + FP_TAG_WORD
//OFFSET(CONTEXT_FRAME_LENGTH 0x2D0
SIZE(CONTEXT_FRAME_LENGTH, CONTEXT),
HEADER("FIBER"),
OFFSET(FIBER_PARAMETER, FIBER, Parameter),
OFFSET(FIBER_EXCEPTION_LIST, FIBER, ExceptionList),
OFFSET(FIBER_STACK_BASE, FIBER, StackBase),
OFFSET(FIBER_STACK_LIMIT, FIBER, StackLimit),
OFFSET(FIBER_DEALLOCATION_STACK, FIBER, DeallocationStack),
OFFSET(FIBER_CONTEXT, FIBER, Context),
OFFSET(FIBER_CONTEXT_FLAGS, FIBER, Context.ContextFlags),
OFFSET(FIBER_CONTEXT_EAX, FIBER, Context.Eax),
OFFSET(FIBER_CONTEXT_EBX, FIBER, Context.Ebx),
OFFSET(FIBER_CONTEXT_ECX, FIBER, Context.Ecx),
OFFSET(FIBER_CONTEXT_EDX, FIBER, Context.Edx),
OFFSET(FIBER_CONTEXT_ESI, FIBER, Context.Esi),
OFFSET(FIBER_CONTEXT_EDI, FIBER, Context.Edi),
OFFSET(FIBER_CONTEXT_EBP, FIBER, Context.Ebp),
OFFSET(FIBER_CONTEXT_EIP, FIBER, Context.Eip),
OFFSET(FIBER_CONTEXT_ESP, FIBER, Context.Esp),
OFFSET(FIBER_CONTEXT_DR6, FIBER, Context.Dr6),
OFFSET(FIBER_CONTEXT_FLOAT_SAVE_CONTROL_WORD, FIBER, Context.FloatSave.ControlWord),
OFFSET(FIBER_CONTEXT_FLOAT_SAVE_STATUS_WORD, FIBER, Context.FloatSave.StatusWord),
OFFSET(FIBER_CONTEXT_FLOAT_SAVE_TAG_WORD, FIBER, Context.FloatSave.TagWord),
OFFSET(FIBER_GUARANTEED_STACK_BYTES, FIBER, GuaranteedStackBytes),
OFFSET(FIBER_FLS_DATA, FIBER, FlsData),
OFFSET(FIBER_ACTIVATION_CONTEXT_STACK, FIBER, ActivationContextStack),
HEADER("KTSS"),
OFFSET(KTSS_IOMAPBASE, KTSS, IoMapBase),
OFFSET(KTSS_ESP0, KTSS, Esp0),
HEADER("EXCEPTION_RECORD"),
OFFSET(EXCEPTION_RECORD_EXCEPTION_CODE, EXCEPTION_RECORD, ExceptionCode),
OFFSET(EXCEPTION_RECORD_EXCEPTION_FLAGS, EXCEPTION_RECORD, ExceptionFlags),
OFFSET(EXCEPTION_RECORD_EXCEPTION_RECORD, EXCEPTION_RECORD, ExceptionRecord),
OFFSET(EXCEPTION_RECORD_EXCEPTION_ADDRESS, EXCEPTION_RECORD, ExceptionAddress),
OFFSET(EXCEPTION_RECORD_NUMBER_PARAMETERS, EXCEPTION_RECORD, NumberParameters),
OFFSET(EXCEPTION_RECORD_EXCEPTION_ADDRESS, EXCEPTION_RECORD, ExceptionAddress),
SIZE(SIZEOF_EXCEPTION_RECORD, EXCEPTION_RECORD),
CONSTANT(EXCEPTION_RECORD_LENGTH),
//#define EXCEPTION_RECORD_LENGTH 0x50
HEADER("KTHREAD"),
OFFSET(KTHREAD_DEBUG_ACTIVE, KTHREAD, Header.DebugActive),
OFFSET(KTHREAD_INITIAL_STACK, KTHREAD, InitialStack),
OFFSET(KTHREAD_STACK_LIMIT, KTHREAD, StackLimit),
OFFSET(KTHREAD_TEB, KTHREAD, Teb),
OFFSET(KTHREAD_KERNEL_STACK, KTHREAD, KernelStack),
//OFFSET(KTHREAD_ALERTED 0x5E
OFFSET(KTHREAD_APCSTATE_PROCESS, KTHREAD, ApcState.Process),
//OFFSET(KTHREAD_PENDING_USER_APC 0x28 + 0x16
OFFSET(KTHREAD_PENDING_KERNEL_APC, KTHREAD, ApcState.KernelApcPending),
OFFSET(KTHREAD_CONTEXT_SWITCHES, KTHREAD, ContextSwitches),
OFFSET(KTHREAD_STATE_, KTHREAD, State),
OFFSET(KTHREAD_NPX_STATE, KTHREAD, NpxState),
OFFSET(KTHREAD_WAIT_IRQL, KTHREAD, WaitIrql),
//OFFSET(KTHREAD_NEXT_PROCESSOR 0x40
OFFSET(KTHREAD_WAIT_REASON, KTHREAD, WaitReason),
//OFFSET(KTHREAD_PRIORITY 0x5B
//OFFSET(KTHREAD_SWAP_BUSY 0x5D
//OFFSET(KTHREAD_SERVICE_TABLE 0x118
//OFFSET(KTHREAD_PREVIOUS_MODE 0xD7
OFFSET(KTHREAD_COMBINED_APC_DISABLE, KTHREAD, CombinedApcDisable),
OFFSET(KTHREAD_SPECIAL_APC_DISABLE, KTHREAD, SpecialApcDisable),
OFFSET(KTHREAD_LARGE_STACK, KTHREAD, LargeStack),
OFFSET(KTHREAD_TRAP_FRAME, KTHREAD, TrapFrame),
OFFSET(KTHREAD_CALLBACK_STACK, KTHREAD, CallbackStack),
OFFSET(KTHREAD_APC_STATE_INDEX, KTHREAD, ApcStateIndex),
OFFSET(KTHREAD_STACK_BASE, KTHREAD, StackBase),
//OFFSET(KTHREAD_QUANTUM 0x15D
//OFFSET(KTHREAD_KERNEL_TIME 0x160
//OFFSET(KTHREAD_USER_TIME 0x18C
HEADER("KPROCESS"),
OFFSET(KPROCESS_DIRECTORY_TABLE_BASE, KPROCESS, DirectoryTableBase),
OFFSET(KPROCESS_LDT_DESCRIPTOR0, KPROCESS, LdtDescriptor),
OFFSET(KPROCESS_LDT_DESCRIPTOR1, KPROCESS, LdtDescriptor.HighWord),
OFFSET(KPROCESS_INT21_DESCRIPTOR0, KPROCESS, Int21Descriptor),
OFFSET(KPROCESS_INT21_DESCRIPTOR1, KPROCESS, Int21Descriptor.Access),
OFFSET(KPROCESS_IOPM_OFFSET, KPROCESS, IopmOffset),
//OFFSET(KPROCESS_ACTIVE_PROCESSORS 0x34
//OFFSET(EPROCESS_VDM_OBJECTS 0x144
HEADER("Teb"),
OFFSET(TEB_EXCEPTION_LIST, TEB, NtTib.ExceptionList),
OFFSET(TEB_STACK_LIMIT, TEB, NtTib.StackLimit),
OFFSET(TEB_STACK_BASE, TEB, NtTib.StackBase),
OFFSET(TEB_SELF, TEB, NtTib.Self),
OFFSET(TEB_FIBER_DATA, TEB, NtTib.FiberData),
OFFSET(TEB_PEB, TEB, ProcessEnvironmentBlock),
OFFSET(TEB_EXCEPTION_CODE, TEB, ExceptionCode),
OFFSET(PEB_KERNEL_CALLBACK_TABLE, PEB, KernelCallbackTable),
OFFSET(TEB_FLS_DATA, TEB, FlsData),
OFFSET(TEB_ACTIVATION_CONTEXT_STACK_POINTER, TEB, ActivationContextStackPointer),
OFFSET(TEB_GUARANTEED_STACK_BYTES, TEB, GuaranteedStackBytes),
OFFSET(TEB_DEALLOCATION_STACK, TEB, DeallocationStack),
HEADER("Misc"),
CONSTANT(NPX_FRAME_LENGTH),
CONSTANT(FN_CR0_NPX_STATE),
CONSTANT(DR7_RESERVED_MASK),
CONSTANT(FP_CONTROL_WORD),
CONSTANT(FP_STATUS_WORD),
CONSTANT(FP_TAG_WORD),
CONSTANT(FP_DATA_SELECTOR),
CONSTANT(CBSTACK_RESULT),
CONSTANT(CBSTACK_RESULT_LENGTH),
CONSTANT(CBSTACK_TRAP_FRAME),
CONSTANT(CBSTACK_CALLBACK_STACK),
SIZE(SIZEOF_FX_SAVE_AREA, FX_SAVE_AREA),
CONSTANT(KUSER_SHARED_SYSCALL),
CONSTANT(EXCEPTION_EXECUTE_HANDLER),
CONSTANT(STATUS_CALLBACK_POP_STACK),
CONSTANT(CONTEXT_ALIGNED_SIZE),
CONSTANT(PROCESSOR_FEATURE_FXSR),
reactos/include/asm/ksamd64.template.h
-612
View File
@@ -1,612 +0,0 @@
HEADER("CR0 flags"),
CONSTANT(CR0_PE),
CONSTANT(CR0_MP),
CONSTANT(CR0_EM),
CONSTANT(CR0_TS),
CONSTANT(CR0_ET),
CONSTANT(CR0_NE),
CONSTANT(CR0_WP),
CONSTANT(CR0_AM),
CONSTANT(CR0_NW),
CONSTANT(CR0_CD),
CONSTANT(CR0_PG),
HEADER("CR4 flags"),
CONSTANT(CR4_VME),
CONSTANT(CR4_PVI),
CONSTANT(CR4_TSD),
CONSTANT(CR4_DE),
CONSTANT(CR4_PSE),
CONSTANT(CR4_PAE),
CONSTANT(CR4_MCE),
CONSTANT(CR4_PGE),
CONSTANT(CR4_FXSR),
CONSTANT(CR4_XMMEXCPT),
CONSTANT(CR4_CHANNELS),
HEADER("KeFeatureBits flags"),
CONSTANT(KF_RDTSC),
CONSTANT(KF_CR4),
CONSTANT(KF_GLOBAL_PAGE),
CONSTANT(KF_LARGE_PAGE),
CONSTANT(KF_CMPXCHG8B),
CONSTANT(KF_FAST_SYSCALL),
HEADER("Machine type definitions"),
CONSTANT(MACHINE_TYPE_ISA),
CONSTANT(MACHINE_TYPE_EISA),
CONSTANT(MACHINE_TYPE_MCA),
HEADER("EFLAGS"),
CONSTANT(EFLAGS_TF_MASK),
CONSTANT(EFLAGS_TF_SHIFT),
CONSTANT(EFLAGS_IF_MASK),
CONSTANT(EFLAGS_IF_SHIFT),
CONSTANT(EFLAGS_ID_MASK),
HEADER("Hypervisor Enlightenment Definitions"),
//CONSTANT(HV_MMU_USE_HYPERCALL_FOR_ADDRESS_SWITCH),
//CONSTANT(HV_MMU_USE_HYPERCALL_FOR_LOCAL_FLUSH),
//CONSTANT(HV_MMU_USE_HYPERCALL_FOR_REMOTE_FLUSH),
//CONSTANT(HV_X64_MSR_APIC_EOI),
//CONSTANT(HV_APIC_ENLIGHTENED),
//CONSTANT(HV_KE_USE_HYPERCALL_FOR_LONG_SPIN_WAIT),
//CONSTANT(HV_VIRTUAL_APIC_NO_EOI_REQUIRED_V),
//CONSTANT(HvApicFlags),
HEADER("KDGT selectors"),
CONSTANT(KGDT64_NULL),
CONSTANT(KGDT64_R0_CODE),
CONSTANT(KGDT64_R0_DATA),
CONSTANT(KGDT64_R3_CMCODE),
CONSTANT(KGDT64_R3_DATA),
CONSTANT(KGDT64_R3_CODE),
CONSTANT(KGDT64_SYS_TSS),
CONSTANT(KGDT64_R3_CMTEB),
HEADER("Machine Specific Register Numbers"),
CONSTANT(MSR_EFER),
CONSTANT(MSR_STAR),
CONSTANT(MSR_LSTAR),
CONSTANT(MSR_CSTAR),
CONSTANT(MSR_SYSCALL_MASK),
CONSTANT(MSR_FS_BASE),
CONSTANT(MSR_GS_BASE),
CONSTANT(MSR_GS_SWAP),
CONSTANT(MSR_MCG_STATUS),
CONSTANT(MSR_AMD_ACCESS),
HEADER("Flags for MSR_EFER"),
CONSTANT(MSR_LMA),
CONSTANT(MSR_LME),
CONSTANT(MSR_SCE),
CONSTANT(MSR_NXE),
CONSTANT(MSR_PAT),
CONSTANT(MSR_DEGUG_CTL),
CONSTANT(MSR_LAST_BRANCH_FROM),
CONSTANT(MSR_LAST_BRANCH_TO),
CONSTANT(MSR_LAST_EXCEPTION_FROM),
CONSTANT(MSR_LAST_EXCEPTION_TO),
HEADER("Flags for MSR_DEGUG_CTL"),
//CONSTANT(MSR_DEBUG_CTL_LBR),
//CONSTANT(MSR_DEBUG_CRL_BTF),
HEADER("Fatal exception codes"),
CONSTANT(EXCEPTION_DIVIDED_BY_ZERO),
CONSTANT(EXCEPTION_DEBUG),
CONSTANT(EXCEPTION_NMI),
CONSTANT(EXCEPTION_INT3),
CONSTANT(EXCEPTION_BOUND_CHECK),
CONSTANT(EXCEPTION_INVALID_OPCODE),
CONSTANT(EXCEPTION_NPX_NOT_AVAILABLE),
CONSTANT(EXCEPTION_DOUBLE_FAULT),
CONSTANT(EXCEPTION_NPX_OVERRUN),
CONSTANT(EXCEPTION_INVALID_TSS),
CONSTANT(EXCEPTION_SEGMENT_NOT_PRESENT),
CONSTANT(EXCEPTION_STACK_FAULT),
CONSTANT(EXCEPTION_GP_FAULT),
CONSTANT(EXCEPTION_RESERVED_TRAP),
CONSTANT(EXCEPTION_NPX_ERROR),
CONSTANT(EXCEPTION_ALIGNMENT_CHECK),
HEADER("Argument Home Address"),
CONSTANT(P1Home),
CONSTANT(P2Home),
CONSTANT(P3Home),
CONSTANT(P4Home),
HEADER("CONTEXT"),
OFFSET(CONTEXT_P1Home, CONTEXT, P1Home),
OFFSET(CONTEXT_P2Home, CONTEXT, P2Home),
OFFSET(CONTEXT_P3Home, CONTEXT, P3Home),
OFFSET(CONTEXT_P4Home, CONTEXT, P4Home),
OFFSET(CONTEXT_P5Home, CONTEXT, P5Home),
OFFSET(CONTEXT_P6Home, CONTEXT, P6Home),
OFFSET(CONTEXT_ContextFlags, CONTEXT, ContextFlags),
OFFSET(CONTEXT_MxCsr, CONTEXT, MxCsr),
OFFSET(CONTEXT_SegCs, CONTEXT, SegCs),
OFFSET(CONTEXT_SegDs, CONTEXT, SegDs),
OFFSET(CONTEXT_SegEs, CONTEXT, SegEs),
OFFSET(CONTEXT_SegFs, CONTEXT, SegFs),
OFFSET(CONTEXT_SegGs, CONTEXT, SegGs),
OFFSET(CONTEXT_SegSs, CONTEXT, SegSs),
OFFSET(CONTEXT_EFlags, CONTEXT, EFlags),
OFFSET(CONTEXT_Dr0, CONTEXT, Dr0),
OFFSET(CONTEXT_Dr1, CONTEXT, Dr1),
OFFSET(CONTEXT_Dr2, CONTEXT, Dr2),
OFFSET(CONTEXT_Dr3, CONTEXT, Dr3),
OFFSET(CONTEXT_Dr6, CONTEXT, Dr6),
OFFSET(CONTEXT_Dr7, CONTEXT, Dr7),
OFFSET(CONTEXT_Rax, CONTEXT, Rax),
OFFSET(CONTEXT_Rcx, CONTEXT, Rcx),
OFFSET(CONTEXT_Rdx, CONTEXT, Rdx),
OFFSET(CONTEXT_Rbx, CONTEXT, Rbx),
OFFSET(CONTEXT_Rsp, CONTEXT, Rsp),
OFFSET(CONTEXT_Rbp, CONTEXT, Rbp),
OFFSET(CONTEXT_Rsi, CONTEXT, Rsi),
OFFSET(CONTEXT_Rdi, CONTEXT, Rdi),
OFFSET(CONTEXT_R8, CONTEXT, R8),
OFFSET(CONTEXT_R9, CONTEXT, R9),
OFFSET(CONTEXT_R10, CONTEXT, R10),
OFFSET(CONTEXT_R11, CONTEXT, R11),
OFFSET(CONTEXT_R12, CONTEXT, R12),
OFFSET(CONTEXT_R13, CONTEXT, R13),
OFFSET(CONTEXT_R14, CONTEXT, R14),
OFFSET(CONTEXT_R15, CONTEXT, R15),
OFFSET(CONTEXT_Rip, CONTEXT, Rip),
OFFSET(CONTEXT_FltSave, CONTEXT, FltSave),
OFFSET(CONTEXT_Xmm0, CONTEXT, Xmm0),
OFFSET(CONTEXT_Xmm1, CONTEXT, Xmm1),
OFFSET(CONTEXT_Xmm2, CONTEXT, Xmm2),
OFFSET(CONTEXT_Xmm3, CONTEXT, Xmm3),
OFFSET(CONTEXT_Xmm4, CONTEXT, Xmm4),
OFFSET(CONTEXT_Xmm5, CONTEXT, Xmm5),
OFFSET(CONTEXT_Xmm6, CONTEXT, Xmm6),
OFFSET(CONTEXT_Xmm7, CONTEXT, Xmm7),
OFFSET(CONTEXT_Xmm8, CONTEXT, Xmm8),
OFFSET(CONTEXT_Xmm9, CONTEXT, Xmm9),
OFFSET(CONTEXT_Xmm10, CONTEXT, Xmm10),
OFFSET(CONTEXT_Xmm11, CONTEXT, Xmm11),
OFFSET(CONTEXT_Xmm12, CONTEXT, Xmm12),
OFFSET(CONTEXT_Xmm13, CONTEXT, Xmm13),
OFFSET(CONTEXT_Xmm14, CONTEXT, Xmm14),
OFFSET(CONTEXT_Xmm15, CONTEXT, Xmm15),
OFFSET(CONTEXT_DebugControl, CONTEXT, DebugControl),
OFFSET(CONTEXT_LastBranchToRip, CONTEXT, LastBranchToRip),
OFFSET(CONTEXT_LastBranchFromRip, CONTEXT, LastBranchFromRip),
OFFSET(CONTEXT_LastExceptionToRip, CONTEXT, LastExceptionToRip),
OFFSET(CONTEXT_LastExceptionFromRip, CONTEXT, LastExceptionFromRip),
OFFSET(CONTEXT_VectorControl, CONTEXT, VectorControl),
OFFSET(CONTEXT_VectorRegister, CONTEXT, VectorRegister),
SIZE(CONTEXT_FRAME_LENGTH, CONTEXT),
HEADER("DISPATCHER_CONTEXT"),
OFFSET(DcControlPc, DISPATCHER_CONTEXT, ControlPc),
OFFSET(DcImageBase, DISPATCHER_CONTEXT, ImageBase),
OFFSET(DcFunctionEntry, DISPATCHER_CONTEXT, FunctionEntry),
OFFSET(DcEstablisherFrame, DISPATCHER_CONTEXT, EstablisherFrame),
OFFSET(DcTargetIp, DISPATCHER_CONTEXT, TargetIp),
OFFSET(DcContextRecord, DISPATCHER_CONTEXT, ContextRecord),
OFFSET(DcLanguageHandler, DISPATCHER_CONTEXT, LanguageHandler),
OFFSET(DcHandlerData, DISPATCHER_CONTEXT, HandlerData),
OFFSET(DcHistoryTable, DISPATCHER_CONTEXT, HistoryTable),
OFFSET(DcScopeIndex, DISPATCHER_CONTEXT, ScopeIndex),
HEADER("KEXCEPTION_FRAME"),
OFFSET(KEXCEPTION_FRAME_P1Home, KEXCEPTION_FRAME, P1Home),
OFFSET(KEXCEPTION_FRAME_P2Home, KEXCEPTION_FRAME, P2Home),
OFFSET(KEXCEPTION_FRAME_P3Home, KEXCEPTION_FRAME, P3Home),
OFFSET(KEXCEPTION_FRAME_P4Home, KEXCEPTION_FRAME, P4Home),
OFFSET(KEXCEPTION_FRAME_P5, KEXCEPTION_FRAME, P5),
OFFSET(KEXCEPTION_FRAME_Xmm6, KEXCEPTION_FRAME, Xmm6),
OFFSET(KEXCEPTION_FRAME_Xmm7, KEXCEPTION_FRAME, Xmm7),
OFFSET(KEXCEPTION_FRAME_Xmm8, KEXCEPTION_FRAME, Xmm8),
OFFSET(KEXCEPTION_FRAME_Xmm9, KEXCEPTION_FRAME, Xmm9),
OFFSET(KEXCEPTION_FRAME_Xmm10, KEXCEPTION_FRAME, Xmm10),
OFFSET(KEXCEPTION_FRAME_Xmm11, KEXCEPTION_FRAME, Xmm11),
OFFSET(KEXCEPTION_FRAME_Xmm12, KEXCEPTION_FRAME, Xmm12),
OFFSET(KEXCEPTION_FRAME_Xmm13, KEXCEPTION_FRAME, Xmm13),
OFFSET(KEXCEPTION_FRAME_Xmm14, KEXCEPTION_FRAME, Xmm14),
OFFSET(KEXCEPTION_FRAME_Xmm15, KEXCEPTION_FRAME, Xmm15),
OFFSET(KEXCEPTION_FRAME_MxCsr, KEXCEPTION_FRAME, MxCsr),
OFFSET(KEXCEPTION_FRAME_Rbp, KEXCEPTION_FRAME, Rbp),
OFFSET(KEXCEPTION_FRAME_Rbx, KEXCEPTION_FRAME, Rbx),
OFFSET(KEXCEPTION_FRAME_Rdi, KEXCEPTION_FRAME, Rdi),
OFFSET(KEXCEPTION_FRAME_Rsi, KEXCEPTION_FRAME, Rsi),
OFFSET(KEXCEPTION_FRAME_R12, KEXCEPTION_FRAME, R12),
OFFSET(KEXCEPTION_FRAME_R13, KEXCEPTION_FRAME, R13),
OFFSET(KEXCEPTION_FRAME_R14, KEXCEPTION_FRAME, R14),
OFFSET(KEXCEPTION_FRAME_R15, KEXCEPTION_FRAME, R15),
OFFSET(KEXCEPTION_FRAME_Return, KEXCEPTION_FRAME, Return),
OFFSET(KEXCEPTION_FRAME_InitialStack, KEXCEPTION_FRAME, InitialStack),
OFFSET(KEXCEPTION_FRAME_TrapFrame, KEXCEPTION_FRAME, TrapFrame),
OFFSET(KEXCEPTION_FRAME_CallbackStack, KEXCEPTION_FRAME, CallbackStack),
OFFSET(KEXCEPTION_FRAME_OutputBuffer, KEXCEPTION_FRAME, OutputBuffer),
OFFSET(KEXCEPTION_FRAME_OutputLength, KEXCEPTION_FRAME, OutputLength),
SIZE(KEXCEPTION_FRAME_LENGTH, KEXCEPTION_FRAME),
HEADER("JUMP_BUFFER"),
OFFSET(JbFrame, _JUMP_BUFFER, Frame),
OFFSET(JbRbx, _JUMP_BUFFER, Rbx),
OFFSET(JbRsp, _JUMP_BUFFER, Rsp),
OFFSET(JbRbp, _JUMP_BUFFER, Rbp),
OFFSET(JbRsi, _JUMP_BUFFER, Rsi),
OFFSET(JbRdi, _JUMP_BUFFER, Rdi),
OFFSET(JbR12, _JUMP_BUFFER, R12),
OFFSET(JbR13, _JUMP_BUFFER, R13),
OFFSET(JbR14, _JUMP_BUFFER, R14),
OFFSET(JbR15, _JUMP_BUFFER, R15),
OFFSET(JbRip, _JUMP_BUFFER, Rip),
//OFFSET(JbMxCsr, _JUMP_BUFFER, MxCsr), // Spare
//OFFSET(JbFpCsr, _JUMP_BUFFER, FpCsr),
OFFSET(JbXmm6, _JUMP_BUFFER, Xmm6),
OFFSET(JbXmm7, _JUMP_BUFFER, Xmm7),
OFFSET(JbXmm8, _JUMP_BUFFER, Xmm8),
OFFSET(JbXmm9, _JUMP_BUFFER, Xmm9),
OFFSET(JbXmm10, _JUMP_BUFFER, Xmm10),
OFFSET(JbXmm11, _JUMP_BUFFER, Xmm11),
OFFSET(JbXmm12, _JUMP_BUFFER, Xmm12),
OFFSET(JbXmm13, _JUMP_BUFFER, Xmm13),
OFFSET(JbXmm14, _JUMP_BUFFER, Xmm14),
OFFSET(JbXmm15, _JUMP_BUFFER, Xmm15),
HEADER("KGDTENTRY64"),
OFFSET(KgdtBaseLow, KGDTENTRY64, BaseLow),
OFFSET(KgdtBaseMiddle, KGDTENTRY64, Bytes.BaseMiddle),
OFFSET(KgdtBaseHigh, KGDTENTRY64, Bytes.BaseHigh),
OFFSET(KgdtBaseUpper, KGDTENTRY64, BaseUpper),
OFFSET(KgdtLimitHigh, KGDTENTRY64, Bytes.Flags2),
OFFSET(KgdtLimitLow, KGDTENTRY64, LimitLow),
//CONSTANT(KGDT_LIMIT_ENCODE_MASK),
HEADER("KPRCB"),
OFFSET(PbMxCsr, KPRCB, MxCsr),
OFFSET(PbNumber, KPRCB, Number),
OFFSET(PbInterruptRequest, KPRCB, InterruptRequest),
OFFSET(PbIdleHalt, KPRCB, IdleHalt),
OFFSET(PbCurrentThread, KPRCB, CurrentThread),
OFFSET(PbNextThread, KPRCB, NextThread),
OFFSET(PbIdleThread, KPRCB, IdleThread),
OFFSET(PbNestingLevel, KPRCB, NestingLevel),
OFFSET(PbRspBase, KPRCB, RspBase),
OFFSET(PbPrcbLock, KPRCB, PrcbLock),
OFFSET(PbSetMember, KPRCB, SetMember),
OFFSET(PbProcessorState, KPRCB, ProcessorState),
OFFSET(PbCpuType, KPRCB, CpuType),
OFFSET(PbCpuID, KPRCB, CpuID),
OFFSET(PbCpuStep, KPRCB, CpuStep),
OFFSET(PbHalReserved, KPRCB, HalReserved),
OFFSET(PbMinorVersion, KPRCB, MinorVersion),
OFFSET(PbMajorVersion, KPRCB, MajorVersion),
OFFSET(PbBuildType, KPRCB, BuildType),
OFFSET(PbCpuVendor, KPRCB, CpuVendor),
//OFFSET(PbCoresPerPhysicalProcessor, KPRCB, CoresPerPhysicalProcessor),
//OFFSET(PbLogicalProcessorsPerCore, KPRCB, LogicalProcessorsPerCore),
OFFSET(PbApicMask, KPRCB, ApicMask),
OFFSET(PbCFlushSize, KPRCB, CFlushSize),
OFFSET(PbAcpiReserved, KPRCB, AcpiReserved),
OFFSET(PbInitialApicId, KPRCB, InitialApicId),
//OFFSET(PbStride, KPRCB, Stride),
OFFSET(PbLockQueue, KPRCB, LockQueue),
OFFSET(PbPPLookasideList, KPRCB, PPLookasideList),
OFFSET(PbPPNPagedLookasideList, KPRCB, PPNPagedLookasideList),
OFFSET(PbPPPagedLookasideList, KPRCB, PPPagedLookasideList),
OFFSET(PbPacketBarrier, KPRCB, PacketBarrier),
OFFSET(PbDeferredReadyListHead, KPRCB, DeferredReadyListHead),
OFFSET(PbLookasideIrpFloat, KPRCB, LookasideIrpFloat),
//OFFSET(PbSystemCalls, KPRCB, SystemCalls),
//OFFSET(PbReadOperationCount, KPRCB, ReadOperationCount),
//OFFSET(PbWriteOperationCount, KPRCB, WriteOperationCount),
//OFFSET(PbOtherOperationCount, KPRCB, OtherOperationCount),
//OFFSET(PbReadTransferCount, KPRCB, ReadTransferCount),
//OFFSET(PbWriteTransferCount, KPRCB, WriteTransferCount),
//OFFSET(PbOtherTransferCount, KPRCB, OtherTransferCount),
//OFFSET(PbContextSwitches, KPRCB, ContextSwitches),
OFFSET(PbTargetSet, KPRCB, TargetSet),
OFFSET(PbIpiFrozen, KPRCB, IpiFrozen),
OFFSET(PbRequestMailbox, KPRCB, RequestMailbox),
OFFSET(PbSenderSummary, KPRCB, SenderSummary),
//OFFSET(PbDpcListHead, KPRCB, DpcListHead),
//OFFSET(PbDpcLock, KPRCB, DpcLock),
//OFFSET(PbDpcQueueDepth, KPRCB, DpcQueueDepth),
//OFFSET(PbDpcCount, KPRCB, DpcCount),
OFFSET(PbDpcStack, KPRCB, DpcStack),
OFFSET(PbMaximumDpcQueueDepth, KPRCB, MaximumDpcQueueDepth),
OFFSET(PbDpcRequestRate, KPRCB, DpcRequestRate),
OFFSET(PbMinimumDpcRate, KPRCB, MinimumDpcRate),
OFFSET(PbDpcInterruptRequested, KPRCB, DpcInterruptRequested),
OFFSET(PbDpcThreadRequested, KPRCB, DpcThreadRequested),
OFFSET(PbDpcRoutineActive, KPRCB, DpcRoutineActive),
OFFSET(PbDpcThreadActive, KPRCB, DpcThreadActive),
OFFSET(PbTimerHand, KPRCB, TimerHand),
OFFSET(PbTimerRequest, KPRCB, TimerRequest),
OFFSET(PbTickOffset, KPRCB, TickOffset),
OFFSET(PbMasterOffset, KPRCB, MasterOffset),
OFFSET(PbDpcLastCount, KPRCB, DpcLastCount),
OFFSET(PbQuantumEnd, KPRCB, QuantumEnd),
OFFSET(PbDpcSetEventRequest, KPRCB, DpcSetEventRequest),
OFFSET(PbIdleSchedule, KPRCB, IdleSchedule),
OFFSET(PbReadySummary, KPRCB, ReadySummary),
OFFSET(PbDispatcherReadyListHead, KPRCB, DispatcherReadyListHead),
OFFSET(PbInterruptCount, KPRCB, InterruptCount),
OFFSET(PbKernelTime, KPRCB, KernelTime),
OFFSET(PbUserTime, KPRCB, UserTime),
OFFSET(PbDpcTime, KPRCB, DpcTime),
OFFSET(PbInterruptTime, KPRCB, InterruptTime),
OFFSET(PbAdjustDpcThreshold, KPRCB, AdjustDpcThreshold),
OFFSET(PbSkipTick, KPRCB, SkipTick),
OFFSET(PbPollSlot, KPRCB, PollSlot),
OFFSET(PbParentNode, KPRCB, ParentNode),
OFFSET(PbMultiThreadProcessorSet, KPRCB, MultiThreadProcessorSet),
OFFSET(PbMultiThreadSetMaster, KPRCB, MultiThreadSetMaster),
//OFFSET(PbStartCycles, KPRCB, StartCycles),
OFFSET(PbPageColor, KPRCB, PageColor),
OFFSET(PbNodeColor, KPRCB, NodeColor),
OFFSET(PbNodeShiftedColor, KPRCB,NodeShiftedColor),
OFFSET(PbSecondaryColorMask, KPRCB, SecondaryColorMask),
OFFSET(PbSleeping, KPRCB, Sleeping),
//OFFSET(PbCycleTime, KPRCB, CycleTime),
//OFFSET(PbFastReadNoWait, KPRCB, FastReadNoWait),
//OFFSET(PbFastReadWait, KPRCB, FastReadWait),
//OFFSET(PbFastReadNotPossible, KPRCB, FastReadNotPossible),
//OFFSET(PbCopyReadNoWait, KPRCB, CopyReadNoWait),
//OFFSET(PbCopyReadWait, KPRCB, CopyReadWait),
//OFFSET(PbCopyReadNoWaitMiss, KPRCB, CopyReadNoWaitMiss),
//OFFSET(PbAlignmentFixupCount, KPRCB, AlignmentFixupCount),
//OFFSET(PbExceptionDispatchCount, KPRCB, ExceptionDispatchCount),
OFFSET(PbVendorString, KPRCB, VendorString),
OFFSET(PbPowerState, KPRCB, PowerState),
SIZE(ProcessorBlockLength, KPRCB),
HEADER("KPCR"),
//OFFSET(PcGdt, KPCR, Gdt),
//OFFSET(PcTss, KPCR, Tss),
OFFSET(PcUserRsp, KPCR, UserRsp),
OFFSET(PcSelf, KPCR, Self),
OFFSET(PcCurrentPrcb, KPCR, CurrentPrcb),
OFFSET(PcLockArray, KPCR, LockArray),
//OFFSET(PcTeb, KPCR, Teb),
//OFFSET(PcIdt, KPCR, Idt),
OFFSET(PcIrql, KPCR, Irql),
OFFSET(PcStallScaleFactor, KPCR, StallScaleFactor),
OFFSET(PcHalReserved, KPCR, HalReserved),
//OFFSET(PcPrcb, KPCR, Prcb),
//OFFSET(PcMxCsr, KPCR, MxCsr),
//OFFSET(PcNumber, KPCR, Number),
//OFFSET(PcInterruptRequest, KPCR, InterruptRequest),
//OFFSET(PcIdleHalt, KPCR, IdleHalt),
OFFSET(PcCurrentThread, KIPCR, Prcb.CurrentThread),
//OFFSET(PcNextThread, KPCR, NextThread),
//OFFSET(PcIdleThread, KPCR, IdleThread),
//OFFSET(PcIpiFrozen, KPCR, IpiFrozen),
//OFFSET(PcNestingLevel, KPCR, NestingLevel),
OFFSET(PcRspBase, KIPCR, Prcb.RspBase),
//OFFSET(PcPrcbLock, KPCR, PrcbLock),
OFFSET(PcSetMember, KIPCR, Prcb.SetMember),
#if 0
OFFSET(PcCr0, KIPCR, Prcb.Cr0),
OFFSET(PcCr2, KIPCR, Prcb.Cr2),
OFFSET(PcCr3, KIPCR, Prcb.Cr3),
OFFSET(PcCr4, KIPCR, Prcb.Cr4),
OFFSET(PcKernelDr0, KIPCR, Prcb.KernelDr0),
OFFSET(PcKernelDr1, KIPCR, Prcb.KernelDr1),
OFFSET(PcKernelDr2, KIPCR, Prcb.KernelDr2),
OFFSET(PcKernelDr3, KIPCR, Prcb.KernelDr3),
OFFSET(PcKernelDr7, KIPCR, Prcb.KernelDr7),
OFFSET(PcGdtrLimit, KIPCR, Prcb.GdtrLimit),
OFFSET(PcGdtrBase, KIPCR, Prcb.GdtrBase),
OFFSET(PcIdtrLimit, KIPCR, IdtrLimit),
OFFSET(PcIdtrBase, KIPCR, IdtrBase),
OFFSET(PcTr, KIPCR, Tr),
OFFSET(PcLdtr, KIPCR, Ldtr),
OFFSET(PcDebugControl, KIPCR, DebugControl),
OFFSET(PcLastBranchToRip, KIPCR, LastBranchToRip),
OFFSET(PcLastBranchFromRip, KIPCR, LastBranchFromRip),
OFFSET(PcLastExceptionToRip, KIPCR, LastExceptionToRip),
OFFSET(PcLastExceptionFromRip, KIPCR, LastExceptionFromRip),
OFFSET(PcCr8, KIPCR, Cr8),
#endif
OFFSET(PcCpuType, KIPCR, Prcb.CpuType),
OFFSET(PcCpuID, KIPCR, Prcb.CpuID),
OFFSET(PcCpuStep, KIPCR, Prcb.CpuStep),
OFFSET(PcCpuVendor, KIPCR, Prcb.CpuVendor),
OFFSET(PcCFlushSize, KIPCR, Prcb.CFlushSize),
OFFSET(PcDeferredReadyListHead, KIPCR, Prcb.DeferredReadyListHead),
OFFSET(PcSystemCalls, KIPCR, Prcb.KeSystemCalls),
OFFSET(PcDpcRoutineActive, KIPCR, Prcb.DpcRoutineActive),
OFFSET(PcInterruptCount, KIPCR, Prcb.InterruptCount),
OFFSET(PcDebuggerSavedIRQL, KIPCR, Prcb.DebuggerSavedIRQL),
OFFSET(PcTickOffset, KIPCR, Prcb.TickOffset),
OFFSET(PcMasterOffset, KIPCR, Prcb.MasterOffset),
OFFSET(PcSkipTick, KIPCR, Prcb.SkipTick),
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
OFFSET(PcVirtualApicAssist, KIPCR, Prcb.VirtualApicAssist),
OFFSET(PcStartCycles, KIPCR, Prcb.StartCycles),
#endif
SIZE(ProcessorControlRegisterLength, KIPCR),
HEADER("KPROCESSOR_STATE"),
OFFSET(PsSpecialRegisters, KPROCESSOR_STATE, SpecialRegisters),
OFFSET(PsCr0, KPROCESSOR_STATE, SpecialRegisters.Cr0),
OFFSET(PsCr2, KPROCESSOR_STATE, SpecialRegisters.Cr2),
OFFSET(PsCr3, KPROCESSOR_STATE, SpecialRegisters.Cr3),
OFFSET(PsCr4, KPROCESSOR_STATE, SpecialRegisters.Cr4),
OFFSET(PsKernelDr0, KPROCESSOR_STATE, SpecialRegisters.KernelDr0),
OFFSET(PsKernelDr1, KPROCESSOR_STATE, SpecialRegisters.KernelDr1),
OFFSET(PsKernelDr2, KPROCESSOR_STATE, SpecialRegisters.KernelDr2),
OFFSET(PsKernelDr3, KPROCESSOR_STATE, SpecialRegisters.KernelDr3),
OFFSET(PsKernelDr6, KPROCESSOR_STATE, SpecialRegisters.KernelDr6),
OFFSET(PsKernelDr7, KPROCESSOR_STATE, SpecialRegisters.KernelDr7),
OFFSET(PsGdtr, KPROCESSOR_STATE, SpecialRegisters.Gdtr),
OFFSET(PsIdtr, KPROCESSOR_STATE, SpecialRegisters.Idtr),
OFFSET(PsTr, KPROCESSOR_STATE, SpecialRegisters.Tr),
OFFSET(PsLdtr, KPROCESSOR_STATE, SpecialRegisters.Ldtr),
OFFSET(PsMxCsr, KPROCESSOR_STATE, SpecialRegisters.MxCsr),
OFFSET(PsContextFrame, KPROCESSOR_STATE, ContextFrame),
OFFSET(PsDebugControl, KPROCESSOR_STATE, SpecialRegisters.DebugControl),
OFFSET(PsLastBranchToRip, KPROCESSOR_STATE, SpecialRegisters.LastBranchToRip),
OFFSET(PsLastBranchFromRip, KPROCESSOR_STATE, SpecialRegisters.LastBranchFromRip),
OFFSET(PsLastExceptionToRip, KPROCESSOR_STATE, SpecialRegisters.LastExceptionToRip),
OFFSET(PsLastExceptionFromRip, KPROCESSOR_STATE, SpecialRegisters.LastExceptionFromRip),
OFFSET(PsCr8, KPROCESSOR_STATE, SpecialRegisters.Cr8),
SIZE(ProcessorStateLength, KPROCESSOR_STATE),
HEADER("KSTART_FRAME"),
OFFSET(SfP1Home, KSTART_FRAME, P1Home),
OFFSET(SfP2Home, KSTART_FRAME, P2Home),
OFFSET(SfP3Home, KSTART_FRAME, P3Home),
OFFSET(SfP4Home, KSTART_FRAME, P4Home),
OFFSET(SfReturn, KSTART_FRAME, Return),
SIZE(KSTART_FRAME_LENGTH, KSTART_FRAME),
HEADER("KSPECIAL_REGISTERS"),
OFFSET(SrKernelDr0, KSPECIAL_REGISTERS, KernelDr0),
OFFSET(SrKernelDr1, KSPECIAL_REGISTERS, KernelDr1),
OFFSET(SrKernelDr2, KSPECIAL_REGISTERS, KernelDr2),
OFFSET(SrKernelDr3, KSPECIAL_REGISTERS, KernelDr3),
OFFSET(SrKernelDr6, KSPECIAL_REGISTERS, KernelDr6),
OFFSET(SrKernelDr7, KSPECIAL_REGISTERS, KernelDr7),
OFFSET(SrGdtr, KSPECIAL_REGISTERS, Gdtr),
OFFSET(SrIdtr, KSPECIAL_REGISTERS, Idtr),
OFFSET(SrTr, KSPECIAL_REGISTERS, Tr),
OFFSET(SrMxCsr, KSPECIAL_REGISTERS, MxCsr),
OFFSET(SrMsrGsBase, KSPECIAL_REGISTERS, MsrGsBase),
OFFSET(SrMsrGsSwap, KSPECIAL_REGISTERS, MsrGsSwap),
OFFSET(SrMsrStar, KSPECIAL_REGISTERS, MsrStar),
OFFSET(SrMsrLStar, KSPECIAL_REGISTERS, MsrLStar),
OFFSET(SrMsrCStar, KSPECIAL_REGISTERS, MsrCStar),
OFFSET(SrMsrSyscallMask, KSPECIAL_REGISTERS, MsrSyscallMask),
HEADER("KSYSTEM_TIME"),
OFFSET(StLowTime, KSYSTEM_TIME, LowPart),
OFFSET(StHigh1Time, KSYSTEM_TIME, High1Time),
OFFSET(StHigh2Time, KSYSTEM_TIME, High2Time),
HEADER("KSWITCH_FRAME"),
OFFSET(SwP5Home, KSWITCH_FRAME, P5Home),
OFFSET(SwApcBypass, KSWITCH_FRAME, ApcBypass),
OFFSET(SwRbp, KSWITCH_FRAME, Rbp),
OFFSET(SwReturn, KSWITCH_FRAME, Return),
SIZE(SwitchFrameLength, KSWITCH_FRAME),
SIZE(KSWITCH_FRAME_LENGTH, KSWITCH_FRAME),
HEADER("KTRAP_FRAME"),
OFFSET(KTRAP_FRAME_P1Home, KTRAP_FRAME, P1Home),
OFFSET(KTRAP_FRAME_P2Home, KTRAP_FRAME, P2Home),
OFFSET(KTRAP_FRAME_P3Home, KTRAP_FRAME, P3Home),
OFFSET(KTRAP_FRAME_P4Home, KTRAP_FRAME, P4Home),
OFFSET(KTRAP_FRAME_P5, KTRAP_FRAME, P5),
OFFSET(KTRAP_FRAME_PreviousMode, KTRAP_FRAME, PreviousMode),
OFFSET(KTRAP_FRAME_PreviousIrql, KTRAP_FRAME, PreviousIrql),
OFFSET(KTRAP_FRAME_FaultIndicator, KTRAP_FRAME, FaultIndicator),
OFFSET(KTRAP_FRAME_ExceptionActive, KTRAP_FRAME, ExceptionActive),
OFFSET(KTRAP_FRAME_MxCsr, KTRAP_FRAME, MxCsr),
OFFSET(KTRAP_FRAME_Rax, KTRAP_FRAME, Rax),
OFFSET(KTRAP_FRAME_Rcx, KTRAP_FRAME, Rcx),
OFFSET(KTRAP_FRAME_Rdx, KTRAP_FRAME, Rdx),
OFFSET(KTRAP_FRAME_R8, KTRAP_FRAME, R8),
OFFSET(KTRAP_FRAME_R9, KTRAP_FRAME, R9),
OFFSET(KTRAP_FRAME_R10, KTRAP_FRAME, R10),
OFFSET(KTRAP_FRAME_R11, KTRAP_FRAME, R11),
OFFSET(KTRAP_FRAME_GsBase, KTRAP_FRAME, GsBase),
OFFSET(KTRAP_FRAME_GsSwap, KTRAP_FRAME,GsSwap),
OFFSET(KTRAP_FRAME_Xmm0, KTRAP_FRAME, Xmm0),
OFFSET(KTRAP_FRAME_Xmm1, KTRAP_FRAME, Xmm1),
OFFSET(KTRAP_FRAME_Xmm2, KTRAP_FRAME, Xmm2),
OFFSET(KTRAP_FRAME_Xmm3, KTRAP_FRAME, Xmm3),
OFFSET(KTRAP_FRAME_Xmm4, KTRAP_FRAME, Xmm4),
OFFSET(KTRAP_FRAME_Xmm5, KTRAP_FRAME, Xmm5),
OFFSET(KTRAP_FRAME_FaultAddress, KTRAP_FRAME, FaultAddress),
OFFSET(KTRAP_FRAME_TimeStampCKCL, KTRAP_FRAME, TimeStampCKCL),
OFFSET(KTRAP_FRAME_Dr0, KTRAP_FRAME, Dr0),
OFFSET(KTRAP_FRAME_Dr1, KTRAP_FRAME, Dr1),
OFFSET(KTRAP_FRAME_Dr2, KTRAP_FRAME, Dr2),
OFFSET(KTRAP_FRAME_Dr3, KTRAP_FRAME, Dr3),
OFFSET(KTRAP_FRAME_Dr6, KTRAP_FRAME, Dr6),
OFFSET(KTRAP_FRAME_Dr7, KTRAP_FRAME, Dr7),
OFFSET(KTRAP_FRAME_DebugControl, KTRAP_FRAME, DebugControl),
OFFSET(KTRAP_FRAME_LastBranchToRip, KTRAP_FRAME, LastBranchToRip),
OFFSET(KTRAP_FRAME_LastBranchFromRip, KTRAP_FRAME, LastBranchFromRip),
OFFSET(KTRAP_FRAME_LastExceptionToRip, KTRAP_FRAME, LastExceptionToRip),
OFFSET(KTRAP_FRAME_LastExceptionFromRip, KTRAP_FRAME, LastExceptionFromRip),
OFFSET(KTRAP_FRAME_LastBranchControl, KTRAP_FRAME, LastBranchControl),
OFFSET(KTRAP_FRAME_LastBranchMSR, KTRAP_FRAME, LastBranchMSR),
OFFSET(KTRAP_FRAME_SegDs, KTRAP_FRAME, SegDs),
OFFSET(KTRAP_FRAME_SegEs, KTRAP_FRAME, SegEs),
OFFSET(KTRAP_FRAME_SegFs, KTRAP_FRAME, SegFs),
OFFSET(KTRAP_FRAME_SegGs, KTRAP_FRAME, SegGs),
OFFSET(KTRAP_FRAME_TrapFrame, KTRAP_FRAME, TrapFrame),
OFFSET(KTRAP_FRAME_Rbx, KTRAP_FRAME, Rbx),
OFFSET(KTRAP_FRAME_Rdi, KTRAP_FRAME, Rdi),
OFFSET(KTRAP_FRAME_Rsi, KTRAP_FRAME, Rsi),
OFFSET(KTRAP_FRAME_Rbp, KTRAP_FRAME, Rbp),
OFFSET(KTRAP_FRAME_ErrorCode, KTRAP_FRAME, ErrorCode),
OFFSET(KTRAP_FRAME_TimeStampKlog, KTRAP_FRAME, TimeStampKlog),
OFFSET(KTRAP_FRAME_Rip, KTRAP_FRAME, Rip),
OFFSET(KTRAP_FRAME_SegCs, KTRAP_FRAME, SegCs),
OFFSET(KTRAP_FRAME_Logging, KTRAP_FRAME, Logging),
OFFSET(KTRAP_FRAME_EFlags, KTRAP_FRAME, EFlags),
OFFSET(KTRAP_FRAME_Rsp, KTRAP_FRAME, Rsp),
OFFSET(KTRAP_FRAME_SegSs, KTRAP_FRAME, SegSs),
OFFSET(KTRAP_FRAME_CodePatchCycle, KTRAP_FRAME, CodePatchCycle),
SIZE(KTRAP_FRAME_LENGTH, KTRAP_FRAME),
#if (NTDDI_VERSION >= NTDDI_WIN7)
HEADER("KTIMER_TABLE"),
OFFSET(TtEntry, KTIMER_TABLE, TimerEntries),
OFFSET(TtTime, KTIMER_TABLE_ENTRY, Time),
SIZE(TIMER_ENTRY_SIZE, KTIMER_TABLE_ENTRY),
SIZE(TIMER_TABLE_SIZE, KTIMER_TABLE),
SIZE(KTIMER_TABLE_SIZE, KTIMER_TABLE),
#endif
HEADER("KTSS"),
OFFSET(TssRsp0, KTSS64, Rsp0),
OFFSET(TssRsp1, KTSS64, Rsp1),
OFFSET(TssRsp2, KTSS64, Rsp2),
OFFSET(TssPanicStack, KTSS64, Ist[1]),
OFFSET(TssMcaStack, KTSS64, Ist[2]),
OFFSET(TssNmiStack, KTSS64, Ist[3]),
OFFSET(TssIoMapBase, KTSS64, IoMapBase),
SIZE(TssLength, KTSS64),
HEADER("EXCEPTION_RECORD"),
OFFSET(EXCEPTION_RECORD_ExceptionCode, EXCEPTION_RECORD, ExceptionCode),
OFFSET(EXCEPTION_RECORD_ExceptionFlags, EXCEPTION_RECORD, ExceptionFlags),
OFFSET(EXCEPTION_RECORD_ExceptionRecord, EXCEPTION_RECORD, ExceptionRecord),
OFFSET(EXCEPTION_RECORD_ExceptionAddress, EXCEPTION_RECORD, ExceptionAddress),
OFFSET(EXCEPTION_RECORD_NumberParameters, EXCEPTION_RECORD, NumberParameters),
OFFSET(EXCEPTION_RECORD_ExceptionInformation, EXCEPTION_RECORD, ExceptionInformation),
HEADER("KTHREAD"),
OFFSET(KTHREAD_WAIT_IRQL, KTHREAD, WaitIrql),
OFFSET(KTHREAD_TrapFrame, KTHREAD, TrapFrame),
OFFSET(KTHREAD_PreviousMode, KTHREAD, PreviousMode),
OFFSET(KTHREAD_KernelStack, KTHREAD, KernelStack),
OFFSET(KTHREAD_UserApcPending, KTHREAD, ApcState.UserApcPending),
HEADER("KINTERRUPT"),
OFFSET(KINTERRUPT_Type, KINTERRUPT, Type),
OFFSET(KINTERRUPT_Size, KINTERRUPT, Size),
OFFSET(KINTERRUPT_InterruptListEntry, KINTERRUPT, InterruptListEntry),
OFFSET(KINTERRUPT_ServiceRoutine, KINTERRUPT, ServiceRoutine),
OFFSET(KINTERRUPT_ServiceContext, KINTERRUPT, ServiceContext),
OFFSET(KINTERRUPT_SpinLock, KINTERRUPT, SpinLock),
OFFSET(KINTERRUPT_TickCount, KINTERRUPT, TickCount),
OFFSET(KINTERRUPT_ActualLock, KINTERRUPT, ActualLock),
OFFSET(KINTERRUPT_DispatchAddress, KINTERRUPT, DispatchAddress),
OFFSET(KINTERRUPT_Vector, KINTERRUPT, Vector),
OFFSET(KINTERRUPT_Irql, KINTERRUPT, Irql),
OFFSET(KINTERRUPT_SynchronizeIrql, KINTERRUPT, SynchronizeIrql),
OFFSET(KINTERRUPT_FloatingSave, KINTERRUPT, FloatingSave),
OFFSET(KINTERRUPT_Connected, KINTERRUPT, Connected),
OFFSET(KINTERRUPT_Number, KINTERRUPT, Number),
OFFSET(KINTERRUPT_ShareVector, KINTERRUPT, ShareVector),
OFFSET(KINTERRUPT_Mode, KINTERRUPT, Mode),
OFFSET(KINTERRUPT_ServiceCount, KINTERRUPT, ServiceCount),
OFFSET(KINTERRUPT_DispatchCount, KINTERRUPT, DispatchCount),
OFFSET(KINTERRUPT_TrapFrame, KINTERRUPT, TrapFrame),
OFFSET(KINTERRUPT_DispatchCode, KINTERRUPT, DispatchCode),
reactos/include/asm/ksx.template.h
-765
View File
@@ -1,765 +0,0 @@
HEADER("Pointer size"),
SIZE(SizeofPointer, PVOID),
HEADER("Breakpoints"),
CONSTANT(BREAKPOINT_BREAK),
CONSTANT(BREAKPOINT_PRINT),
CONSTANT(BREAKPOINT_PROMPT),
CONSTANT(BREAKPOINT_LOAD_SYMBOLS),
CONSTANT(BREAKPOINT_UNLOAD_SYMBOLS),
CONSTANT(BREAKPOINT_COMMAND_STRING),
HEADER("Context Frame Flags"),
CONSTANT(CONTEXT_FULL),
CONSTANT(CONTEXT_CONTROL),
CONSTANT(CONTEXT_INTEGER),
#ifndef _M_ARM
CONSTANT(CONTEXT_SEGMENTS),
CONSTANT(CONTEXT_FLOATING_POINT),
CONSTANT(CONTEXT_DEBUG_REGISTERS),
#endif
HEADER("Exception flags"),
CONSTANT(EXCEPTION_NONCONTINUABLE),
CONSTANT(EXCEPTION_UNWINDING),
CONSTANT(EXCEPTION_EXIT_UNWIND),
CONSTANT(EXCEPTION_STACK_INVALID),
CONSTANT(EXCEPTION_NESTED_CALL),
CONSTANT(EXCEPTION_TARGET_UNWIND),
CONSTANT(EXCEPTION_COLLIDED_UNWIND),
CONSTANT(EXCEPTION_UNWIND),
CONSTANT(EXCEPTION_EXECUTE_HANDLER),
CONSTANT(EXCEPTION_CONTINUE_SEARCH),
CONSTANT(EXCEPTION_CONTINUE_EXECUTION),
#ifdef _X86_
CONSTANT(EXCEPTION_CHAIN_END),
//CONSTANT(FIXED_NTVDMSTATE_LINEAR),
#endif
HEADER("Exception types"),
CONSTANT(ExceptionContinueExecution),
CONSTANT(ExceptionContinueSearch),
CONSTANT(ExceptionNestedException),
CONSTANT(ExceptionCollidedUnwind),
HEADER("Lock Queue"),
CONSTANT(LOCK_QUEUE_WAIT),
CONSTANT(LOCK_QUEUE_OWNER),
CONSTANT(LockQueueDispatcherLock),
//HEADER("Performance Definitions"),
//CONSTANT(PERF_CONTEXTSWAP_OFFSET),
//CONSTANT(PERF_CONTEXTSWAP_FLAG),
//CONSTANT(PERF_INTERRUPT_OFFSET),
//CONSTANT(PERF_INTERRUPT_FLAG),
//CONSTANT(PERF_PROFILE_OFFSET),
//CONSTANT(PERF_PROFILE_FLAG),
//CONSTANT(PERF_SYSCALL_OFFSET),
//CONSTANT(PERF_SYSCALL_FLAG),
//CONSTANT(PERF_SPINLOCK_OFFSET),
//CONSTANT(PERF_SPINLOCK_FLAG),
//CONSTANT(NTOS_YIELD_MACRO),
HEADER("Process states"),
CONSTANT(ProcessInMemory),
CONSTANT(ProcessOutOfMemory),
CONSTANT(ProcessInTransition),
HEADER("Processor mode"),
CONSTANT(KernelMode),
CONSTANT(UserMode),
HEADER("Status codes"),
CONSTANT(STATUS_ACCESS_VIOLATION),
CONSTANT(STATUS_ASSERTION_FAILURE),
CONSTANT(STATUS_ARRAY_BOUNDS_EXCEEDED),
CONSTANT(STATUS_BAD_COMPRESSION_BUFFER),
CONSTANT(STATUS_BREAKPOINT),
CONSTANT(STATUS_CALLBACK_POP_STACK),
CONSTANT(STATUS_DATATYPE_MISALIGNMENT),
CONSTANT(STATUS_FLOAT_DENORMAL_OPERAND),
CONSTANT(STATUS_FLOAT_DIVIDE_BY_ZERO),
CONSTANT(STATUS_FLOAT_INEXACT_RESULT),
CONSTANT(STATUS_FLOAT_INVALID_OPERATION),
CONSTANT(STATUS_FLOAT_OVERFLOW),
CONSTANT(STATUS_FLOAT_STACK_CHECK),
CONSTANT(STATUS_FLOAT_UNDERFLOW),
CONSTANT(STATUS_FLOAT_MULTIPLE_FAULTS),
CONSTANT(STATUS_FLOAT_MULTIPLE_TRAPS),
CONSTANT(STATUS_GUARD_PAGE_VIOLATION),
CONSTANT(STATUS_ILLEGAL_FLOAT_CONTEXT),
CONSTANT(STATUS_ILLEGAL_INSTRUCTION),
CONSTANT(STATUS_INSTRUCTION_MISALIGNMENT),
CONSTANT(STATUS_INVALID_HANDLE),
CONSTANT(STATUS_INVALID_LOCK_SEQUENCE),
CONSTANT(STATUS_INVALID_OWNER),
CONSTANT(STATUS_INVALID_PARAMETER),
CONSTANT(STATUS_INVALID_PARAMETER_1),
CONSTANT(STATUS_INVALID_SYSTEM_SERVICE),
//CONSTANT(STATUS_INVALID_THREAD),
CONSTANT(STATUS_INTEGER_DIVIDE_BY_ZERO),
CONSTANT(STATUS_INTEGER_OVERFLOW),
CONSTANT(STATUS_IN_PAGE_ERROR),
CONSTANT(STATUS_KERNEL_APC),
CONSTANT(STATUS_LONGJUMP),
CONSTANT(STATUS_NO_CALLBACK_ACTIVE),
CONSTANT(STATUS_NO_EVENT_PAIR),
CONSTANT(STATUS_PRIVILEGED_INSTRUCTION),
CONSTANT(STATUS_SINGLE_STEP),
CONSTANT(STATUS_STACK_BUFFER_OVERRUN),
CONSTANT(STATUS_STACK_OVERFLOW),
CONSTANT(STATUS_SUCCESS),
CONSTANT(STATUS_THREAD_IS_TERMINATING),
CONSTANT(STATUS_TIMEOUT),
CONSTANT(STATUS_UNWIND),
CONSTANT(STATUS_UNWIND_CONSOLIDATE),
CONSTANT(STATUS_USER_APC),
CONSTANT(STATUS_WAKE_SYSTEM_DEBUGGER),
HEADER("TLS defines"),
CONSTANT(TLS_MINIMUM_AVAILABLE),
CONSTANT(TLS_EXPANSION_SLOTS),
HEADER("Thread states"),
CONSTANT(Initialized),
CONSTANT(Ready),
CONSTANT(Running),
CONSTANT(Standby),
CONSTANT(Terminated),
CONSTANT(Waiting),
HEADER("Wait type / reason"),
CONSTANT(WrExecutive),
CONSTANT(WrMutex),
CONSTANT(WrDispatchInt),
CONSTANT(WrQuantumEnd),
CONSTANT(WrEventPair),
CONSTANT(WaitAny),
CONSTANT(WaitAll),
HEADER("Interrupt object types"),
CONSTANTX(InLevelSensitive, LevelSensitive),
CONSTANTX(InLatched, Latched),
HEADER("Bug Check Codes"),
CONSTANT(APC_INDEX_MISMATCH),
CONSTANT(INVALID_AFFINITY_SET),
CONSTANT(INVALID_DATA_ACCESS_TRAP),
CONSTANT(IRQL_NOT_GREATER_OR_EQUAL),
CONSTANT(IRQL_NOT_LESS_OR_EQUAL),
CONSTANT(NO_USER_MODE_CONTEXT),
CONSTANT(SPIN_LOCK_ALREADY_OWNED),
CONSTANT(SPIN_LOCK_NOT_OWNED),
CONSTANT(THREAD_NOT_MUTEX_OWNER),
CONSTANT(TRAP_CAUSE_UNKNOWN),
CONSTANT(KMODE_EXCEPTION_NOT_HANDLED),
CONSTANT(KERNEL_APC_PENDING_DURING_EXIT),
CONSTANT(PANIC_STACK_SWITCH),
CONSTANT(DATA_BUS_ERROR),
CONSTANT(INSTRUCTION_BUS_ERROR),
CONSTANT(SYSTEM_EXIT_OWNED_MUTEX),
//CONSTANT(SYSTEM_UNWIND_PREVIOUS_USER),
//CONSTANT(SYSTEM_SERVICE_EXCEPTION),
//CONSTANT(INTERRUPT_UNWIND_ATTEMPTED),
//CONSTANT(INTERRUPT_EXCEPTION_NOT_HANDLED),
CONSTANT(PAGE_FAULT_WITH_INTERRUPTS_OFF),
CONSTANT(IRQL_GT_ZERO_AT_SYSTEM_SERVICE),
CONSTANT(DATA_COHERENCY_EXCEPTION),
CONSTANT(INSTRUCTION_COHERENCY_EXCEPTION),
CONSTANT(HAL1_INITIALIZATION_FAILED),
CONSTANT(UNEXPECTED_KERNEL_MODE_TRAP),
CONSTANT(NMI_HARDWARE_FAILURE),
CONSTANT(SPIN_LOCK_INIT_FAILURE),
CONSTANT(ATTEMPTED_SWITCH_FROM_DPC),
//CONSTANT(MUTEX_ALREADY_OWNED),
//CONSTANT(HARDWARE_INTERRUPT_STORM),
//CONSTANT(RECURSIVE_MACHINE_CHECK),
//CONSTANT(RECURSIVE_NMI),
HEADER("IRQL"),
CONSTANT(PASSIVE_LEVEL),
CONSTANT(APC_LEVEL),
CONSTANT(DISPATCH_LEVEL),
#ifdef _M_AMD64
CONSTANT(CLOCK_LEVEL),
#else
CONSTANT(CLOCK1_LEVEL),
CONSTANT(CLOCK2_LEVEL),
#endif
CONSTANT(IPI_LEVEL),
CONSTANT(POWER_LEVEL),
CONSTANT(PROFILE_LEVEL),
CONSTANT(HIGH_LEVEL),
RAW("#ifdef NT_UP"),
{TYPE_CONSTANT, "SYNCH_LEVEL", DISPATCH_LEVEL},
RAW("#else"),
{TYPE_CONSTANT, "SYNCH_LEVEL", (IPI_LEVEL - 2)},
RAW("#endif"),
HEADER("Stack sizes"),
CONSTANT(KERNEL_STACK_SIZE),
CONSTANT(KERNEL_LARGE_STACK_SIZE),
CONSTANT(KERNEL_LARGE_STACK_COMMIT),
//CONSTANT(DOUBLE_FAULT_STACK_SIZE),
#ifdef _M_AMD64
CONSTANT(KERNEL_MCA_EXCEPTION_STACK_SIZE),
CONSTANT(NMI_STACK_SIZE),
#endif
//HEADER("Thread flags"),
//CONSTANT(THREAD_FLAGS_CYCLE_PROFILING),
//CONSTANT(THREAD_FLAGS_CYCLE_PROFILING_LOCK_BIT),
//CONSTANT(THREAD_FLAGS_CYCLE_PROFILING_LOCK),
//CONSTANT(THREAD_FLAGS_COUNTER_PROFILING),
//CONSTANT(THREAD_FLAGS_COUNTER_PROFILING_LOCK_BIT),
//CONSTANT(THREAD_FLAGS_COUNTER_PROFILING_LOCK),
//CONSTANT(THREAD_FLAGS_CPU_THROTTLED),
//CONSTANT(THREAD_FLAGS_CPU_THROTTLED_BIT),
//CONSTANT(THREAD_FLAGS_ACCOUNTING_ANY),
HEADER("Miscellaneous Definitions"),
//CONSTANT(BASE_PRIORITY_THRESHOLD),
//CONSTANT(EVENT_PAIR_INCREMENT),
CONSTANT(LOW_REALTIME_PRIORITY),
CONSTANT(CLOCK_QUANTUM_DECREMENT),
//CONSTANT(READY_SKIP_QUANTUM),
//CONSTANT(THREAD_QUANTUM),
CONSTANT(WAIT_QUANTUM_DECREMENT),
//CONSTANT(ROUND_TRIP_DECREMENT_COUNT),
CONSTANT(MAXIMUM_PROCESSORS),
CONSTANT(INITIAL_STALL_COUNT),
//CONSTANT(EXCEPTION_EXECUTE_FAULT),
//CONSTANT(KCACHE_ERRATA_MONITOR_FLAGS),
//CONSTANT(KI_EXCEPTION_GP_FAULT),
//CONSTANT(KI_EXCEPTION_INVALID_OP),
//CONSTANT(KI_EXCEPTION_INTEGER_DIVIDE_BY_ZERO),
CONSTANT(KI_EXCEPTION_ACCESS_VIOLATION),
//CONSTANT(TARGET_FREEZE),
//CONSTANT(BlackHole),
CONSTANT(Executive),
CONSTANT(FALSE),
CONSTANT(TRUE),
CONSTANT(DBG_STATUS_CONTROL_C),
//CONSTANTPTR(USER_SHARED_DATA), // FIXME: we need the kernel mode address here!
//CONSTANT(MM_SHARED_USER_DATA_VA),
CONSTANT(PAGE_SIZE),
//CONSTANT(KERNEL_STACK_CONTROL_LARGE_STACK),
//CONSTANT(KI_DPC_ALL_FLAGS),
//CONSTANT(DISPATCH_LENGTH),
//CONSTANT(MAXIMUM_PRIMARY_VECTOR),
//CONSTANT(KTHREAD_AUTO_ALIGNMENT_BIT),
//CONSTANT(KTHREAD_GUI_THREAD_MASK),
//CONSTANT(KI_SLIST_FAULT_COUNT_MAXIMUM),
#ifndef _M_ARM
CONSTANT(MAXIMUM_IDTVECTOR),
CONSTANT(PRIMARY_VECTOR_BASE),
CONSTANT(RPL_MASK),
CONSTANT(MODE_MASK),
CONSTANT(NUMBER_SERVICE_TABLES),
CONSTANT(SERVICE_NUMBER_MASK),
CONSTANT(SERVICE_TABLE_SHIFT),
CONSTANT(SERVICE_TABLE_MASK),
CONSTANT(SERVICE_TABLE_TEST),
#endif
/* STRUCTURE OFFSETS *********************************************************/
//HEADER("KAFFINITY_EX"),
//OFFSET(AfBitmap, KAFFINITY_EX, Bitmap),
//HEADER("Aligned Affinity"),
//OFFSET(AfsCpuSet, ???, CpuSet),
HEADER("KAPC"),
OFFSET(ApType, KAPC, Type),
OFFSET(ApSize, KAPC, Size),
OFFSET(ApThread, KAPC, Thread),
OFFSET(ApApcListEntry, KAPC, ApcListEntry),
OFFSET(ApKernelRoutine, KAPC, KernelRoutine),
OFFSET(ApRundownRoutine, KAPC, RundownRoutine),
OFFSET(ApNormalRoutine, KAPC, NormalRoutine),
OFFSET(ApNormalContext, KAPC, NormalContext),
OFFSET(ApSystemArgument1, KAPC, SystemArgument1),
OFFSET(ApSystemArgument2, KAPC, SystemArgument2),
OFFSET(ApApcStateIndex, KAPC, ApcStateIndex),
OFFSET(ApApcMode, KAPC, ApcMode),
OFFSET(ApInserted, KAPC, Inserted),
SIZE(ApcObjectLength, KAPC),
HEADER("KAPC_STATE"),
OFFSET(AsApcListHead, KAPC_STATE, ApcListHead),
OFFSET(AsProcess, KAPC_STATE, Process),
OFFSET(AsKernelApcInProgress, KAPC_STATE, KernelApcInProgress),
OFFSET(AsKernelApcPending, KAPC_STATE, KernelApcPending),
OFFSET(AsUserApcPending, KAPC_STATE, UserApcPending),
HEADER("CLIENT_ID"),
OFFSET(CidUniqueProcess, CLIENT_ID, UniqueProcess),
OFFSET(CidUniqueThread, CLIENT_ID, UniqueThread),
HEADER("RTL_CRITICAL_SECTION"),
OFFSET(CsDebugInfo, RTL_CRITICAL_SECTION, DebugInfo),
OFFSET(CsLockCount, RTL_CRITICAL_SECTION, LockCount),
OFFSET(CsRecursionCount, RTL_CRITICAL_SECTION, RecursionCount),
OFFSET(CsOwningThread, RTL_CRITICAL_SECTION, OwningThread),
OFFSET(CsLockSemaphore, RTL_CRITICAL_SECTION, LockSemaphore),
OFFSET(CsSpinCount, RTL_CRITICAL_SECTION, SpinCount),
HEADER("RTL_CRITICAL_SECTION_DEBUG"),
OFFSET(CsType, RTL_CRITICAL_SECTION_DEBUG, Type),
OFFSET(CsCreatorBackTraceIndex, RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex),
OFFSET(CsCriticalSection, RTL_CRITICAL_SECTION_DEBUG, CriticalSection),
OFFSET(CsProcessLocksList, RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList),
OFFSET(CsEntryCount, RTL_CRITICAL_SECTION_DEBUG, EntryCount),
OFFSET(CsContentionCount, RTL_CRITICAL_SECTION_DEBUG, ContentionCount),
HEADER("KDEVICE_QUEUE_ENTRY"),
OFFSET(DeDeviceListEntry, KDEVICE_QUEUE_ENTRY, DeviceListEntry),
OFFSET(DeSortKey, KDEVICE_QUEUE_ENTRY, SortKey),
OFFSET(DeInserted, KDEVICE_QUEUE_ENTRY, Inserted),
SIZE(DeviceQueueEntryLength, KDEVICE_QUEUE_ENTRY),
HEADER("KDPC"),
OFFSET(DpType, KDPC, Type),
OFFSET(DpImportance, KDPC, Importance),
OFFSET(DpNumber, KDPC, Number),
OFFSET(DpDpcListEntry, KDPC, DpcListEntry),
OFFSET(DpDeferredRoutine, KDPC, DeferredRoutine),
OFFSET(DpDeferredContext, KDPC, DeferredContext),
OFFSET(DpSystemArgument1, KDPC, SystemArgument1),
OFFSET(DpSystemArgument2, KDPC, SystemArgument2),
OFFSET(DpDpcData, KDPC, DpcData),
SIZE(DpcObjectLength, KDPC),
HEADER("KDEVICE_QUEUE"),
OFFSET(DvType, KDEVICE_QUEUE, Type),
OFFSET(DvSize, KDEVICE_QUEUE, Size),
OFFSET(DvDeviceListHead, KDEVICE_QUEUE, DeviceListHead),
OFFSET(DvSpinLock, KDEVICE_QUEUE, Lock),
OFFSET(DvBusy, KDEVICE_QUEUE, Busy),
SIZE(DeviceQueueObjectLength, KDEVICE_QUEUE),
HEADER("EXCEPTION_RECORD"),
OFFSET(ErExceptionCode, EXCEPTION_RECORD, ExceptionCode),
OFFSET(ErExceptionFlags, EXCEPTION_RECORD, ExceptionFlags),
OFFSET(ErExceptionRecord, EXCEPTION_RECORD, ExceptionRecord),
OFFSET(ErExceptionAddress, EXCEPTION_RECORD, ExceptionAddress),
OFFSET(ErNumberParameters, EXCEPTION_RECORD, NumberParameters),
OFFSET(ErExceptionInformation, EXCEPTION_RECORD, ExceptionInformation),
SIZE(ExceptionRecordLength, EXCEPTION_RECORD),
SIZE(EXCEPTION_RECORD_LENGTH, EXCEPTION_RECORD),
HEADER("EPROCESS"),
OFFSET(EpDebugPort, EPROCESS, DebugPort),
OFFSET(EpVdmObjects, EPROCESS, VdmObjects),
SIZE(ExecutiveProcessObjectLength, EPROCESS),
HEADER("KEVENT"),
OFFSET(EvType, KEVENT, Header.Type),
OFFSET(EvSize, KEVENT, Header.Size),
OFFSET(EvSignalState, KEVENT, Header.SignalState),
OFFSET(EvWaitListHead, KEVENT, Header.WaitListHead),
SIZE(EventObjectLength, KEVENT),
HEADER("FAST_MUTEX"),
OFFSET(FmCount, FAST_MUTEX, Count),
OFFSET(FmOwner, FAST_MUTEX, Owner),
OFFSET(FmContention, FAST_MUTEX, Contention),
//OFFSET(FmGate, FAST_MUTEX, Gate),
OFFSET(FmOldIrql, FAST_MUTEX, OldIrql),
HEADER("KINTERRUPT"),
OFFSET(InType, KINTERRUPT, Type),
OFFSET(InSize, KINTERRUPT, Size),
OFFSET(InInterruptListEntry, KINTERRUPT, InterruptListEntry),
OFFSET(InServiceRoutine, KINTERRUPT, ServiceRoutine),
OFFSET(InServiceContext, KINTERRUPT, ServiceContext),
OFFSET(InSpinLock, KINTERRUPT, SpinLock),
OFFSET(InTickCount, KINTERRUPT, TickCount),
OFFSET(InActualLock, KINTERRUPT, ActualLock),
OFFSET(InDispatchAddress, KINTERRUPT, DispatchAddress),
OFFSET(InVector, KINTERRUPT, Vector),
OFFSET(InIrql, KINTERRUPT, Irql),
OFFSET(InSynchronizeIrql, KINTERRUPT, SynchronizeIrql),
OFFSET(InFloatingSave, KINTERRUPT, FloatingSave),
OFFSET(InConnected, KINTERRUPT, Connected),
OFFSET(InNumber, KINTERRUPT, Number),
OFFSET(InShareVector, KINTERRUPT, ShareVector),
OFFSET(InMode, KINTERRUPT, Mode),
OFFSET(InServiceCount, KINTERRUPT, ServiceCount),
OFFSET(InDispatchCount, KINTERRUPT, DispatchCount),
//OFFSET(InTrapFrame, KINTERRUPT, TrapFrame),
OFFSET(InDispatchCode, KINTERRUPT, DispatchCode),
SIZE(InterruptObjectLength, KINTERRUPT),
HEADER("IO_STATUS_BLOCK"),
OFFSET(IoStatus, IO_STATUS_BLOCK, Status),
OFFSET(IoPointer, IO_STATUS_BLOCK, Pointer),
OFFSET(IoInformation, IO_STATUS_BLOCK, Information),
//HEADER("KERNEL_STACK_CONTROL"),
#ifdef _M_IX86
// Kernel Stack Control Structure Offset (relative to initial stack pointer) Definitions
//RELOFFSET(KcPreviousBase, KERNEL_STACK_CONTROL, PreviousBase, ???), -40
//RELOFFSET(KcPreviousLimit, KERNEL_STACK_CONTROL, PreviousBase, ???), -36
//RELOFFSET(KcPreviousKernel, KERNEL_STACK_CONTROL, PreviousBase, ???), -32
//RELOFFSET(KcPreviousInitial, KERNEL_STACK_CONTROL, PreviousBase, ???), -28
#else
//OFFSET(KcPreviousBase, KERNEL_STACK_CONTROL, PreviousBase),
//OFFSET(KcPreviousLimit, KERNEL_STACK_CONTROL, PreviousLimit),
//OFFSET(KcPreviousKernel, KERNEL_STACK_CONTROL, PreviousKernel),
//OFFSET(KcPreviousInitial, KERNEL_STACK_CONTROL, PreviousInitial),
//SIZE(KERNEL_STACK_CONTROL_LENGTH, KERNEL_STACK_CONTROL),
#endif
HEADER("KNODE"),
//OFFSET(KnRight, KNODE, Right),
//OFFSET(KnLeft, KNODE, Left),
OFFSET(KnPfnDereferenceSListHead, KNODE, PfnDereferenceSListHead),
OFFSET(KnProcessorMask, KNODE, ProcessorMask),
OFFSET(KnColor, KNODE, Color),
OFFSET(KnSeed, KNODE, Seed),
OFFSET(KnNodeNumber, KNODE, NodeNumber),
OFFSET(KnFlags, KNODE, Flags),
OFFSET(knMmShiftedColor, KNODE, MmShiftedColor),
OFFSET(KnFreeCount, KNODE, FreeCount),
OFFSET(KnPfnDeferredList, KNODE, PfnDeferredList),
SIZE(KNODE_SIZE, KNODE),
HEADER("KSPIN_LOCK_QUEUE"),
OFFSET(LqNext, KSPIN_LOCK_QUEUE, Next),
OFFSET(LqLock, KSPIN_LOCK_QUEUE, Lock),
HEADER("KLOCK_QUEUE_HANDLE"),
OFFSET(LqhNext, KLOCK_QUEUE_HANDLE, LockQueue.Next),
OFFSET(LqhLock, KLOCK_QUEUE_HANDLE, LockQueue.Lock),
OFFSET(LqhOldIrql, KLOCK_QUEUE_HANDLE, OldIrql),
SIZE(LOCK_QUEUE_HEADER_SIZE, KLOCK_QUEUE_HANDLE),
HEADER("LARGE_INTEGER"),
OFFSET(LiLowPart, LARGE_INTEGER, LowPart),
OFFSET(LiHighPart, LARGE_INTEGER, HighPart),
#if 0
HEADER("LOADER_PARAMETER_BLOCK (rel. to LoadOrderListHead)"),
RELOFFSET(LpbLoadOrderListHead, LOADER_PARAMETER_BLOCK, LoadOrderListHead, LoadOrderListHead),
RELOFFSET(LpbMemoryDescriptorListHead, LOADER_PARAMETER_BLOCK, MemoryDescriptorListHead, LoadOrderListHead),
RELOFFSET(LpbKernelStack, LOADER_PARAMETER_BLOCK, KernelStack, LoadOrderListHead),
RELOFFSET(LpbPrcb, LOADER_PARAMETER_BLOCK, Prcb, LoadOrderListHead),
RELOFFSET(LpbProcess, LOADER_PARAMETER_BLOCK, Process, LoadOrderListHead),
RELOFFSET(LpbThread, LOADER_PARAMETER_BLOCK, Thread, LoadOrderListHead),
RELOFFSET(LpbI386, LOADER_PARAMETER_BLOCK, u.I386, LoadOrderListHead),
RELOFFSET(LpbRegistryLength, LOADER_PARAMETER_BLOCK, RegistryLength, LoadOrderListHead),
RELOFFSET(LpbRegistryBase, LOADER_PARAMETER_BLOCK, RegistryBase, LoadOrderListHead),
RELOFFSET(LpbConfigurationRoot, LOADER_PARAMETER_BLOCK, ConfigurationRoot, LoadOrderListHead),
RELOFFSET(LpbArcBootDeviceName, LOADER_PARAMETER_BLOCK, ArcBootDeviceName, LoadOrderListHead),
RELOFFSET(LpbArcHalDeviceName, LOADER_PARAMETER_BLOCK, ArcHalDeviceName, LoadOrderListHead),
RELOFFSET(LpbLoadOptions, LOADER_PARAMETER_BLOCK, LoadOptions, LoadOrderListHead),
RELOFFSET(LpbExtension, LOADER_PARAMETER_BLOCK, Extension, LoadOrderListHead),
#endif
HEADER("LIST_ENTRY"),
OFFSET(LsFlink, LIST_ENTRY, Flink),
OFFSET(LsBlink, LIST_ENTRY, Blink),
HEADER("PEB"),
OFFSET(PeKernelCallbackTable, PEB, KernelCallbackTable),
SIZE(ProcessEnvironmentBlockLength, PEB),
HEADER("KPROFILE"),
OFFSET(PfType, KPROFILE, Type),
OFFSET(PfSize, KPROFILE, Size),
OFFSET(PfProfileListEntry, KPROFILE, ProfileListEntry),
OFFSET(PfProcess, KPROFILE, Process),
OFFSET(PfRangeBase, KPROFILE, RangeBase),
OFFSET(PfRangeLimit, KPROFILE, RangeLimit),
OFFSET(PfBucketShift, KPROFILE, BucketShift),
OFFSET(PfBuffer, KPROFILE, Buffer),
OFFSET(PfSegment, KPROFILE, Segment),
OFFSET(PfAffinity, KPROFILE, Affinity),
OFFSET(PfSource, KPROFILE, Source),
OFFSET(PfStarted, KPROFILE, Started),
SIZE(ProfileObjectLength, KPROFILE),
HEADER("PORT_MESSAGE"),
OFFSET(PmLength, PORT_MESSAGE, u1.Length),
OFFSET(PmZeroInit, PORT_MESSAGE, u2.ZeroInit),
OFFSET(PmClientId, PORT_MESSAGE, ClientId),
OFFSET(PmProcess, PORT_MESSAGE, ClientId.UniqueProcess),
OFFSET(PmThread, PORT_MESSAGE, ClientId.UniqueThread),
OFFSET(PmMessageId, PORT_MESSAGE, MessageId),
OFFSET(PmClientViewSize, PORT_MESSAGE, ClientViewSize),
SIZE(PortMessageLength, PORT_MESSAGE),
HEADER("KPROCESS"),
OFFSET(PrType, KPROCESS, Header.Type),
OFFSET(PrSize, KPROCESS, Header.Size),
OFFSET(PrSignalState, KPROCESS, Header.SignalState),
OFFSET(PrProfileListHead, KPROCESS, ProfileListHead),
OFFSET(PrDirectoryTableBase, KPROCESS, DirectoryTableBase),
#ifdef _M_IX86
OFFSET(PrLdtDescriptor, KPROCESS, LdtDescriptor),
OFFSET(PrIopmOffset, KPROCESS, IopmOffset),
OFFSET(PrInt21Descriptor, KPROCESS, Int21Descriptor),
OFFSET(PrVdmTrapcHandler, KPROCESS, VdmTrapcHandler),
//OFFSET(PrVdmObjects, KPROCESS, VdmObjects),
OFFSET(PrFlags, KPROCESS, Flags),
#endif
//OFFSET(PrInstrumentationCallback, KPROCESS, InstrumentationCallback),
OFFSET(PrActiveProcessors, KPROCESS, ActiveProcessors),
OFFSET(PrKernelTime, KPROCESS, KernelTime),
OFFSET(PrUserTime, KPROCESS, UserTime),
OFFSET(PrReadyListHead, KPROCESS, ReadyListHead),
OFFSET(PrSwapListEntry, KPROCESS, SwapListEntry),
OFFSET(PrThreadListHead, KPROCESS, ThreadListHead),
OFFSET(PrProcessLock, KPROCESS, ProcessLock),
OFFSET(PrAffinity, KPROCESS, Affinity),
OFFSET(PrProcessFlags, KPROCESS, ProcessFlags),
OFFSET(PrBasePriority, KPROCESS, BasePriority),
OFFSET(PrQuantumReset, KPROCESS, QuantumReset),
OFFSET(PrState, KPROCESS, State),
OFFSET(PrStackCount, KPROCESS, StackCount),
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
OFFSET(PrCycleTime, KPROCESS, CycleTime),
#endif
SIZE(KernelProcessObjectLength, KPROCESS),
HEADER("KQUEUE"),
OFFSET(QuType, KQUEUE, Header.Type),
OFFSET(QuSize, KQUEUE, Header.Size),
OFFSET(QuSignalState, KQUEUE, Header.SignalState),
OFFSET(QuEntryListHead, KQUEUE, EntryListHead),
OFFSET(QuCurrentCount, KQUEUE, CurrentCount),
OFFSET(QuMaximumCount, KQUEUE, MaximumCount),
OFFSET(QuThreadListHead, KQUEUE, ThreadListHead),
SIZE(QueueObjectLength, KQUEUE),
HEADER("STRING"),
OFFSET(StrLength, STRING, Length),
OFFSET(StrMaximumLength, STRING, MaximumLength),
OFFSET(StrBuffer, STRING, Buffer),
HEADER("TEB"),
OFFSET(TeCmTeb, TEB, NtTib),
#ifdef _M_IX86
OFFSET(TeExceptionList, TEB, NtTib.ExceptionList),
#endif
OFFSET(TeStackBase, TEB, NtTib.StackBase),
OFFSET(TeStackLimit, TEB, NtTib.StackLimit),
OFFSET(TeFiberData, TEB, NtTib.FiberData),
OFFSET(TeSelf, TEB, NtTib.Self),
OFFSET(TeEnvironmentPointer, TEB, EnvironmentPointer),
OFFSET(TeClientId, TEB, ClientId),
OFFSET(TeActiveRpcHandle, TEB, ActiveRpcHandle),
OFFSET(TeThreadLocalStoragePointer, TEB, ThreadLocalStoragePointer),
OFFSET(TeCountOfOwnedCriticalSections, TEB, CountOfOwnedCriticalSections),
OFFSET(TePeb, TEB, ProcessEnvironmentBlock),
OFFSET(TeCsrClientThread, TEB, CsrClientThread),
OFFSET(TeWOW32Reserved, TEB, WOW32Reserved),
//OFFSET(TeSoftFpcr, TEB, SoftFpcr),
OFFSET(TeExceptionCode, TEB, ExceptionCode),
OFFSET(TeActivationContextStackPointer, TEB, ActivationContextStackPointer),
OFFSET(TeGdiClientPID, TEB, GdiClientPID),
OFFSET(TeGdiClientTID, TEB, GdiClientTID),
OFFSET(TeGdiThreadLocalInfo, TEB, GdiThreadLocalInfo),
OFFSET(TeglDispatchTable, TEB, glDispatchTable),
OFFSET(TeglReserved1, TEB, glReserved1),
OFFSET(TeglReserved2, TEB, glReserved2),
OFFSET(TeglSectionInfo, TEB, glSectionInfo),
OFFSET(TeglSection, TEB, glSection),
OFFSET(TeglTable, TEB, glTable),
OFFSET(TeglCurrentRC, TEB, glCurrentRC),
OFFSET(TeglContext, TEB, glContext),
OFFSET(TeDeallocationStack, TEB, DeallocationStack),
OFFSET(TeTlsSlots, TEB, TlsSlots),
OFFSET(TeTlsExpansionSlots, TEB, TlsExpansionSlots),
OFFSET(TeLastErrorValue, TEB, LastErrorValue),
OFFSET(TeVdm, TEB, Vdm),
OFFSET(TeInstrumentation, TEB, Instrumentation),
OFFSET(TeGdiBatchCount, TEB, GdiBatchCount),
OFFSET(TeGuaranteedStackBytes, TEB, GuaranteedStackBytes),
OFFSET(TeFlsData, TEB, FlsData),
//OFFSET(TeProcessRundown, TEB, ProcessRundown),
SIZE(ThreadEnvironmentBlockLength, TEB),
HEADER("TIME_FIELDS"),
OFFSET(TfSecond, TIME_FIELDS, Second),
OFFSET(TfMinute, TIME_FIELDS, Minute),
OFFSET(TfHour, TIME_FIELDS, Hour),
OFFSET(TfWeekday, TIME_FIELDS, Weekday),
OFFSET(TfDay, TIME_FIELDS, Day),
OFFSET(TfMonth, TIME_FIELDS, Month),
OFFSET(TfYear, TIME_FIELDS, Year),
OFFSET(TfMilliseconds, TIME_FIELDS, Milliseconds),
HEADER("KTHREAD"),
OFFSET(ThType, KTHREAD, Header.Type),
//OFFSET(ThNpxIrql, KTHREAD, NpxIrql),
OFFSET(ThSize, KTHREAD, Header.Size),
OFFSET(ThLock, KTHREAD, Header.Lock),
OFFSET(ThDebugActive, KTHREAD, Header.DebugActive),
//OFFSET(ThThreadControlFlags, KTHREAD, DispatcherHeader.ThreadControlFlags),
OFFSET(ThSignalState, KTHREAD, Header.SignalState),
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
OFFSET(ThCycleTime, KTHREAD, CycleTime),
OFFSET(ThHighCycleTime, KTHREAD, HighCycleTime),
#endif
OFFSET(ThInitialStack, KTHREAD, InitialStack),
OFFSET(ThStackLimit, KTHREAD, StackLimit),
OFFSET(ThKernelStack, KTHREAD, KernelStack),
OFFSET(ThThreadLock, KTHREAD, ThreadLock),
//OFFSET(ThRunning, KTHREAD, Running),
OFFSET(ThAlerted, KTHREAD, Alerted),
//OFFSET(ThMiscFlags, KTHREAD, MiscFlags),
OFFSET(ThApcState, KTHREAD, ApcState),
OFFSET(ThPriority, KTHREAD, Priority),
OFFSET(ThSwapBusy, KTHREAD, SwapBusy),
OFFSET(ThNextProcessor, KTHREAD, NextProcessor),
OFFSET(ThDeferredProcessor, KTHREAD, DeferredProcessor),
OFFSET(ThApcQueueLock, KTHREAD, ApcQueueLock),
OFFSET(ThContextSwitches, KTHREAD, ContextSwitches),
OFFSET(ThState, KTHREAD, State),
OFFSET(ThNpxState, KTHREAD, NpxState),
OFFSET(ThWaitIrql, KTHREAD, WaitIrql),
OFFSET(ThWaitMode, KTHREAD, WaitMode),
OFFSET(ThWaitStatus, KTHREAD, WaitStatus),
OFFSET(ThWaitBlockList, KTHREAD, WaitBlockList),
OFFSET(ThGateObject, KTHREAD, GateObject),
OFFSET(ThWaitListEntry, KTHREAD, WaitListEntry),
OFFSET(ThSwapListEntry, KTHREAD, SwapListEntry),
OFFSET(ThQueue, KTHREAD, Queue),
OFFSET(ThWaitTime, KTHREAD, WaitTime),
OFFSET(ThCombinedApcDisable, KTHREAD, CombinedApcDisable),
OFFSET(ThKernelApcDisable, KTHREAD, KernelApcDisable),
OFFSET(ThSpecialApcDisable, KTHREAD, SpecialApcDisable),
OFFSET(ThTeb, KTHREAD, Teb),
OFFSET(ThTimer, KTHREAD, Timer),
OFFSET(ThThreadFlags, KTHREAD, ThreadFlags),
OFFSET(ThServiceTable, KTHREAD, ServiceTable),
OFFSET(ThWaitBlock, KTHREAD, WaitBlock),
OFFSET(ThResourceIndex, KTHREAD, ResourceIndex),
OFFSET(ThQueueListEntry, KTHREAD, QueueListEntry),
OFFSET(ThTrapFrame, KTHREAD, TrapFrame),
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
OFFSET(ThFirstArgument, KTHREAD, FirstArgument),
#endif
OFFSET(ThCallbackStack, KTHREAD, CallbackStack),
//OFFSET(ThCallbackDepth, KTHREAD, CallbackDepth),
OFFSET(ThApcStateIndex, KTHREAD, ApcStateIndex),
OFFSET(ThIdealProcessor, KTHREAD, IdealProcessor),
OFFSET(ThBasePriority, KTHREAD, BasePriority),
OFFSET(ThPriorityDecrement, KTHREAD, PriorityDecrement),
OFFSET(ThAdjustReason, KTHREAD, AdjustReason),
OFFSET(ThAdjustIncrement, KTHREAD, AdjustIncrement),
OFFSET(ThPreviousMode, KTHREAD, PreviousMode),
OFFSET(ThSaturation, KTHREAD, Saturation),
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
OFFSET(ThSystemCallNumber, KTHREAD, SystemCallNumber),
#endif
OFFSET(ThFreezeCount, KTHREAD, FreezeCount),
OFFSET(ThUserAffinity, KTHREAD, UserAffinity),
OFFSET(ThProcess, KTHREAD, Process),
OFFSET(ThAffinity, KTHREAD, Affinity),
OFFSET(ThUserIdealProcessor, KTHREAD, UserIdealProcessor),
OFFSET(ThApcStatePointer, KTHREAD, ApcStatePointer),
OFFSET(ThSavedApcState, KTHREAD, SavedApcState),
OFFSET(ThWaitReason, KTHREAD, WaitReason),
OFFSET(ThSuspendCount, KTHREAD, SuspendCount),
//OFFSET(ThCodePatchInProgress, KTHREAD, CodePatchInProgress),
OFFSET(ThWin32Thread, KTHREAD, Win32Thread),
OFFSET(ThStackBase, KTHREAD, StackBase),
OFFSET(ThSuspendApc, KTHREAD, SuspendApc),
OFFSET(ThPowerState, KTHREAD, PowerState),
OFFSET(ThKernelTime, KTHREAD, KernelTime),
OFFSET(ThLegoData, KTHREAD, LegoData),
OFFSET(ThLargeStack, KTHREAD, LargeStack),
OFFSET(ThUserTime, KTHREAD, UserTime),
OFFSET(ThSuspendSemaphore, KTHREAD, SuspendSemaphore),
OFFSET(ThSListFaultCount, KTHREAD, SListFaultCount),
OFFSET(ThThreadListEntry, KTHREAD, ThreadListEntry),
OFFSET(ThMutantListHead, KTHREAD, MutantListHead),
OFFSET(ThSListFaultAddress, KTHREAD, SListFaultAddress),
SIZE(KernelThreadObjectLength, KTHREAD),
SIZE(ExecutiveThreadObjectLength, ETHREAD),
HEADER("KTIMER"),
OFFSET(TiType, KTIMER, Header.Type),
OFFSET(TiSize, KTIMER, Header.Size),
OFFSET(TiInserted, KTIMER, Header.Inserted),
OFFSET(TiSignalState, KTIMER, Header.SignalState),
OFFSET(TiDueTime, KTIMER, DueTime),
OFFSET(TiTimerListEntry, KTIMER, TimerListEntry),
OFFSET(TiDpc, KTIMER, Dpc),
OFFSET(TiPeriod, KTIMER, Period),
SIZE(TimerObjectLength, KTIMER),
HEADER("TIME"),
//OFFSET(TmLowTime, TIME, LowTime),
//OFFSET(TmHighTime, TIME, HighTime),
#if 0
HEADER("SYSTEM_CONTEXT_SWITCH_INFORMATION (relative to FindAny)"),
RELOFFSET(TwFindAny, SYSTEM_CONTEXT_SWITCH_INFORMATION, FindAny, FindAny),
RELOFFSET(TwFindIdeal, SYSTEM_CONTEXT_SWITCH_INFORMATION, FindIdeal, FindAny),
RELOFFSET(TwFindLast, SYSTEM_CONTEXT_SWITCH_INFORMATION, FindLast, FindAny),
RELOFFSET(TwIdleAny, SYSTEM_CONTEXT_SWITCH_INFORMATION, IdleAny, FindAny),
RELOFFSET(TwIdleCurrent, SYSTEM_CONTEXT_SWITCH_INFORMATION, IdleCurrent, FindAny),
RELOFFSET(TwIdleIdeal, SYSTEM_CONTEXT_SWITCH_INFORMATION, IdleIdeal, FindAny),
RELOFFSET(TwIdleLast, SYSTEM_CONTEXT_SWITCH_INFORMATION, IdleLast, FindAny),
RELOFFSET(TwPreemptAny, SYSTEM_CONTEXT_SWITCH_INFORMATION, PreemptAny, FindAny),
RELOFFSET(TwPreemptCurrent, SYSTEM_CONTEXT_SWITCH_INFORMATION, PreemptCurrent, FindAny),
RELOFFSET(TwPreemptLast, SYSTEM_CONTEXT_SWITCH_INFORMATION, PreemptLast, FindAny),
RELOFFSET(TwSwitchToIdle, SYSTEM_CONTEXT_SWITCH_INFORMATION, SwitchToIdle, FindAny),
#endif
HEADER("KUSER_SHARED_DATA"),
OFFSET(UsTickCountMultiplier, KUSER_SHARED_DATA, TickCountMultiplier),
OFFSET(UsInterruptTime, KUSER_SHARED_DATA, InterruptTime),
OFFSET(UsSystemTime, KUSER_SHARED_DATA, SystemTime),
OFFSET(UsTimeZoneBias, KUSER_SHARED_DATA, TimeZoneBias),
OFFSET(UsImageNumberLow, KUSER_SHARED_DATA, ImageNumberLow),
OFFSET(UsImageNumberHigh, KUSER_SHARED_DATA, ImageNumberHigh),
OFFSET(UsNtSystemRoot, KUSER_SHARED_DATA, NtSystemRoot),
OFFSET(UsMaxStackTraceDepth, KUSER_SHARED_DATA, MaxStackTraceDepth),
OFFSET(UsCryptoExponent, KUSER_SHARED_DATA, CryptoExponent),
OFFSET(UsTimeZoneId, KUSER_SHARED_DATA, TimeZoneId),
OFFSET(UsLargePageMinimum, KUSER_SHARED_DATA, LargePageMinimum),
OFFSET(UsReserved2, KUSER_SHARED_DATA, Reserved2),
OFFSET(UsNtProductType, KUSER_SHARED_DATA, NtProductType),
OFFSET(UsProductTypeIsValid, KUSER_SHARED_DATA, ProductTypeIsValid),
OFFSET(UsNtMajorVersion, KUSER_SHARED_DATA, NtMajorVersion),
OFFSET(UsNtMinorVersion, KUSER_SHARED_DATA, NtMinorVersion),
OFFSET(UsProcessorFeatures, KUSER_SHARED_DATA, ProcessorFeatures),
OFFSET(UsReserved1, KUSER_SHARED_DATA, Reserved1),
OFFSET(UsReserved3, KUSER_SHARED_DATA, Reserved3),
OFFSET(UsTimeSlip, KUSER_SHARED_DATA, TimeSlip),
OFFSET(UsAlternativeArchitecture, KUSER_SHARED_DATA, AlternativeArchitecture),
OFFSET(UsSystemExpirationDate, KUSER_SHARED_DATA, SystemExpirationDate),
OFFSET(UsSuiteMask, KUSER_SHARED_DATA, SuiteMask),
OFFSET(UsKdDebuggerEnabled, KUSER_SHARED_DATA, KdDebuggerEnabled),
OFFSET(UsActiveConsoleId, KUSER_SHARED_DATA, ActiveConsoleId),
OFFSET(UsDismountCount, KUSER_SHARED_DATA, DismountCount),
OFFSET(UsComPlusPackage, KUSER_SHARED_DATA, ComPlusPackage),
OFFSET(UsLastSystemRITEventTickCount, KUSER_SHARED_DATA, LastSystemRITEventTickCount),
OFFSET(UsNumberOfPhysicalPages, KUSER_SHARED_DATA, NumberOfPhysicalPages),
OFFSET(UsSafeBootMode, KUSER_SHARED_DATA, SafeBootMode),
//OFFSET(UsTscQpcData, KUSER_SHARED_DATA, TscQpcData),
OFFSET(UsTestRetInstruction, KUSER_SHARED_DATA, TestRetInstruction),
OFFSET(UsSystemCall, KUSER_SHARED_DATA, SystemCall),
OFFSET(UsSystemCallReturn, KUSER_SHARED_DATA, SystemCallReturn),
OFFSET(UsSystemCallPad, KUSER_SHARED_DATA, SystemCallPad),
OFFSET(UsTickCount, KUSER_SHARED_DATA, TickCount),
OFFSET(UsTickCountQuad, KUSER_SHARED_DATA, TickCountQuad),
OFFSET(UsWow64SharedInformation, KUSER_SHARED_DATA, Wow64SharedInformation),
HEADER("KWAIT_BLOCK"),
OFFSET(WbWaitListEntry, KWAIT_BLOCK, WaitListEntry),
OFFSET(WbThread, KWAIT_BLOCK, Thread),
OFFSET(WbObject, KWAIT_BLOCK, Object),
OFFSET(WbNextWaitBlock, KWAIT_BLOCK, NextWaitBlock),
OFFSET(WbWaitKey, KWAIT_BLOCK, WaitKey),
OFFSET(WbWaitType, KWAIT_BLOCK, WaitType),
reactos/include/asm/syscalls.inc
-109
View File
@@ -1,109 +0,0 @@
#ifdef _M_IX86
#define KUSER_SHARED_SYSCALL HEX(7ffe0300)
#define KGDT_R0_CODE 8
MACRO(STUBCODE_U, Name, SyscallId, ArgCount)
StackBytes = 4 * ArgCount
FPO 0, 0, 0, 0, 0, FRAME_FPO
mov eax, SyscallId
mov ecx, KUSER_SHARED_SYSCALL
call dword ptr [ecx]
ret StackBytes
ENDM
MACRO(STUBCODE_K, Name, SyscallId, ArgCount)
StackBytes = 4 * &ArgCount
FPO 0, 0, 0, 0, 0, FRAME_FPO
mov eax, SyscallId
lea edx, [esp + 4]
pushfd
push KGDT_R0_CODE
call _KiSystemService
ret StackBytes
ENDM
#elif defined(_M_AMD64)
MACRO(STUBCODE_U, Name, SyscallId, ArgCount)
.ENDPROLOG
mov eax, SyscallId
mov r10, rcx
syscall
ret
ENDM
MACRO(STUBCODE_K, Name, SyscallId, ArgCount)
.ENDPROLOG
EXTERN Nt&Name:PROC
lea rax, Nt&Name[rip]
mov r10, ArgCount * 8
jmp KiZwSystemService
ENDM
#elif defined(_M_ARM)
MACRO(STUBCODE_U, Name, SyscallId, ArgCount)
swi #SyscallId
bx lr
ENDM
MACRO(STUBCODE_K, Name, SyscallId, ArgCount)
mov ip, lr
swi #SyscallId
bx ip
ENDM
#elif defined(_M_PPC)
MACRO(STUBCODE_U, Name, SyscallId, ArgCount)
stwu 1,-16(1)
mflr 0
stw 0,0(1)
li 0, SyscallId
sc
lwz 0,0(1)
mtlr 0
addi 1,1,16
blr
ENDM
#define STUBCODE_K STUBCODE_U
#elif defined(_M_MIPS)
MACRO(STUBCODE_U, Name, SyscallId, ArgCount)
li $8, KUSER_SHARED_SYSCALL
lw $8,0($8)
j $8
nop
ENDM
MACRO(STUBCODE_K, Name, SyscallId, ArgCount)
j KiSystemService
nop
ENDM
#else
#error unsupported architecture
#endif
#ifdef _M_IX86
MACRO(MAKE_LABEL, Name, StackBytes)
PUBLIC _&Name&@&StackBytes
_&Name&@&StackBytes:
ENDM
MACRO(START_PROC, Name, StackBytes)
PUBLIC _&Name&@&StackBytes
.PROC _&Name&@&StackBytes
ENDM
#else
MACRO(MAKE_LABEL, Name, StackBytes)
PUBLIC &Name
&Name:
ENDM
MACRO(START_PROC, Name, StackBytes)
PUBLIC &Name
.PROC &Name
ENDM
#endif
MACRO(STUB_U, Name, ArgCount)
MAKE_LABEL Zw&Name, %ArgCount * 4
START_PROC Nt&Name, %ArgCount * 4
STUBCODE_U Name, SyscallId, %ArgCount
.ENDP
SyscallId = SyscallId + 1
ENDM
MACRO(STUB_K, Name, ArgCount)
START_PROC Zw&Name, %ArgCount * 4
STUBCODE_K Name, SyscallId, %ArgCount
.ENDP
SyscallId = SyscallId + 1
ENDM
reactos/include/asm/trapamd64.inc
-244
View File
@@ -1,244 +0,0 @@
APIC_EOI = HEX(0FFFFFFFFFFFE00B0)
TF_VOLATILES = HEX(01)
TF_NONVOLATILES = HEX(02)
TF_XMM = HEX(04)
TF_SEGMENTS = HEX(08)
TF_DEBUG = HEX(10)
TF_IRQL = HEX(20)
TF_SAVE_ALL = (TF_VOLATILES OR TF_NONVOLATILES OR TF_XMM OR TF_SEGMENTS)
TF_HAS_ERROR_CODE = HEX(40)
TF_SEND_EOI = HEX(80)
//TF_SYSTEMSERVICE = (TRAPFLAG_VOLATILES or TRAPFLAG_DEBUG)
TF_CHECKUSERAPC = HEX(100)
/*
* Stack Layout:
* |-------------------|
* | KTRAP_FRAME |
* |-------------------| <- rbp
* | EXCEPTION_RECORD |
* |-------------------|
* | KEXCEPTION_FRAME |
* |-------------------| <- rsp
*
*/
/*
* EnterTrap - Allocate KTRAP_FRAME_LENGTH and save registers to it
*/
MACRO(EnterTrap, Flags)
LOCAL kernel_mode_entry
/* Save the trap flags for this trap */
CurrentTrapFlags = VAL(Flags)
/* Size of hardware trap frame */
if (Flags AND TF_HAS_ERROR_CODE)
.pushframe code
SIZE_INITIAL_FRAME = 6 * 8
else
.pushframe
SIZE_INITIAL_FRAME = 5 * 8
endif
/* Make room for a KTRAP_FRAME */
sub rsp, (KTRAP_FRAME_LENGTH - SIZE_INITIAL_FRAME)
.allocstack (KTRAP_FRAME_LENGTH - SIZE_INITIAL_FRAME)
/* Save rbp and rax */
mov [rsp + KTRAP_FRAME_Rbp], rbp
.savereg rbp, KTRAP_FRAME_Rbp
mov [rsp + KTRAP_FRAME_Rax], rax
.savereg rax, KTRAP_FRAME_Rax
/* Point rbp to the KTRAP_FRAME */
lea rbp, [rsp]
.setframe rbp, 0
if (Flags AND TF_NONVOLATILES)
/* Save non-volatile registers */
mov [rbp + KTRAP_FRAME_Rbx], rbx
.savereg rbx, KTRAP_FRAME_Rbx
mov [rbp + KTRAP_FRAME_Rdi], rdi
.savereg rdi, KTRAP_FRAME_Rdi
mov [rbp + KTRAP_FRAME_Rsi], rsi
.savereg rsi, KTRAP_FRAME_Rsi
endif
.endprolog
if (Flags AND TF_VOLATILES)
/* Save volatile registers */
mov [rbp + KTRAP_FRAME_Rcx], rcx
mov [rbp + KTRAP_FRAME_Rdx], rdx
mov [rbp + KTRAP_FRAME_R8], r8
mov [rbp + KTRAP_FRAME_R9], r9
mov [rbp + KTRAP_FRAME_R10], r10
mov [rbp + KTRAP_FRAME_R11], r11
endif
if (Flags AND TF_XMM)
/* Save xmm registers */
movdqa [rbp + KTRAP_FRAME_Xmm0], xmm0
movdqa [rbp + KTRAP_FRAME_Xmm1], xmm1
movdqa [rbp + KTRAP_FRAME_Xmm2], xmm2
movdqa [rbp + KTRAP_FRAME_Xmm3], xmm3
movdqa [rbp + KTRAP_FRAME_Xmm4], xmm4
movdqa [rbp + KTRAP_FRAME_Xmm5], xmm5
endif
if (Flags AND TF_SEGMENTS)
/* Save segment selectors */
mov [rbp + KTRAP_FRAME_SegDs], ds
mov [rbp + KTRAP_FRAME_SegEs], es
mov [rbp + KTRAP_FRAME_SegFs], fs
mov [rbp + KTRAP_FRAME_SegGs], gs
endif
/* Save previous mode and check if it was user mode */
mov ax, [rbp + KTRAP_FRAME_SegCs]
and al, 1
mov [rbp + KTRAP_FRAME_PreviousMode], al
jz kernel_mode_entry
/* Set sane segments */
mov ax, (KGDT64_R3_DATA or RPL_MASK)
mov ds, ax
mov es, ax
swapgs
kernel_mode_entry:
// if (Flags AND TF_IRQL)
/* Save previous irql */
mov rax, cr8
mov [rbp + KTRAP_FRAME_PreviousIrql], al
// endif
if (Flags AND TF_DEBUG)
/* Save debug registers */
mov rax, dr0
mov [rbp + KTRAP_FRAME_Dr0], rax
mov rax, dr1
mov [rbp + KTRAP_FRAME_Dr1], rax
mov rax, dr2
mov [rbp + KTRAP_FRAME_Dr2], rax
mov rax, dr3
mov [rbp + KTRAP_FRAME_Dr3], rax
mov rax, dr6
mov [rbp + KTRAP_FRAME_Dr6], rax
mov rax, dr7
mov [rbp + KTRAP_FRAME_Dr7], rax
endif
/* Make sure the direction flag is cleared */
cld
ENDM
/*
* ExitTrap - Restore registers and free stack space
*/
MACRO(ExitTrap, Flags)
LOCAL kernel_mode_return
#if DBG
/* Check previous irql */
mov rax, cr8
cmp [rbp + KTRAP_FRAME_PreviousIrql], al
je .irql_ok
int 3
.irql_ok:
#endif
if (Flags AND TF_SEGMENTS)
/* Restore segment selectors */
mov ds, [rbp + KTRAP_FRAME_SegDs]
mov es, [rbp + KTRAP_FRAME_SegEs]
mov fs, [rbp + KTRAP_FRAME_SegFs]
endif
if (Flags AND TF_IRQL)
/* Restore previous irql */
movzx rax, byte ptr [rbp + KTRAP_FRAME_PreviousIrql]
mov cr8, rax
endif
/* Check if we came from user mode */
test byte ptr [rbp + KTRAP_FRAME_SegCs], 1
jz kernel_mode_return
if (Flags AND TF_CHECKUSERAPC)
/* Load current thread into r10 */
mov r10, gs:[PcCurrentThread]
cmp byte ptr [r10 + KTHREAD_UserApcPending], 0
jne KiExitToUserApc
endif
/* Swap gs to user mode */
swapgs
kernel_mode_return:
if (Flags AND TF_NONVOLATILES)
/* Restore non-volatile registers */
mov rbx, [rbp + KTRAP_FRAME_Rbx]
mov rdi, [rbp + KTRAP_FRAME_Rdi]
mov rsi, [rbp + KTRAP_FRAME_Rsi]
endif
if (Flags AND TF_VOLATILES)
/* Restore volatile registers */
mov rax, [rbp + KTRAP_FRAME_Rax]
mov rcx, [rbp + KTRAP_FRAME_Rcx]
mov rdx, [rbp + KTRAP_FRAME_Rdx]
mov r8, [rbp + KTRAP_FRAME_R8]
mov r9, [rbp + KTRAP_FRAME_R9]
mov r10, [rbp + KTRAP_FRAME_R10]
mov r11, [rbp + KTRAP_FRAME_R11]
endif
if (Flags AND TF_XMM)
/* Restore xmm registers */
movdqa xmm0, [rbp + KTRAP_FRAME_Xmm0]
movdqa xmm1, [rbp + KTRAP_FRAME_Xmm1]
movdqa xmm2, [rbp + KTRAP_FRAME_Xmm2]
movdqa xmm3, [rbp + KTRAP_FRAME_Xmm3]
movdqa xmm4, [rbp + KTRAP_FRAME_Xmm4]
movdqa xmm5, [rbp + KTRAP_FRAME_Xmm5]
endif
/* Restore rbp */
mov rbp, [rbp + KTRAP_FRAME_Rbp]
/* Adjust stack pointer */
add rsp, KTRAP_FRAME_Rip
if (Flags AND TF_SEND_EOI)
/* Write 0 to the local APIC EOI register */
mov dword ptr [APIC_EOI], 0
endif
/* Return from the trap */
iretq
ENDM
MACRO(TRAP_ENTRY, Trap, Flags)
EXTERN Trap&Handler :PROC
PUBLIC &Trap
FUNC &Trap
/* Common code to create the trap frame */
EnterTrap Flags
/* Call the C handler */
mov rcx, rbp
call Trap&Handler
/* Leave */
ExitTrap Flags
ENDFUNC
ENDM
reactos/include/c++/cerrno
-10
View File
@@ -1,10 +0,0 @@
// C++ forwarding C errno header.
#pragma once
#include <errno.h>
// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
#ifndef errno
#define errno errno
#endif
reactos/include/c++/cfloat
-9
View File
@@ -1,9 +0,0 @@
// C++ forwarding C float header.
//
// ISO C++ 14882: 18.2.2 Implementation properties: C library
//
#pragma once
#include <float.h>
reactos/include/c++/climits
-17
View File
@@ -1,17 +0,0 @@
// C limitations
#pragma once
#include <limits.h>
#ifndef LLONG_MIN
#define LLONG_MIN (-__LONG_LONG_MAX__ - 1)
#endif
#ifndef LLONG_MAX
#define LLONG_MAX __LONG_LONG_MAX__
#endif
#ifndef ULLONG_MAX
#define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1)
#endif
reactos/include/c++/clocale
-16
View File
@@ -1,16 +0,0 @@
// C++ forwarding C locale header.
#pragma once
#include <locale.h>
// Get rid of those macros defined in <locale.h> in lieu of real functions.
#undef setlocale
#undef localeconv
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
reactos/include/c++/cmath
-292
View File
@@ -1,292 +0,0 @@
//Standard C++ math declarations
#pragma once
#include <math.h>
// Get rid of those macros defined in <math.h> in lieu of real functions.
#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh
namespace std
{
// Forward declaration of a helper function. This really should be
// an `exported' forward declaration.
template<typename _Tp>
_Tp __cmath_power(_Tp, unsigned int);
template<typename _Tp>
inline _Tp
__pow_helper(_Tp __x, int __n)
{
return __n < 0
? _Tp(1)/__cmath_power(__x, -__n)
: __cmath_power(__x, __n);
}
inline double
abs(double __x)
{ return fabs(__x); }
inline float
abs(float __x)
{ return fabsf(__x); }
inline long double
abs(long double __x)
{ return fabsl(__x); }
using ::acos;
inline float
acos(float __x)
{ return acosf(__x); }
inline long double
acos(long double __x)
{ return acosl(__x); }
using ::asin;
inline float
asin(float __x)
{ return asinf(__x); }
inline long double
asin(long double __x)
{ return asinl(__x); }
using ::atan;
inline float
atan(float __x)
{ return atanf(__x); }
inline long double
atan(long double __x)
{ return atanl(__x); }
using ::atan2;
inline float
atan2(float __y, float __x)
{ return atan2f(__y, __x); }
inline long double
atan2(long double __y, long double __x)
{ return atan2l(__y, __x); }
using ::ceil;
inline float
ceil(float __x)
{ return ceilf(__x); }
inline long double
ceil(long double __x)
{ return ceill(__x); }
using ::cos;
inline float
cos(float __x)
{ return cosf(__x); }
inline long double
cos(long double __x)
{ return cosl(__x); }
using ::cosh;
inline float
cosh(float __x)
{ return coshf(__x); }
inline long double
cosh(long double __x)
{ return coshl(__x); }
using ::exp;
inline float
exp(float __x)
{ return expf(__x); }
inline long double
exp(long double __x)
{ return expl(__x); }
using ::fabs;
inline float
fabs(float __x)
{ return fabsf(__x); }
inline long double
fabs(long double __x)
{ return fabsl(__x); }
using ::floor;
inline float
floor(float __x)
{ return floorf(__x); }
inline long double
floor(long double __x)
{ return floorl(__x); }
using ::fmod;
inline float
fmod(float __x, float __y)
{ return fmodf(__x, __y); }
inline long double
fmod(long double __x, long double __y)
{ return fmodl(__x, __y); }
using ::frexp;
inline float
frexp(float __x, int* __exp)
{ return frexpf(__x, __exp); }
inline long double
frexp(long double __x, int* __exp)
{ return frexpl(__x, __exp); }
using ::ldexp;
inline float
ldexp(float __x, int __exp)
{ return ldexpf(__x, __exp); }
inline long double
ldexp(long double __x, int __exp)
{ return ldexpl(__x, __exp); }
using ::log;
inline float
log(float __x)
{ return logf(__x); }
inline long double
log(long double __x)
{ return logl(__x); }
using ::log10;
inline float
log10(float __x)
{ return log10f(__x); }
inline long double
log10(long double __x)
{ return log10l(__x); }
using ::modf;
inline float
modf(float __x, float* __iptr)
{ return modff(__x, __iptr); }
inline long double
modf(long double __x, long double* __iptr)
{ return modfl(__x, __iptr); }
using ::pow;
inline float
pow(float __x, float __y)
{ return powf(__x, __y); }
inline long double
pow(long double __x, long double __y)
{ return powl(__x, __y); }
inline double
pow(double __x, int __i)
{ return pow(__x, static_cast<double>(__i)); }
inline float
pow(float __x, int __n)
{ return powf(__x, static_cast<float>(__n)); }
inline long double
pow(long double __x, int __n)
{ return powl(__x, static_cast<long double>(__n)); }
using ::sin;
inline float
sin(float __x)
{ return sinf(__x); }
inline long double
sin(long double __x)
{ return sinl(__x); }
using ::sinh;
inline float
sinh(float __x)
{ return sinhf(__x); }
inline long double
sinh(long double __x)
{ return sinhl(__x); }
using ::sqrt;
inline float
sqrt(float __x)
{ return sqrtf(__x); }
inline long double
sqrt(long double __x)
{ return sqrtl(__x); }
using ::tan;
inline float
tan(float __x)
{ return tanf(__x); }
inline long double
tan(long double __x)
{ return tanl(__x); }
using ::tanh;
inline float
tanh(float __x)
{ return tanhf(__x); }
inline long double
tanh(long double __x)
{ return tanhl(__x); }
}
reactos/include/c++/cstddef
-11
View File
@@ -1,11 +0,0 @@
// ISO C++ standards definitions
#include <stddef.h>
#pragma once
namespace std
{
using ::ptrdiff_t;
using ::size_t;
}
reactos/include/c++/cstdio
-98
View File
@@ -1,98 +0,0 @@
// C++ forwarding C stdio header.
#pragma once
#include <cstddef>
#include <stdio.h>
// Get rid of those macros defined in <stdio.h> in lieu of real functions.
#undef clearerr
#undef fclose
#undef feof
#undef ferror
#undef fflush
#undef fgetc
#undef fgetpos
#undef fgets
#undef fopen
#undef fprintf
#undef fputc
#undef fputs
#undef fread
#undef freopen
#undef fscanf
#undef fseek
#undef fsetpos
#undef ftell
#undef fwrite
#undef getc
#undef getchar
#undef gets
#undef perror
#undef printf
#undef putc
#undef putchar
#undef puts
#undef remove
#undef rename
#undef rewind
#undef scanf
#undef setbuf
#undef setvbuf
#undef sprintf
#undef sscanf
#undef tmpfile
#undef tmpnam
#undef ungetc
#undef vfprintf
#undef vprintf
#undef vsprintf
namespace std
{
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;
using ::gets;
using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;
using ::tmpnam;
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
using ::vsnprintf;
}
reactos/include/c++/cstdlib
-77
View File
@@ -1,77 +0,0 @@
// Standard C library declarations
#pragma once
#include <cstddef>
#include <stdlib.h>
// Get rid of those macros defined in <stdlib.h> in lieu of real functions.
#undef abort
#undef abs
#undef atexit
#undef atof
#undef atoi
#undef atol
#undef bsearch
#undef calloc
#undef div
#undef exit
#undef free
#undef getenv
#undef labs
#undef ldiv
#undef malloc
#undef mblen
#undef mbstowcs
#undef mbtowc
#undef qsort
#undef rand
#undef realloc
#undef srand
#undef strtod
#undef strtol
#undef strtoul
#undef system
#undef wcstombs
#undef wctomb
namespace std
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
using ::atexit;
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
using ::qsort;
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
using ::wcstombs;
using ::wctomb;
inline long
abs(long __i) { return labs(__i); }
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
}
reactos/include/c++/cstring
-60
View File
@@ -1,60 +0,0 @@
// Standard C string declarations for C++
//
// ISO C++ 14882: 20.4.6 C library
//
#pragma once
#include <cstddef>
#include <string.h>
// Get rid of those macros defined in <string.h> in lieu of real functions.
#undef memchr
#undef memcmp
#undef memcpy
#undef memmove
#undef memset
#undef strcat
#undef strchr
#undef strcmp
#undef strcoll
#undef strcpy
#undef strcspn
#undef strerror
#undef strlen
#undef strncat
#undef strncmp
#undef strncpy
#undef strpbrk
#undef strrchr
#undef strspn
#undef strstr
#undef strtok
#undef strxfrm
namespace std
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
}
reactos/include/c++/ctime
-34
View File
@@ -1,34 +0,0 @@
// ISO C++ date and time declarations
#include <cstddef>
#include <time.h>
#pragma once
// Get rid of those macros defined in <time.h> in lieu of real functions.
#undef clock
#undef difftime
#undef mktime
#undef time
#undef asctime
#undef ctime
#undef gmtime
#undef localtime
#undef strftime
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
reactos/include/c++/cwchar
-152
View File
@@ -1,152 +0,0 @@
// C++ wchar forwarding header
#pragma once
#include <cstddef>
#include <wchar.h>
namespace std
{
using ::mbstate_t;
}
// Get rid of those macros defined in <wchar.h> in lieu of real functions.
#undef btowc
#undef fgetwc
#undef fgetws
#undef fputwc
#undef fputws
#undef fwide
#undef fwprintf
#undef fwscanf
#undef getwc
#undef getwchar
#undef mbrlen
#undef mbrtowc
#undef mbsinit
#undef mbsrtowcs
#undef putwc
#undef putwchar
#undef swprintf
#undef swscanf
#undef ungetwc
#undef vfwprintf
#undef vfwscanf
#undef vswprintf
#undef vswscanf
#undef vwprintf
#undef vwscanf
#undef wcrtomb
#undef wcscat
#undef wcschr
#undef wcscmp
#undef wcscoll
#undef wcscpy
#undef wcscspn
#undef wcsftime
#undef wcslen
#undef wcsncat
#undef wcsncmp
#undef wcsncpy
#undef wcspbrk
#undef wcsrchr
#undef wcsrtombs
#undef wcsspn
#undef wcsstr
#undef wcstod
#undef wcstof
#undef wcstok
#undef wcstol
#undef wcstoul
#undef wcsxfrm
#undef wctob
#undef wmemchr
#undef wmemcmp
#undef wmemcpy
#undef wmemmove
#undef wmemset
#undef wprintf
#undef wscanf
namespace std
{
using ::wint_t;
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
using ::swprintf;
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
using ::vfwscanf;
using ::vswprintf;
using ::vswscanf;
using ::vwprintf;
using ::vwscanf;
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
using ::wcstof;
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wcschr(const_cast<const wchar_t*>(__p), __c); }
inline wchar_t*
wcspbrk(wchar_t* __s1, const wchar_t* __s2)
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
inline wchar_t*
wcsrchr(wchar_t* __p, wchar_t __c)
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
inline wchar_t*
wcsstr(wchar_t* __s1, const wchar_t* __s2)
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
inline wchar_t*
wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
}
reactos/include/c++/exception
-52
View File
@@ -1,52 +0,0 @@
// Exception Handling support header for -*- C++ -*-
#ifndef __EXCEPTION__
#define __EXCEPTION__
extern "C++" {
class exception
{
public:
exception() throw();
exception(const char * const &) throw();
exception(const char * const &, int) throw();
virtual ~exception() throw();
virtual const char *what() const throw();
private:
const char *_name;
int _do_free;
};
class bad_exception : public exception
{
public:
bad_exception(const char *name = "bad exception") throw()
: exception(name) { }
virtual ~bad_exception() throw() { }
};
namespace std
{
using ::exception;
using ::bad_exception;
typedef void (*unexpected_handler) ();
unexpected_handler set_unexpected(unexpected_handler) throw();
__MINGW_ATTRIB_NORETURN void unexpected();
bool uncaught_exception() throw();
} // namespace std
typedef void (*terminate_handler) ();
terminate_handler set_terminate(terminate_handler) throw();
__MINGW_ATTRIB_NORETURN void terminate() throw();
} // extern "C++"
#endif
reactos/include/c++/fstream
View File
reactos/include/c++/ios
View File
reactos/include/c++/iostream
View File
reactos/include/c++/istream
View File
reactos/include/c++/limits
-1122
View File
File diff suppressed because it is too large Load Diff
reactos/include/c++/new
-47
View File
@@ -1,47 +0,0 @@
// Standard C++ dynamic memory management header
#ifndef _NEW
#define _NEW
#include <cstddef>
#include <exception>
extern "C++" {
class bad_alloc : public exception
{
public:
bad_alloc(const char *name = "bad alloc") throw()
: exception(name) { }
virtual ~bad_alloc() throw() { }
};
namespace std
{
using ::bad_alloc;
struct nothrow_t { };
extern const nothrow_t nothrow;
} // namespace std
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
void* operator new (std::size_t size, const std::nothrow_t& nothrow_constant) throw();
inline void* operator new (std::size_t size, void* ptr) throw() { return ptr; }
void* operator new[] (std::size_t size, const std::nothrow_t& nothrow_constant) throw();
inline void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; }
void operator delete (void* ptr) throw ();
void operator delete (void* ptr, const std::nothrow_t& nothrow_constant) throw();
inline void operator delete (void* ptr, void* voidptr2) throw() { }
void operator delete[] (void* ptr) throw ();
void operator delete[] (void* ptr, const std::nothrow_t& nothrow_constant) throw();
inline void operator delete[] (void* ptr, void* voidptr2) throw() { }
} // extern "C++"
#endif
reactos/include/c++/sstream
View File
reactos/include/c++/stlport/algorithm
-62
View File
@@ -1,62 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_ALGORITHM
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1
# include <stl/_prolog.h>
# define _STLP_ALGORITHM
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1)
# ifndef _STLP_INTERNAL_CSTDIO
// remove() conflicts, <cstdio> should always go first
# include <stl/_cstdio.h>
# endif
# ifndef _STLP_INTERNAL_ALGO_H
# include <stl/_algo.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <algorithm>
# else
# include _STLP_NATIVE_HEADER(algorithm)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_ALGORITHM */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/assert.h
-50
View File
@@ -1,50 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x202
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x202) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
/* evc3 doesn't have assert.h; macro assert() is defined in stl_evc.h */
#ifndef _STLP_WCE_EVC3
# if !defined (assert)
# define _STLP_NATIVE_ASSERT_H_INCLUDED
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <assert.h>
# else
# include _STLP_NATIVE_C_HEADER(assert.h)
# endif
# endif
# if !defined (_STLP_NATIVE_ASSERT_H_INCLUDED)
/* See errno.h for additional information about this #error */
# error assert has been defined before inclusion of assert.h header.
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x202)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
/* Local Variables:
* mode:C++
* End:
*/
reactos/include/c++/stlport/bitset
-70
View File
@@ -1,70 +0,0 @@
/*
* Copyright (c) 1998
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_BITSET
// This implementation of bitset<> has a second template parameter,
// _WordT, which defaults to unsigned long. *YOU SHOULD NOT USE
// THIS FEATURE*. It is experimental, and it may be removed in
// future releases.
// A bitset of size N, using words of type _WordT, will have
// N % (sizeof(_WordT) * CHAR_BIT) unused bits. (They are the high-
// order bits in the highest word.) It is a class invariant
// of class bitset<> that those unused bits are always zero.
// Most of the actual code isn't contained in bitset<> itself, but in the
// base class _Base_bitset. The base class works with whole words, not with
// individual bits. This allows us to specialize _Base_bitset for the
// important special case where the bitset is only a single word.
// The C++ standard does not define the precise semantics of operator[].
// In this implementation the const version of operator[] is equivalent
// to test(), except that it does no range checking. The non-const version
// returns a reference to a bit, again without doing any range checking.
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x2
# include <stl/_prolog.h>
# define _STLP_BITSET
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x2)
# ifndef _STLP_INTERNAL_BITSET
# include <stl/_bitset.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x2) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <bitset>
# else
# include _STLP_NATIVE_HEADER(bitset)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x2 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_BITSET */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cassert
-46
View File
@@ -1,46 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x103
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x103) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#if !defined (_STLP_WCE_EVC3)
# if defined (_STLP_USE_NEW_C_HEADERS)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cassert>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cassert)
# endif
# else
# include <assert.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x103 )
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cctype
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CCTYPE
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x104
# define _STLP_CCTYPE
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x104 )
# ifndef _STLP_INTERNAL_CCTYPE
# include <stl/_cctype.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x104) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cctype>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cctype)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x104 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CCTYPE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cerrno
-55
View File
@@ -1,55 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CERRNO
#define _STLP_CERRNO
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x105
# include <stl/_prolog.h>
#endif
#ifndef _STLP_WCE
# if defined (_STLP_USE_NEW_C_HEADERS)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cerrno>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cerrno)
# endif
# else
# include <errno.h>
# endif
#endif
#ifndef errno /* errno is not a macro */
# if defined (_STLP_IMPORT_VENDOR_CSTD)
# if !defined (__IBMCPP__) && !defined (__hpux) && !defined (__MWERKS__) && !defined (_STLP_WCE)
_STLP_BEGIN_NAMESPACE
using _STLP_VENDOR_CSTD::errno;
_STLP_END_NAMESPACE
# endif
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x105 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CERRNO */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cfloat
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CFLOAT
#define _STLP_CFLOAT
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x106
# include <stl/_prolog.h>
#endif
// Borland defines some implementation constants in std:: namespace,
// we do not want to import them.
#if defined (_STLP_USE_NEW_C_HEADERS) && !defined (__BORLANDC__)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cfloat>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cfloat)
# endif
#else
# include <float.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x106 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CFLOAT */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ciso646
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CISO646
#define _STLP_CISO646
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x107
# include <stl/_prolog.h>
#endif
#if !defined(_STLP_WCE_EVC3) && !defined (__BORLANDC__)
# if defined (_STLP_USE_NEW_C_HEADERS)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <ciso646>
# else
# include _STLP_NATIVE_CPP_C_HEADER(ciso646)
# endif
# else
# include <iso646.h>
# endif /* _STLP_USE_NEW_C_HEADERS */
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x107 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CISO646 */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/climits
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CLIMITS
# define _STLP_CLIMITS
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x108
# include <stl/_prolog.h>
#endif
#if defined (__SUNPRO_CC) && ((__SUNPRO_CC == 0x500) && (__SUNPRO_CC_COMPAT > 4))
# include </usr/include/limits.h>
#elif defined (_STLP_USE_NEW_C_HEADERS)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <climits>
# else
# include _STLP_NATIVE_CPP_C_HEADER(climits)
# endif
#else
# if defined (__BORLANDC__)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <limits.h>
# else
# include _STLP_NATIVE_C_HEADER(limits.h)
# endif
# else
# include <limits.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x108 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CLIMITS */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/clocale
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CLOCALE
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x109
# define _STLP_CLOCALE
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x109)
# ifndef _STLP_INTERNAL_CLOCALE
# include <stl/_clocale.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x109) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <clocale>
# else
# include _STLP_NATIVE_CPP_C_HEADER(clocale)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x109)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CLOCALE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cmath
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CMATH
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x110
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x110) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
# define _STLP_CMATH
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x110) && !defined (_STLP_DONT_POP_HEADER_ID)
# ifndef _STLP_INTERNAL_CMATH
# include <stl/_cmath.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x110) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cmath>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cmath)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x110)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
#endif /* _STLP_CMATH */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/complex
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_COMPLEX
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x10
# define _STLP_COMPLEX
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x10)
// This header declares the template class complex, as described in
// in the C++ Standard. Single-precision complex numbers
// are complex<float>, double-precision are complex<double>, and
// quad precision are complex<long double>.
// Note that the template class complex is declared within namespace
// std, as called for by the draft C++ standard
# ifndef _STLP_INTERNAL_COMPLEX
# include <stl/_complex.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x10) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <complex>
# else
# include _STLP_NATIVE_HEADER(complex)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x10 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_COMPLEX */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/csetjmp
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSETJMP
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x111
# define _STLP_CSETJMP
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x111)
# ifndef _STLP_INTERNAL_CSETJMP
# include <stl/_csetjmp.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x111) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <csetjmp>
# else
# include _STLP_NATIVE_CPP_C_HEADER(csetjmp)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x111 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CSETJMP */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/csignal
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSIGNAL
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x112
# define _STLP_CSIGNAL
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x112)
# ifndef _STLP_INTERNAL_CSIGNAL
# include <stl/_csignal.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x112) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <csignal>
# else
# include _STLP_NATIVE_CPP_C_HEADER(csignal)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x112 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CSIGNAL */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cstdarg
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSTDARG
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x113
# define _STLP_CSTDARG
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x113)
# ifndef _STLP_INTERNAL_CSTDARG
# include <stl/_cstdarg.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x113) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cstdarg>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cstdarg)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x113 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CSTDARG */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cstddef
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSTDDEF
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x114
# define _STLP_CSTDDEF
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x114)
# ifndef _STLP_INTERNAL_CSTDDEF
# include <stl/_cstddef.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x114) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cstddef>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cstddef)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x114 )
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CSTDDEF */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cstdio
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSTDIO
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x15
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x15) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
# define _STLP_CSTDIO
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x15) && !defined (_STLP_DONT_POP_HEADER_ID)
# ifndef _STLP_INTERNAL_CSTDIO
# include <stl/_cstdio.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x15) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cstdio>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cstdio)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x15)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
#endif
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cstdlib
-54
View File
@@ -1,54 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSTDLIB
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x116
# define _STLP_CSTDLIB
# include <stl/_prolog.h>
#endif
# if defined (__GNUC__) && defined (__MINGW32__)
/* Native cstdlib includes stdlib.h using an include_next so STLport stdlib.h
* is not used and the workaround in this file must be duplicated here
* (see stdlib.h). */
# include "errno.h"
# endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x116)
# ifndef _STLP_INTERNAL_CSTDLIB
# include <stl/_cstdlib.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x116) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cstdlib>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cstdlib)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x116)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CSTDLIB */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cstring
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CSTRING
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x117
# define _STLP_CSTRING
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x117)
# ifndef _STLP_INTERNAL_CSTRING
# include <stl/_cstring.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x117) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cstring>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cstring)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x117)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CSTRING */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ctime
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CTIME
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x118
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x118) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
# define _STLP_CTIME
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x118) && !defined (_STLP_DONT_POP_HEADER_ID)
# ifndef _STLP_INTERNAL_CTIME
# include <stl/_ctime.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x118) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <ctime>
# else
# include _STLP_NATIVE_CPP_C_HEADER(ctime)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x118)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
#endif /* _STLP_CTIME */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ctype.h
-114
View File
@@ -1,114 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CTYPE_H
/* Workaround for a "misbehaviour" when compiling resource scripts using
* eMbedded Visual C++. The standard .rc file includes windows header files,
* which in turn include ctype.h, which results in warnings and errors
*/
#if !defined(RC_INVOKED)
# if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x219
# include <stl/_prolog.h>
# elif (_STLP_OUTERMOST_HEADER_ID == 0x219)
# define _STLP_DONT_POP_HEADER_ID
# define _STLP_CTYPE_H
# endif
# if defined(_STLP_WCE_EVC3)
struct _exception;
# endif
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <ctype.h>
# else
# include _STLP_NATIVE_C_HEADER(ctype.h)
# endif
/* on evc4 including ctype.h also defines setjmp macro */
# if defined (_STLP_WCE)
# define _STLP_NATIVE_SETJMP_H_INCLUDED
# endif
# ifndef _STLP_CTYPE_H_SEEN
# define _STLP_CTYPE_H_SEEN
/* Undef convenience interfaces */
# undef isspace
# undef isprint
# undef iscntrl
# undef isupper
# undef islower
# undef isalpha
# undef isdigit
# undef ispunct
# undef isxdigit
# undef isalnum
# undef isgraph
# undef toupper
# undef tolower
# if defined (UNDER_CE)
# if (_WIN32_WCE < 300) /* Only wide chars for older versions */
# define _isctype iswctype
# endif
__inline int (isalpha)(int c) { return _isctype(c, _ALPHA); }
__inline int (isupper)(int c) { return _isctype(c, _UPPER); }
__inline int (islower)(int c) { return _isctype(c, _LOWER); }
__inline int (isdigit)(int c) { return _isctype(c, _DIGIT); }
__inline int (isxdigit)(int c) { return _isctype(c, _HEX); }
__inline int (isspace)(int c) { return _isctype(c, _SPACE); }
__inline int (ispunct)(int c) { return _isctype(c, _PUNCT); }
__inline int (isalnum)(int c) { return _isctype(c, _ALPHA|_DIGIT); }
__inline int (isprint)(int c) { return _isctype(c, _BLANK|_PUNCT|_ALPHA|_DIGIT); }
__inline int (isgraph)(int c) { return _isctype(c, _PUNCT|_ALPHA|_DIGIT); }
__inline int (iscntrl)(int c) { return _isctype(c, _CONTROL); }
__inline int (isascii)(int c) { return ((unsigned)(c) < 0x80); }
# undef _isctype
__inline int (iswalpha)(int c) { return iswctype((unsigned short)(c), _ALPHA); }
__inline int (iswupper)(int c) { return iswctype((unsigned short)(c), _UPPER); }
__inline int (iswlower)(int c) { return iswctype((unsigned short)(c), _LOWER); }
__inline int (iswdigit)(int c) { return iswctype((unsigned short)(c), _DIGIT); }
__inline int (iswxdigit)(int c) { return iswctype((unsigned short)(c), _HEX); }
__inline int (iswspace)(int c) { return iswctype((unsigned short)(c), _SPACE); }
__inline int (iswpunct)(int c) { return iswctype((unsigned short)(c), _PUNCT); }
__inline int (iswalnum)(int c) { return iswctype((unsigned short)(c), _ALPHA|_DIGIT); }
__inline int (iswprint)(int c) { return iswctype((unsigned short)(c), _BLANK|_PUNCT|_ALPHA|_DIGIT); }
__inline int (iswgraph)(int c) { return iswctype((unsigned short)(c), _PUNCT|_ALPHA|_DIGIT); }
__inline int (iswcntrl)(int c) { return iswctype((unsigned short)(c), _CONTROL); }
__inline int (iswascii)(int c) { return ((unsigned)(c) < 0x80); }
# endif /* UNDER_CE */
# endif /* _STLP_CTYPE_H_SEEN */
# if (_STLP_OUTERMOST_HEADER_ID == 0x219)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
# endif
#endif /* RC_INVOKED */
#endif /* _STLP_CTYPE_H */
reactos/include/c++/stlport/cwchar
-48
View File
@@ -1,48 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CWCHAR
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x120
# define _STLP_CWCHAR
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x120)
# ifndef _STLP_INTERNAL_CWCHAR
# include <stl/_cwchar.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x120) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cwchar>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cwchar)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x120)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CWCHAR */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/cwctype
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_CWCTYPE
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x121
# define _STLP_CWCTYPE
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x121)
# ifndef _STLP_INTERNAL_CWCTYPE
# include <stl/_cwctype.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x121) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <cwctype>
# else
# include _STLP_NATIVE_CPP_C_HEADER(cwctype)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x121)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_CWCTYPE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/deque
-57
View File
@@ -1,57 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_DEQUE
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x22
# include <stl/_prolog.h>
# define _STLP_DEQUE
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x22)
# ifndef _STLP_INTERNAL_DEQUE_H
# include <stl/_deque.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x22) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <deque>
# else
# include _STLP_NATIVE_HEADER(deque)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x22)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_DEQUE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/errno.h
-71
View File
@@ -1,71 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x205
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x205) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#ifdef _STLP_WCE
/* only show message when directly including this file in a non-library build */
# if !defined(__BUILDING_STLPORT) && (_STLP_OUTERMOST_HEADER_ID == 0x205)
# pragma message("eMbedded Visual C++ 3 and .NET don't have a errno.h header; STLport won't include native errno.h here")
# endif
#else
# ifndef errno
/* We define the following macro first to guaranty the header reentrancy: */
# define _STLP_NATIVE_ERRNO_H_INCLUDED
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <errno.h>
# else
# include _STLP_NATIVE_C_HEADER(errno.h)
# endif
# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x590) && defined (__cplusplus)
_STLP_BEGIN_NAMESPACE
using _STLP_VENDOR_CSTD::__errno;
_STLP_END_NAMESPACE
# endif
# endif /* errno */
# if !defined (_STLP_NATIVE_ERRNO_H_INCLUDED)
/* If errno has been defined before inclusion of native errno.h including it from STLport errno.h
* becomes impossible because if:
* #define errno foo
* then
* #include _STLP_NATIVE_C_HEADER(errno.h)
* becomes:
* #include _STLP_NATIVE_C_HEADER(foo.h)
*
* To fix this problem you have to find where this definition comes from and include errno.h before it.
*/
# define errno foo
# error errno has been defined before inclusion of errno.h header.
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x205)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
/* Local Variables:
* mode: C
* End:
*/
reactos/include/c++/stlport/exception
-68
View File
@@ -1,68 +0,0 @@
/*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*/
// This header exists solely for portability. Normally it just includes
// the native header <exception>.
#ifndef _STLP_EXCEPTION
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x423
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x423)
# define _STLP_DONT_POP_HEADER_ID
# define _STLP_EXCEPTION
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x423) && !defined (_STLP_DONT_POP_HEADER_ID)
# ifndef _STLP_INTERNAL_EXCEPTION
# include <stl/_exception.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x423) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
/* If we are here it means that we are in an include called
* from the native lib which means that we can simply forward this
* call to the native exception header:
*/
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <exception>
# else
# if defined (__DMC__) && (_STLP_OUTERMOST_HEADER_ID == 0x874)
// Workaround to DMC harcoded typeinfo.h inclusion.
# include <../include/exception>
# else
# include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception)
# endif
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x423)
# if !defined(_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
#endif /* _STLP_EXCEPTION */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/exception.h
-43
View File
@@ -1,43 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_OLDSTD_exception
#define _STLP_OLDSTD_exception
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x824
# include <stl/_prolog.h>
#endif
#if defined (__BORLANDC__) || defined (_MSC_VER)
# include <exception>
#else
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <exception.h>
# else
# include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception.h)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x824)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_OLDSTD_exception */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/float.h
-52
View File
@@ -1,52 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x203
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x203) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#elif (_STLP_OUTERMOST_HEADER_ID == 0x203)
# error This header is only reentrant once, it should be modified if it has to be included more.
#endif
#if defined (_STLP_WCE_EVC3)
struct _exception;
#endif
#if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <float.h>
#else
# include _STLP_NATIVE_C_HEADER(float.h)
#endif
#if !defined (__linux__)
# if defined(__BORLANDC__) && defined (__cplusplus) && (__BORLANDC__ >= 0x560)
_STLP_BEGIN_NAMESPACE
using ::_max_dble;
using ::_max_flt;
using ::_max_ldble;
using ::_tiny_ldble;
_STLP_END_NAMESPACE
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x203)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
reactos/include/c++/stlport/fstream
-66
View File
@@ -1,66 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
// This header defines classes basic_filebuf, basic_ifstream,
// basic_ofstream, and basic_fstream. These classes represent
// streambufs and streams whose sources or destinations are files.
#ifndef _STLP_FSTREAM
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1025
# include <stl/_prolog.h>
# define _STLP_FSTREAM
# if defined (__DMC__) && defined (_DLL)
# define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1025) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_FSTREAM_H
# include <stl/_fstream.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1025) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <fstream>
# else
# include _STLP_NATIVE_HEADER(fstream)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1025)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# if defined (__DMC__) && defined (_DLL)
# undef _STLP_CLASS_IMPORT_DECLSPEC
# define _STLP_CLASS_IMPORT_DECLSPEC
# endif
#endif
#endif /* _STLP_FSTREAM */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/fstream.h
-42
View File
@@ -1,42 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_FSTREAM_H
#define _STLP_FSTREAM_H
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x2026
# include <stl/_prolog.h>
#endif
#include <fstream>
// get desired pollution
#include <iostream.h>
#ifndef _STLP_HAS_NO_NAMESPACES
# include <using/fstream>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x2026)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_FSTREAM_H */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/functional
-148
View File
@@ -1,148 +0,0 @@
/*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_FUNCTIONAL
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x27
# include <stl/_prolog.h>
# define _STLP_FUNCTIONAL
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x27)
# ifndef _STLP_INTERNAL_FUNCTION_H
# include <stl/_function.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x27) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <functional>
# else
# include _STLP_NATIVE_HEADER(functional)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x27)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
#include <boost/ref.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/bind/placeholders.hpp>
#include <boost/mem_fn.hpp>
#include <boost/bind.hpp>
namespace boost {
template<class T> class reference_wrapper;
template<class T> reference_wrapper<T> const ref(T &);
template<class T> inline reference_wrapper<T const> const cref(T const &);
template<typename F> struct result_of;
namespace _mfi {
template<class R, class T> class dm;
}
template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f);
} // namespace boost
_STLP_BEGIN_NAMESPACE
namespace tr1 {
using ::boost::reference_wrapper;
using ::boost::ref;
using ::boost::cref;
using ::boost::result_of;
using ::boost::mem_fn;
using ::boost::bind;
namespace placeholders {
using ::_1;
using ::_2;
using ::_3;
using ::_4;
using ::_5;
using ::_6;
using ::_7;
using ::_8;
using ::_9;
} // placeholders
} // namespace tr1
_STLP_END_NAMESPACE
#endif // !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT
#endif /* _STLP_FUNCTIONAL */
#if !defined(_STLP_FUNCTIONAL_FUN) && !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
#ifndef BOOST_FUNCTION_NUM_ARGS // avoid recursive includes
// #ifdef BOOST_FUNCTION_BASE_HEADER
// #undef BOOST_FUNCTION_BASE_HEADER
// #endif
// #ifdef BOOST_FUNCTION_PROLOGUE_HPP
// #undef BOOST_FUNCTION_PROLOGUE_HPP
// #endif
#define _STLP_FUNCTIONAL_FUN
#ifndef BOOST_FUNCTION_BASE_HEADER // avoid recursive includes
# include <boost/function.hpp>
#else
namespace boost {
class bad_function_call;
template<typename Signature, typename Allocator >
class function;
template<typename Signature, typename Allocator>
void swap(function<Signature, Allocator>& f1, function<Signature, Allocator>& f2);
}
#endif
_STLP_BEGIN_NAMESPACE
namespace tr1 {
using ::boost::bad_function_call;
using ::boost::function;
using ::boost::swap;
} // namespace tr1
_STLP_END_NAMESPACE
#endif // !BOOST_FUNCTION_NUM_ARGS
#endif // !_STLP_FUNCTIONAL_REF && !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/hash_map
-49
View File
@@ -1,49 +0,0 @@
/*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_HASH_MAP
#define _STLP_HASH_MAP
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x4028
# include <stl/_prolog.h>
#endif
#ifdef _STLP_PRAGMA_ONCE
# pragma once
#endif
#if defined (_STLP_NO_EXTENSIONS)
/* Comment following if you want to use hash constainers even if you ask for
* no extension.
*/
# error The hash_map and hash_multimap class are STLport extensions.
#endif
#include <stl/_hash_map.h>
#if (_STLP_OUTERMOST_HEADER_ID == 0x4028)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_HASH_MAP */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/hash_set
-49
View File
@@ -1,49 +0,0 @@
/*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_HASH_SET
#define _STLP_HASH_SET
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x4029
# include <stl/_prolog.h>
#endif
#ifdef _STLP_PRAGMA_ONCE
# pragma once
#endif
#if defined (_STLP_NO_EXTENSIONS)
/* Comment following if you want to use hash constainers even if you ask for
* no extension.
*/
# error The hash_set and hash_multiset class are STLport extensions.
#endif
#include <stl/_hash_set.h>
#if (_STLP_OUTERMOST_HEADER_ID == 0x4029)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_HASH_SET */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/iomanip
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOMANIP
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1030
# include <stl/_prolog.h>
# define _STLP_IOMANIP
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1030) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_IOMANIP
# include <stl/_iomanip.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1030) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <iomanip>
# else
# include _STLP_NATIVE_HEADER(iomanip)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1030)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOMANIP */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/iomanip.h
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOMANIP_H
#define _STLP_IOMANIP_H
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x2031
# include <stl/_prolog.h>
#endif
#include <stl/_ioserr.h>
#include <iomanip>
#ifndef _STLP_HAS_NO_NAMESPACES
# ifdef _STLP_BROKEN_USING_DIRECTIVE
_STLP_USING_NAMESPACE(stlport)
# else
using _STLP_STD::setiosflags;
using _STLP_STD::resetiosflags;
using _STLP_STD::setbase;
using _STLP_STD::setfill;
using _STLP_STD::setprecision;
using _STLP_STD::setw;
# endif
#endif /* _STLP_HAS_NO_NAMESPACES */
// get all the pollution we want
#include <iostream.h>
#if (_STLP_OUTERMOST_HEADER_ID == 0x2031)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOMANIP_H */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ios
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOS
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1032
# include <stl/_prolog.h>
# define _STLP_IOS
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1032) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_IOS_H
# include <stl/_ios.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1032) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <ios>
# else
# include _STLP_NATIVE_HEADER(ios)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1032)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOS */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ios.h
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOS_H
#define _STLP_IOS_H
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1033
# include <stl/_prolog.h>
#endif
#include <ios>
#if defined (_STLP_USE_NAMESPACES)
# include <using/ios>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1033)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOS_H */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/iosfwd
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOSFWD
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1034
# include <stl/_prolog.h>
# define _STLP_IOSFWD
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1034) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_IOSFWD
# include <stl/_iosfwd.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1034) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <iosfwd>
# else
# include _STLP_NATIVE_HEADER(iosfwd)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1034)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOSFWD */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/iostream
-104
View File
@@ -1,104 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOSTREAM
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1037
# include <stl/_prolog.h>
# define _STLP_IOSTREAM
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1037) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifdef _STLP_REDIRECT_STDSTREAMS
// for ofstream redirection
# ifndef _STLP_INTERNAL_FSTREAM_H
# include <stl/_fstream.h>
# endif
# endif
# ifndef _STLP_INTERNAL_IOSFWD
# include <stl/_iosfwd.h>
# endif
# ifndef _STLP_INTERNAL_ISTREAM
# include <stl/_istream.h>
# endif
_STLP_BEGIN_NAMESPACE
# ifndef _STLP_USE_NAMESPACES
// in case of SGI iostreams, we have to rename our streams not to clash with those
// provided in native lib
# define cin _STLP_cin
# define cout _STLP_cout
# define cerr _STLP_cerr
# define clog _STLP_clog
# endif
// Note: cin and wcin are both associated with stdio. The C standard
// (Amendment 1, section 4.6.2.1) says that it is an error to mix
// wide- and narrow-oriented I/O on the same stream. This implies
// that it is an error to use both cin and wcin in the same C++
// program; the same applies to cout and wcout, and cerr/clog and
// wcerr/wclog.
extern _STLP_DECLSPEC istream cin;
# ifdef _STLP_REDIRECT_STDSTREAMS
extern _STLP_DECLSPEC ofstream cout;
extern _STLP_DECLSPEC ofstream cerr;
extern _STLP_DECLSPEC ofstream clog;
# else
extern _STLP_DECLSPEC ostream cout;
extern _STLP_DECLSPEC ostream cerr;
extern _STLP_DECLSPEC ostream clog;
# endif
# ifndef _STLP_NO_WCHAR_T
extern _STLP_DECLSPEC wistream wcin;
extern _STLP_DECLSPEC wostream wcout;
extern _STLP_DECLSPEC wostream wcerr;
extern _STLP_DECLSPEC wostream wclog;
# endif
_STLP_END_NAMESPACE
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1037) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <iostream>
# else
# include _STLP_NATIVE_HEADER(iostream)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1037)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOSTREAM */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/iostream.h
-106
View File
@@ -1,106 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_IOSTREAM_H
#define _STLP_IOSTREAM_H
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x2035
# include <stl/_prolog.h>
#endif
#include <iostream>
// Those should be included all separately, as they do contain using declarations
#include <streambuf.h>
#include <ostream.h>
#include <istream.h>
#ifndef _STLP_HAS_NO_NAMESPACES
# ifdef _STLP_BROKEN_USING_DIRECTIVE
_STLP_USING_NAMESPACE(stlport)
# else
using _STLP_STD::cin;
using _STLP_STD::cout;
using _STLP_STD::clog;
using _STLP_STD::cerr;
using _STLP_STD::iostream;
# ifndef _STLP_NO_WCHAR_T
using _STLP_STD::wcin;
using _STLP_STD::wcout;
using _STLP_STD::wclog;
using _STLP_STD::wcerr;
# endif
# endif
#endif /* _STLP_HAS_NO_NAMESPACES */
// Obsolete classes for old-style backwards compatibility
class istream_withassign : public istream {
public:
istream_withassign() : istream((streambuf*)0) {}
~istream_withassign() {}
istream_withassign& operator=(istream& __s) {
ios::init(__s.rdbuf());
return *this;
}
istream_withassign& operator=(streambuf* __s) {
ios::init(__s);
return *this;
}
};
class ostream_withassign : public ostream {
public:
ostream_withassign() : ostream((streambuf*)0) {}
~ostream_withassign() {}
ostream_withassign& operator=(ostream& __s) {
ios::init(__s.rdbuf());
return *this;
}
ostream_withassign& operator=(streambuf* __s) {
ios::init(__s);
return *this;
}
};
class iostream_withassign : public iostream {
public:
iostream_withassign() : iostream((streambuf*)0) {}
~iostream_withassign() {}
iostream_withassign & operator=(ios& __i) {
ios::init(__i.rdbuf());
return *this;
}
iostream_withassign & operator=(streambuf* __s) {
ios::init(__s);
return *this;
}
} ;
#if (_STLP_OUTERMOST_HEADER_ID == 0x2035)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_IOSTREAM_H */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/iso646.h
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x204
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x204) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
/* evc3 doesn't have iso646.h */
#if !defined (_STLP_WCE_EVC3) && !defined (__BORLANDC__)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <iso646.h>
# else
# include _STLP_NATIVE_C_HEADER(iso646.h)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x204)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
reactos/include/c++/stlport/istream
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_ISTREAM
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1036
# include <stl/_prolog.h>
# define _STLP_ISTREAM
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1036) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_ISTREAM
# include <stl/_istream.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1036) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <istream>
# else
# include _STLP_NATIVE_HEADER(istream)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1036)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_ISTREAM */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/istream.h
-50
View File
@@ -1,50 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_ISTREAM_H
#define _STLP_ISTREAM_H
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x2037
# include <stl/_prolog.h>
#endif
#include <stl/_ioserr.h>
#include <istream>
#ifndef _STLP_HAS_NO_NAMESPACES
# ifdef _STLP_BROKEN_USING_DIRECTIVE
_STLP_USING_NAMESPACE(stlport)
# else
using _STLP_STD::basic_istream;
using _STLP_STD::basic_iostream;
using _STLP_STD::istream;
using _STLP_STD::iostream;
using _STLP_STD::ios;
# ifndef _STLP_NO_WCHAR_T
using _STLP_STD::wistream;
using _STLP_STD::wiostream;
# endif
using _STLP_STD::ws;
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x2037)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_ISTREAM_H */
reactos/include/c++/stlport/iterator
-61
View File
@@ -1,61 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_ITERATOR
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x38
# include <stl/_prolog.h>
# define _STLP_ITERATOR
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x38)
# ifndef _STLP_INTERNAL_ITERATOR_H
# include <stl/_iterator.h>
# endif
# ifndef _STLP_INTERNAL_STREAM_ITERATOR_H
# include <stl/_stream_iterator.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x38) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <iterator>
# else
# include _STLP_NATIVE_HEADER(iterator)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x38)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_ITERATOR */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/limits
-50
View File
@@ -1,50 +0,0 @@
/*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_LIMITS
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x39
# include <stl/_prolog.h>
# define _STLP_LIMITS
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x39)
# ifndef _STLP_INTERNAL_LIMITS
# include <stl/_limits.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x39) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <limits>
# else
# include _STLP_NATIVE_HEADER(limits)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x39)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_LIMITS */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/limits.h
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x201
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x201) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#if defined(_STLP_WCE_EVC3)
struct _exception;
#endif
#if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <limits.h>
#else
# include _STLP_NATIVE_C_HEADER(limits.h)
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x201)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
reactos/include/c++/stlport/list
-57
View File
@@ -1,57 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_LIST
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x40
# include <stl/_prolog.h>
# define _STLP_LIST
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x40)
# ifndef _STLP_INTERNAL_LIST_H
# include <stl/_list.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x40) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <list>
# else
# include _STLP_NATIVE_HEADER(list)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x40)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_LIST */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/locale
-156
View File
@@ -1,156 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_LOCALE
// Basic framework: class locale and class locale::facet
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1041
# include <stl/_prolog.h>
# define _STLP_LOCALE
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1041) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
// Individual facets
# ifndef _STLP_INTERNAL_CTYPE_H
# include <stl/_ctype.h>
# endif
# ifndef _STLP_INTERNAL_CODECVT_H
# include <stl/_codecvt.h>
# endif
# ifndef _STLP_INTERNAL_COLLATE_H
# include <stl/_collate.h>
# endif
# ifndef _STLP_INTERNAL_NUM_PUT_H
# include <stl/_num_put.h>
# endif
# ifndef _STLP_INTERNAL_NUM_GET_H
# include <stl/_num_get.h>
# endif
// those never included separately anyway
# include <stl/_monetary.h>
# include <stl/_time_facets.h>
# include <stl/_messages_facets.h>
// some stuff for streambuf iterators ended up defined there
// Strictly speaking, _istream.h portion is only required for <iterator>, but it may break too many
// programs if we omit it
# ifndef _STLP_ISTREAM_H
# include <stl/_istream.h>
# endif
// Convenience interfaces
#undef isspace
#undef isprint
#undef iscntrl
#undef isupper
#undef islower
#undef isalpha
#undef isdigit
#undef ispunct
#undef isxdigit
#undef isalnum
#undef isgraph
#undef toupper
#undef tolower
_STLP_BEGIN_NAMESPACE
template <class _CharT>
inline bool isspace (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::space, c); }
template <class _CharT>
inline bool isprint (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::print, c); }
template <class _CharT>
inline bool iscntrl (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::cntrl, c); }
template <class _CharT>
inline bool isupper (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::upper, c); }
template <class _CharT>
inline bool islower (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::lower, c); }
template <class _CharT>
inline bool isalpha (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::alpha, c); }
template <class _CharT>
inline bool isdigit (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::digit, c); }
template <class _CharT>
inline bool ispunct (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::punct, c); }
template <class _CharT>
inline bool isxdigit (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::xdigit, c); }
template <class _CharT>
inline bool isalnum (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::alnum, c); }
template <class _CharT>
inline bool isgraph (_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::graph, c); }
template <class _CharT>
inline _CharT toupper(_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).toupper(c); }
template <class _CharT>
inline _CharT tolower(_CharT c, const locale& loc)
{ return (use_facet<ctype<_CharT> >(loc)).tolower(c); }
_STLP_END_NAMESPACE
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1041) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <locale>
# else
# include _STLP_NATIVE_HEADER(locale)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1041)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_LOCALE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/locale.h
-43
View File
@@ -1,43 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x242
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x242)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
# else
# error STLport include schema violation
# endif
#endif
/* evc3 doesn't have locale.h */
#ifndef _STLP_WCE_EVC3
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <locale.h>
# else
# include _STLP_NATIVE_C_HEADER(locale.h)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x242)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
reactos/include/c++/stlport/map
-57
View File
@@ -1,57 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_MAP
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x43
# include <stl/_prolog.h>
# define _STLP_MAP
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x43)
# ifndef _STLP_INTERNAL_MAP_H
# include <stl/_map.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x43) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <map>
# else
# include _STLP_NATIVE_HEADER(map)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x43)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_MAP */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/math.h
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x244
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x244) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#if !defined (exception) && (!defined (__KCC) || (__KCC_VERSION < 4000)) && \
!(defined(__IBMCPP__) && (500 <= __IBMCPP__)) && !defined(_STLP_WCE_EVC3)
# define _STLP_EXCEPTION_WAS_REDEFINED 1
# define exception __math_exception
#endif
#if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <math.h>
#else
# include _STLP_NATIVE_C_HEADER(math.h)
#endif
#if defined (_STLP_EXCEPTION_WAS_REDEFINED)
# undef exception
# undef _STLP_EXCEPTION_WAS_REDEFINED
#endif
#ifdef _STLP_WCE_EVC3
# undef _exception
# define _exception exception
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x244)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
reactos/include/c++/stlport/mem.h
-58
View File
@@ -1,58 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_mem_h
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x245
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x245) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x245) || defined (_STLP_DONT_POP_HEADER_ID)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <mem.h>
# else
# include _STLP_NATIVE_C_HEADER(mem.h)
# endif
#else
# if defined (__BORLANDC__) && defined (__USING_CNAME__)
# define _USING_CNAME_WAS_UNDEFINED
# undef __USING_CNAME__
# endif
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <mem.h>
# else
# include _STLP_NATIVE_C_HEADER(mem.h)
# endif
# if defined (__BORLANDC__) && defined (_USING_CNAME_WAS_UNDEFINED)
# define __USING_CNAME__
# define _STLP_mem_h 1
# undef _USING_CNAME_WAS_UNDEFINED
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x245)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
#endif /* _STLP_mem_h */
reactos/include/c++/stlport/memory
-130
View File
@@ -1,130 +0,0 @@
/*
* Copyright (c) 1997-1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_MEMORY
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x46
# include <stl/_prolog.h>
# define _STLP_MEMORY
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x46)
# ifndef _STLP_INTERNAL_ALLOC_H
# include <stl/_alloc.h>
# endif
# ifndef _STLP_INTERNAL_TEMPBUF_H
# include <stl/_tempbuf.h>
# endif
# ifndef _STLP_INTERNAL_RAW_STORAGE_ITER_H
# include <stl/_raw_storage_iter.h>
# endif
# include <stl/_auto_ptr.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x46) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (__MSL__)
# include _STLP_NATIVE_HEADER(limits)
# endif
# if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
# define BOOST_TR1_MEMORY_INCLUDED
# define BOOST_TR1_FULL_MEMORY_INCLUDED
# endif
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <memory>
# else
# include _STLP_NATIVE_HEADER(memory)
# endif
# if defined (__MSL__) && (__MSL__ >= 0x2405 && __MSL__ < 0x5201)
/* 980401 vss MSL 2.4 Pro 3 Release */
# include <new_mem.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x46)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
namespace boost {
class bad_weak_ptr;
template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
template<class D, class T> D * get_deleter(shared_ptr<T> const & p);
template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r);
template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b);
template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b);
namespace detail{
class shared_count;
class weak_count;
}
} // namespace boost
# ifndef BOOST_SHARED_PTR_HPP_INCLUDED
# include <boost/shared_ptr.hpp>
# endif
# ifndef BOOST_WEAK_PTR_HPP_INCLUDED
# include <boost/weak_ptr.hpp>
# endif
# ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
# include <boost/enable_shared_from_this.hpp>
# endif
_STLP_BEGIN_NAMESPACE
namespace tr1 {
using ::boost::bad_weak_ptr;
using ::boost::shared_ptr;
using ::boost::swap;
using ::boost::static_pointer_cast;
using ::boost::dynamic_pointer_cast;
using ::boost::const_pointer_cast;
using ::boost::get_deleter;
using ::boost::weak_ptr;
using ::boost::enable_shared_from_this;
// shared_ptr IO
// weak_ptr IO
} // namespace tr1
_STLP_END_NAMESPACE
#endif /* !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT */
#endif /* _STLP_MEMORY */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/new
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_NEW_HEADER
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x447
# define _STLP_NEW_HEADER
# include <stl/_prolog.h>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x447)
# ifndef _STLP_NEW_H_HEADER
# include <stl/_new.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x447) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <new>
# else
# include _STLP_NATIVE_CPP_RUNTIME_HEADER(new)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x447)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_NEW */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/new.h
-50
View File
@@ -1,50 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x848
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x848) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#if !defined(_STLP_NO_NEW_HEADER)
# if defined (__BORLANDC__)
# include <new>
# elif defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <new.h>
# elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800 && !defined(_MSC_VER))
# include _STLP_NATIVE_OLD_STREAMS_HEADER(new.h)
# else
# if defined (__GNUC__) && (__GNUC__ >= 3)
# include _STLP_NATIVE_OLD_STREAMS_HEADER(new.h)
# else
# include _STLP_NATIVE_CPP_RUNTIME_HEADER(new.h)
# endif
# endif
#endif /* !defined(_STLP_NO_NEW_HEADER) */
#if (_STLP_OUTERMOST_HEADER_ID == 0x848)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/numeric
-54
View File
@@ -1,54 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_NUMERIC
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x49
# include <stl/_prolog.h>
# define _STLP_NUMERIC
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x49)
# ifndef _STLP_INTERNAL_NUMERIC_H
# include <stl/_numeric.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x49) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <numeric>
# else
# include _STLP_NATIVE_HEADER(numeric)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x49)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_NUMERIC */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ostream
-52
View File
@@ -1,52 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_OSTREAM
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1050
# include <stl/_prolog.h>
# define _STLP_OSTREAM
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1050) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_OSTREAM
# include <stl/_ostream.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1050) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <ostream>
# else
# include _STLP_NATIVE_HEADER(ostream)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1050)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_OSTREAM */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/ostream.h
-37
View File
@@ -1,37 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_OSTREAM_H
#define _STLP_OSTREAM_H
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x2051
# include <stl/_prolog.h>
#endif
#include <stl/_ioserr.h>
#include <ostream>
#ifdef _STLP_USE_NAMESPACES
# include <using/ostream>
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x2051)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_OSTREAM_H */
reactos/include/c++/stlport/pthread.h
-46
View File
@@ -1,46 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x280
# include <stl/_prolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x280) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
#if defined (__SUNPRO_CC) || defined (__HP_aCC)
# include "/usr/include/pthread.h"
#else
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <pthread.h>
# else
# include _STLP_NATIVE_C_HEADER(pthread.h)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x280)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
/*
Local Variables:
mode:C++
End:
*/
reactos/include/c++/stlport/pthread_alloc
-49
View File
@@ -1,49 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_PTHREAD_ALLOC
#define _STLP_PTHREAD_ALLOC
# ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x52
# include <stl/_prolog.h>
# endif
# ifdef _STLP_PRAGMA_ONCE
# pragma once
# endif
# include <stl/_pthread_alloc.h>
# if (_STLP_OUTERMOST_HEADER_ID == 0x52)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
#endif /* _STLP_PTHREAD_ALLOC */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/queue
-57
View File
@@ -1,57 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_QUEUE
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x53
# include <stl/_prolog.h>
# define _STLP_QUEUE
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x53)
# ifndef _STLP_INTERNAL_QUEUE_H
# include <stl/_queue.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x53) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <queue>
# else
# include _STLP_NATIVE_HEADER(queue)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x53)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_QUEUE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/rlocks.h
-11
View File
@@ -1,11 +0,0 @@
#ifndef _STLP_misc_rlocks_h
# define _STLP_misc_rlocks_h
# if (__SUNPRO_CC >= 0x500 )
# include <../CCios/rlocks.h>
# elif defined (__SUNPRO_CC)
# include <../CC/rlocks.h>
# else
# error "This file is for SUN CC only. Please remove it if it causes any harm for other compilers."
# endif
#endif
reactos/include/c++/stlport/rope
-44
View File
@@ -1,44 +0,0 @@
/*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _STLP_ROPE
#define _STLP_ROPE
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x54
# include <stl/_prolog.h>
#endif
#ifdef _STLP_PRAGMA_ONCE
# pragma once
#endif
#if defined (_STLP_NO_EXTENSIONS)
/* Comment following if you want to use rope class even if you ask for
* no extension.
*/
# error The rope class is a STLport extension.
#endif
#include <stl/_rope.h>
#if (_STLP_OUTERMOST_HEADER_ID == 0x54)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_ROPE */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/set
-57
View File
@@ -1,57 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_SET
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x55
# include <stl/_prolog.h>
# define _STLP_SET
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x55)
# ifndef _STLP_INTERNAL_SET_H
# include <stl/_set.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x55) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <set>
# else
# include _STLP_NATIVE_HEADER(set)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x55)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_SET */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/setjmp.h
-52
View File
@@ -1,52 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_SETJMP_H
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x256
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x256) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
# define _STLP_SETJMP_H
#endif
#if defined(_STLP_WCE_EVC3)
struct _exception;
#endif
#if !defined (setjmp)
# define _STLP_NATIVE_SETJMP_H_INCLUDED
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <setjmp.h>
# else
# include _STLP_NATIVE_C_HEADER(setjmp.h)
# endif
#endif
#if !defined (_STLP_NATIVE_SETJMP_H_INCLUDED)
/* See errno.h file for a description of this problem. */
# error setjmp has been defined before inclusion of setjmp.h header.
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x256)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
#endif
#endif /* _STLP_SETJMP_H */
reactos/include/c++/stlport/signal.h
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x257
# include <stl/_cprolog.h>
#elif (_STLP_OUTERMOST_HEADER_ID == 0x257) && ! defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
#endif
/* evc3 and evc4 don't have signal.h */
#ifndef _STLP_WCE
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <signal.h>
# else
# include _STLP_NATIVE_C_HEADER(signal.h)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x257)
# if ! defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# undef _STLP_DONT_POP_HEADER_ID
#endif
reactos/include/c++/stlport/slist
-54
View File
@@ -1,54 +0,0 @@
/*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*/
#ifndef _STLP_SLIST
#define _STLP_SLIST
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x58
# include <stl/_prolog.h>
#endif
#ifdef _STLP_PRAGMA_ONCE
# pragma once
#endif
#if defined (_STLP_NO_EXTENSIONS)
/* Comment following if you want to use the slist constainer even if you ask for
* no extension.
*/
# error The slist class is an STLport extension.
#endif
#ifndef _STLP_INTERNAL_SLIST_H
# include <stl/_slist.h>
#endif
#if defined (_STLP_IMPORT_VENDOR_STD)
//This is not a Standard header, it might failed for most of
//the compilers so we comment it for the moment. Should be uncommented
//on a compiler basis.
//# include _STLP_NATIVE_HEADER(slist)
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x58)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_SLIST */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/sstream
-57
View File
@@ -1,57 +0,0 @@
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
// This header defines classes basic_stringbuf, basic_istringstream,
// basic_ostringstream, and basic_stringstream. These classes
// represent streamsbufs and streams whose sources or destinations are
// C++ strings.
#ifndef _STLP_SSTREAM
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x1059
# include <stl/_prolog.h>
# define _STLP_SSTREAM
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1059) && \
!(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
# include <stl/_ioserr.h>
# ifndef _STLP_INTERNAL_SSTREAM
# include <stl/_sstream.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x1059) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <sstream>
# else
# include _STLP_NATIVE_HEADER(sstream)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x1059)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_SSTREAM */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/stack
-57
View File
@@ -1,57 +0,0 @@
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_STACK
#ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x60
# include <stl/_prolog.h>
# define _STLP_STACK
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x60)
# ifndef _STLP_INTERNAL_STACK_H
# include <stl/_stack.h>
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID != 0x60) || defined (_STLP_IMPORT_VENDOR_STD)
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <stack>
# else
# include _STLP_NATIVE_HEADER(stack)
# endif
#endif
#if (_STLP_OUTERMOST_HEADER_ID == 0x60)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
#endif
#endif /* _STLP_STACK */
// Local Variables:
// mode:C++
// End:
reactos/include/c++/stlport/stdarg.h
-47
View File
@@ -1,47 +0,0 @@
/*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
/* Workaround for a "misbehaviour" when compiling resource scripts using
* eMbedded Visual C++. The standard .rc file includes windows header files,
* which in turn include stdarg.h, which results in warnings and errors
*/
#if !defined (RC_INVOKED)
# if !defined (_STLP_OUTERMOST_HEADER_ID)
# define _STLP_OUTERMOST_HEADER_ID 0x261
# include <stl/_cprolog.h>
# elif (_STLP_OUTERMOST_HEADER_ID == 0x261) && !defined (_STLP_DONT_POP_HEADER_ID)
# define _STLP_DONT_POP_HEADER_ID
# endif
# if defined(_STLP_WCE_EVC3)
struct _exception;
# endif
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <stdarg.h>
# else
# include _STLP_NATIVE_C_HEADER(stdarg.h)
# endif
# if (_STLP_OUTERMOST_HEADER_ID == 0x261)
# if !defined (_STLP_DONT_POP_HEADER_ID)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# else
# undef _STLP_DONT_POP_HEADER_ID
# endif
# endif
#endif /* RC_INVOKED */

Some files were not shown because too many files have changed in this diff Show More