1 {******************************************************************************} 2 { } 3 { Windows Base Types API interface Unit for Object Pascal } 4 { } 5 { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft } 6 { Corporation. All Rights Reserved. } 7 { } 8 { The original file is: basetsd.h, released August 2001. The original Pascal } 9 { code is: WinType.pas, released December 2000. The initial developer of the } 10 { Pascal code is Marcel van Brakel (brakelm att chello dott nl). } 11 { } 12 { Portions created by Marcel van Brakel are Copyright (C) 1999-2001 } 13 { Marcel van Brakel. All Rights Reserved. } 14 { } 15 { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) } 16 { } 17 { You may retrieve the latest version of this file at the Project JEDI } 18 { APILIB home page, located at http://jedi-apilib.sourceforge.net } 19 { } 20 { The contents of this file are used with permission, subject to the Mozilla } 21 { Public License Version 1.1 (the "License"); you may not use this file except } 22 { in compliance with the License. You may obtain a copy of the License at } 23 { http://www.mozilla.org/MPL/MPL-1.1.html } 24 { } 25 { Software distributed under the License is distributed on an "AS IS" basis, } 26 { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for } 27 { the specific language governing rights and limitations under the License. } 28 { } 29 { Alternatively, the contents of this file may be used under the terms of the } 30 { GNU Lesser General Public License (the "LGPL License"), in which case the } 31 { provisions of the LGPL License are applicable instead of those above. } 32 { If you wish to allow use of your version of this file only under the terms } 33 { of the LGPL License and not to allow others to use your version of this file } 34 { under the MPL, indicate your decision by deleting the provisions above and } 35 { replace them with the notice and other provisions required by the LGPL } 36 { License. If you do not delete the provisions above, a recipient may use } 37 { your version of this file under either the MPL or the LGPL License. } 38 { } 39 { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html } 40 { } 41 {******************************************************************************} 42 43 44 // $Id: JwaWinType.pas,v 1.20 2007/10/07 23:55:45 dezipaitor Exp $ 45 46 {$IFNDEF JWA_OMIT_SECTIONS} 47 unit JwaWinType; 48 {$I jediapilib.inc} 49 50 {$WEAKPACKAGEUNIT} 51 52 {$ENDIF JWA_OMIT_SECTIONS} 53 54 {$HPPEMIT ''} 55 {$HPPEMIT '#include "BaseTsd.h"'} 56 {$HPPEMIT '#include "BaseTyps.h"'} 57 {$HPPEMIT '#include "NtDef.h"'} 58 {$HPPEMIT '#include "WinDef.h"'} 59 {$HPPEMIT ''} 60 {$HPPEMIT 'typedef LPVOID *LPLPVOID'} 61 {$HPPEMIT 'typedef GUID TGUID'} 62 {$HPPEMIT 'typedef GUID *LPGUID'} 63 {$HPPEMIT 'typedef GUID CLSID'} 64 {$HPPEMIT 'typedef HMODULE *PHMODULE'} 65 {$HPPEMIT ''} 66 67 {$IFNDEF JWA_OMIT_SECTIONS} 68 69 interface 70 71 uses 72 {$IFDEF USE_DELPHI_TYPES} 73 Windows, 74 {$ENDIF USE_DELPHI_TYPES} 75 SysUtils; // TODO 76 77 {$ENDIF JWA_OMIT_SECTIONS} 78 79 {$IFNDEF JWA_IMPLEMENTATIONSECTION} 80 81 type 82 EJwaError = class(Exception); 83 EJwaLoadLibraryError = class(EJwaError); 84 EJwaGetProcAddressError = class(EJwaError); 85 86 procedure GetProcedureAddress(var P: Pointer; const ModuleName, ProcName: string); 87 88 type 89 // (rom) moved from JwaRpc.pas 90 RPC_STATUS = Longint; 91 {$EXTERNALSYM RPC_STATUS} 92 93 // ntdef.h 94 95 type 96 //typedef double DOUBLE; 97 98 PQuad = ^TQuad; 99 _QUAD = record // QUAD is for those times we want 100 DoNotUseThisField: Double; // an 8 byte aligned 8 byte long structure 101 end; // which is NOT really a floating point 102 {$EXTERNALSYM _QUAD} // number. Use DOUBLE if you want an FP number. 103 QUAD = _QUAD; 104 {$EXTERNALSYM QUAD} 105 TQuad = _QUAD; 106 107 // 108 // Unsigned Basics 109 // 110 111 UCHAR = {$IFDEF USE_DELPHI_TYPES} Windows.UCHAR {$ELSE} Byte {$ENDIF}; 112 {$EXTERNALSYM UCHAR} 113 USHORT = Word; 114 {$EXTERNALSYM USHORT} 115 ULONG = {$IFDEF USE_DELPHI_TYPES} Windows.ULONG {$ELSE} Cardinal {$ENDIF}; 116 {$EXTERNALSYM ULONG} 117 UQUAD = QUAD; 118 {$EXTERNALSYM UQUAD} 119 120 // 121 // __int64 is only supported by 2.0 and later midl. 122 // __midl is set by the 2.0 midl and not by 1.0 midl. 123 // 124 125 type 126 LONGLONG = {$IFDEF USE_DELPHI_TYPES} Windows.LONGLONG {$ELSE} Int64 {$ENDIF}; 127 {$EXTERNALSYM LONGLONG} 128 ULONGLONG = Int64; 129 {$EXTERNALSYM ULONGLONG} 130 131 const 132 MAXLONGLONG = $7fffffffffffffff; 133 {$EXTERNALSYM MAXLONGLONG} 134 135 type 136 PLONGLONG = ^LONGLONG; 137 {$EXTERNALSYM PLONGLONG} 138 PULONGLONG = ^ULONGLONG; 139 {$EXTERNALSYM PULONGLONG} 140 141 BOOL = {$IFDEF USE_DELPHI_TYPES} Windows.BOOL {$ELSE} LongBool {$ENDIF}; 142 {$EXTERNALSYM BOOL} 143 144 DWORD = {$IFDEF USE_DELPHI_TYPES} Windows.DWORD {$ELSE} Longword {$ENDIF}; 145 {$EXTERNALSYM DWORD} 146 147 const 148 ANYSIZE_ARRAY = 1; 149 {$EXTERNALSYM ANYSIZE_ARRAY} 150 151 MAX_NATURAL_ALIGNMENT = SizeOf(ULONG); 152 {$EXTERNALSYM MAX_NATURAL_ALIGNMENT} 153 154 // 155 // Void 156 // 157 158 type 159 PVOID = Pointer; 160 {$EXTERNALSYM PVOID} 161 PPVOID = ^PVOID; 162 {$EXTERNALSYM PPVOID} 163 PVOID64 = Pointer; 164 {$EXTERNALSYM PVOID64} 165 166 // 167 // Basics 168 // 169 170 SHORT = {$IFDEF USE_DELPHI_TYPES} Windows.SHORT {$ELSE} Smallint {$ENDIF}; 171 {$EXTERNALSYM SHORT} 172 LONG = Longint; 173 {$EXTERNALSYM LONG} 174 175 // 176 // UNICODE (Wide Character) types 177 // 178 179 WCHAR = {$IFDEF USE_DELPHI_TYPES} Windows.WCHAR {$ELSE} WideChar {$ENDIF}; 180 {$EXTERNALSYM WCHAR} 181 182 PWCHAR = {$IFDEF USE_DELPHI_TYPES} Windows.PWChar {$ELSE} PWideChar {$ENDIF}; 183 {$EXTERNALSYM PWCHAR} 184 LPWCH = ^WCHAR; 185 {$EXTERNALSYM LPWCH} 186 PWCH = ^WCHAR; 187 {$EXTERNALSYM PWCH} 188 LPCWCH = ^WCHAR; 189 {$EXTERNALSYM LPCWCH} 190 PCWCH = ^WCHAR; 191 {$EXTERNALSYM PCWCH} 192 NWPSTR = ^WCHAR; 193 {$EXTERNALSYM NWPSTR} 194 LPWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} PWideChar {$ENDIF}; 195 {$EXTERNALSYM LPWSTR} 196 LPCWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPCWSTR {$ELSE} PWideChar {$ENDIF}; 197 {$EXTERNALSYM LPCWSTR} 198 PWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} PWideChar {$ENDIF}; 199 {$EXTERNALSYM PWSTR} 200 LPUWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} PWideChar {$ENDIF}; 201 {$EXTERNALSYM LPUWSTR} 202 PUWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} PWideChar {$ENDIF}; 203 {$EXTERNALSYM PUWSTR} 204 LPCUWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} PWideChar {$ENDIF}; 205 {$EXTERNALSYM LPCUWSTR} 206 PCUWSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} PWideChar {$ENDIF}; 207 {$EXTERNALSYM PCUWSTR} 208 209 // 210 // ANSI (Multi-byte Character) types 211 // 212 213 LPCH = ^Char; 214 {$EXTERNALSYM LPCH} 215 PCH = ^Char; 216 {$EXTERNALSYM PCH} 217 218 LPCCH = ^Char; 219 {$EXTERNALSYM LPCCH} 220 PCCH = ^Char; 221 {$EXTERNALSYM PCCH} 222 NPSTR = ^Char; 223 {$EXTERNALSYM NPSTR} 224 LPSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPSTR {$ELSE} PAnsiChar {$ENDIF}; 225 {$EXTERNALSYM LPSTR} 226 PSTR = PChar; 227 {$EXTERNALSYM PSTR} 228 LPCSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPCSTR {$ELSE} PAnsiChar {$ENDIF}; 229 {$EXTERNALSYM LPCSTR} 230 PCSTR = PChar; 231 {$EXTERNALSYM PCSTR} 232 233 // (rom) moved down to have LPSTR etc always declared 234 type 235 LPLPSTR = ^LPSTR; 236 {$NODEFINE LPLPSTR} 237 LPLPCSTR = ^LPCSTR; 238 {$NODEFINE LPLPCSTR} 239 LPLPCWSTR = ^LPCWSTR; 240 {$NODEFINE LPLPCWSTR} 241 LPLPWSTR = ^LPWSTR; 242 {$NODEFINE LPLPWSTR} 243 244 PLPWSTR = ^LPWSTR; 245 {$EXTERNALSYM PLPWSTR} 246 PLPSTR = ^LPSTR; 247 {$EXTERNALSYM PLPSTR} 248 PPWCHAR = ^PWCHAR; 249 250 PPTSTR = ^PTSTR; 251 PPChar = ^PChar; 252 PPWideChar = ^PWideChar; 253 PPointer = ^Pointer; 254 255 GUID = TGUID; 256 {$NODEFINE GUID} 257 LPGUID = ^GUID; 258 {$NODEFINE LPGUID} 259 CLSID = TGUID; 260 {$NODEFINE CLSID} 261 262 // 263 // Neutral ANSI/UNICODE types and macros 264 // 265 266 {$IFDEF UNICODE} 267 268 TCHAR = WCHAR; 269 {$EXTERNALSYM TCHAR} 270 PTCHAR = PWideChar; 271 {$EXTERNALSYM PTCHAR} 272 TUCHAR = WCHAR; 273 {$EXTERNALSYM TUCHAR} 274 PTUCHAR = ^TUCHAR; 275 {$EXTERNALSYM PTUCHAR} 276 277 LPCTCH = LPWSTR; 278 LPTCH = LPWSTR; 279 {$EXTERNALSYM LPTCH} 280 PTCH = LPWSTR; 281 {$EXTERNALSYM PTCH} 282 PTSTR = LPWSTR; 283 {$EXTERNALSYM PTSTR} 284 LPTSTR = {$IFDEF USE_DELPHI_TYPES} Windows.LPWSTR {$ELSE} LPWSTR {$ENDIF}; 285 {$EXTERNALSYM LPTSTR} 286 PCTSTR = LPTSTR; 287 {$EXTERNALSYM PCTSTR} 288 LPCTSTR = LPTSTR; 289 {$EXTERNALSYM LPCTSTR} 290 291 PCUTSTR = PTUCHAR; 292 {$EXTERNALSYM PCUTSTR} 293 LPCUTSTR = PTUCHAR; 294 {$EXTERNALSYM LPCUTSTR} 295 PUTSTR = PTUCHAR; 296 {$EXTERNALSYM PUTSTR} 297 LPUTSTR = PTUCHAR; 298 {$EXTERNALSYM LPUTSTR} 299 300 __TEXT = WideString; 301 {$EXTERNALSYM __TEXT} 302 303 {$ELSE} 304 305 TCHAR = Char; 306 {$EXTERNALSYM TCHAR} 307 PTCHAR = PChar; 308 {$EXTERNALSYM PTCHAR} 309 TUCHAR = Byte; 310 {$EXTERNALSYM TUCHAR} 311 PTUCHAR = ^TUCHAR; 312 {$EXTERNALSYM PTUCHAR} 313 314 LPCTCH = LPSTR; 315 LPTCH = LPSTR; 316 {$EXTERNALSYM LPTCH} 317 PTCH = LPSTR; 318 {$EXTERNALSYM PTCH} 319 PTSTR = LPSTR; 320 {$EXTERNALSYM PTSTR} 321 LPTSTR = LPSTR; 322 {$EXTERNALSYM LPTSTR} 323 PCTSTR = LPCSTR; 324 {$EXTERNALSYM PCTSTR} 325 LPCTSTR = LPCSTR; 326 {$EXTERNALSYM LPCTSTR} 327 328 PCUTSTR = PTUCHAR; 329 {$EXTERNALSYM PCUTSTR} 330 LPCUTSTR = PTUCHAR; 331 {$EXTERNALSYM LPCUTSTR} 332 PUTSTR = PTUCHAR; 333 {$EXTERNALSYM PUTSTR} 334 LPUTSTR = PTUCHAR; 335 {$EXTERNALSYM LPUTSTR} 336 337 __TEXT = AnsiString; 338 {$EXTERNALSYM __TEXT} 339 340 {$ENDIF UNICODE} 341 342 TEXT = __TEXT; 343 {$EXTERNALSYM TEXT} 344 345 // 346 // Pointer to Basics 347 // 348 349 PSHORT = ^SHORT; 350 {$EXTERNALSYM PSHORT} 351 PLONG = ^LONG; 352 {$EXTERNALSYM PLONG} 353 354 // 355 // Pointer to Unsigned Basics 356 // 357 358 PUCHAR = {$IFDEF USE_DELPHI_TYPES} Windows.PUCHAR {$ELSE} ^Byte {$ENDIF}; 359 {$EXTERNALSYM PUCHAR} 360 PUSHORT = ^USHORT; 361 {$EXTERNALSYM PUSHORT} 362 PULONG = {$IFDEF USE_DELPHI_TYPES} Windows.PULONG {$ELSE} ^ULONG {$ENDIF}; 363 {$EXTERNALSYM PULONG} 364 PUQUAD = ^UQUAD; 365 {$EXTERNALSYM PUQUAD} 366 367 // 368 // Signed characters 369 // 370 371 SCHAR = Shortint; 372 {$EXTERNALSYM SCHAR} 373 PSCHAR = ^SCHAR; 374 {$EXTERNALSYM PSCHAR} 375 376 // 377 // Handle to an Object 378 // 379 380 HANDLE = {$IFDEF USE_DELPHI_TYPES} Windows.THandle {$ELSE} Longword {$ENDIF}; 381 {$EXTERNALSYM HANDLE} 382 PHANDLE = {$IFDEF USE_DELPHI_TYPES} Windows.PHandle {$ELSE} ^HANDLE {$ENDIF}; 383 {$EXTERNALSYM PHANDLE} 384 THandle = {$IFDEF USE_DELPHI_TYPES} Windows.THandle {$ELSE} HANDLE {$ENDIF}; 385 386 // 387 // Flag (bit) fields 388 // 389 390 FCHAR = UCHAR; 391 {$EXTERNALSYM FCHAR} 392 FSHORT = USHORT; 393 {$EXTERNALSYM FSHORT} 394 FLONG = ULONG; 395 {$EXTERNALSYM FLONG} 396 397 // Component Object Model defines, and macros 398 399 HRESULT = System.HRESULT; // LONG; 400 {$EXTERNALSYM HRESULT} 401 402 // 403 // Low order two bits of a handle are ignored by the system and available 404 // for use by application code as tag bits. The remaining bits are opaque 405 // and used to store a serial number and table index. 406 // 407 408 const 409 OBJ_HANDLE_TAGBITS = $00000003; 410 {$EXTERNALSYM OBJ_HANDLE_TAGBITS} 411 412 // 413 // Cardinal Data Types [0 - 2**N-2) 414 // 415 416 type 417 CCHAR = Char; 418 {$EXTERNALSYM CCHAR} 419 CSHORT = Shortint; 420 {$EXTERNALSYM CSHORT} 421 CLONG = ULONG; 422 {$EXTERNALSYM CLONG} 423 424 PCCHAR = ^CCHAR; 425 {$EXTERNALSYM PCCHAR} 426 PCSHORT = ^CSHORT; 427 {$EXTERNALSYM PCSHORT} 428 PCLONG = ^CLONG; 429 {$EXTERNALSYM PCLONG} 430 431 // 432 // NLS basics (Locale and Language Ids) 433 // 434 435 LCID = {$IFDEF USE_DELPHI_TYPES} Windows.LCID {$ELSE} DWORD {$ENDIF}; 436 {$EXTERNALSYM LCID} 437 PLCID = ^LCID; 438 {$EXTERNALSYM PLCID} 439 LANGID = {$IFDEF USE_DELPHI_TYPES} Windows.LANGID {$ELSE} Word {$ENDIF}; 440 {$EXTERNALSYM LANGID} 441 PLANGID = ^LANGID; // TODO Not in original header (used in MSI) 442 443 // 444 // Logical Data Type - These are 32-bit logical values. 445 // 446 447 LOGICAL = ULONG; 448 {$EXTERNALSYM LOGICAL} 449 PLOGICAL = ^ULONG; 450 {$EXTERNALSYM PLOGICAL} 451 452 // 453 // NTSTATUS 454 // 455 456 NTSTATUS = LONG; 457 {$EXTERNALSYM NTSTATUS} 458 PNTSTATUS = ^NTSTATUS; 459 {$EXTERNALSYM PNTSTATUS} 460 TNTStatus = NTSTATUS; 461 462 // 463 // Status values are 32 bit values layed out as follows: 464 // 465 // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 466 // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 467 // +---+-+-------------------------+-------------------------------+ 468 // |Sev|C| Facility | Code | 469 // +---+-+-------------------------+-------------------------------+ 470 // 471 // where 472 // 473 // Sev - is the severity code 474 // 475 // 00 - Success 476 // 01 - Informational 477 // 10 - Warning 478 // 11 - Error 479 // 480 // C - is the Customer code flag 481 // 482 // Facility - is the facility code 483 // 484 // Code - is the facility's status code 485 // 486 487 // 488 // Generic test for success on any status value (non-negative numbers 489 // indicate success). 490 // 491 492 function NT_SUCCESS(Status: NTSTATUS): BOOL; 493 {$EXTERNALSYM NT_SUCCESS} 494 495 // 496 // Generic test for information on any status value. 497 // 498 499 function NT_INFORMATION(Status: NTSTATUS): BOOL; 500 {$EXTERNALSYM NT_INFORMATION} 501 502 // 503 // Generic test for warning on any status value. 504 // 505 506 function NT_WARNING(Status: NTSTATUS): BOOL; 507 {$EXTERNALSYM NT_WARNING} 508 509 // 510 // Generic test for error on any status value. 511 // 512 513 function NT_ERROR(Status: NTSTATUS): BOOL; 514 {$EXTERNALSYM NT_ERROR} 515 516 const 517 APPLICATION_ERROR_MASK = $20000000; 518 {$EXTERNALSYM APPLICATION_ERROR_MASK} 519 ERROR_SEVERITY_SUCCESS = $00000000; 520 {$EXTERNALSYM ERROR_SEVERITY_SUCCESS} 521 ERROR_SEVERITY_INFORMATIONAL = $40000000; 522 {$EXTERNALSYM ERROR_SEVERITY_INFORMATIONAL} 523 ERROR_SEVERITY_WARNING = DWORD($80000000); 524 {$EXTERNALSYM ERROR_SEVERITY_WARNING} 525 ERROR_SEVERITY_ERROR = DWORD($C0000000); 526 {$EXTERNALSYM ERROR_SEVERITY_ERROR} 527 528 // 529 // Large (64-bit) integer types and operations 530 // 531 532 type 533 LPLARGE_INTEGER = ^LARGE_INTEGER; 534 {$EXTERNALSYM LPLARGE_INTEGER} 535 536 {$IFDEF USE_DELPHI_TYPES} 537 _LARGE_INTEGER = Windows._LARGE_INTEGER; 538 LARGE_INTEGER = Windows.LARGE_INTEGER; 539 TLargeInteger = Windows.TLargeInteger; 540 {$ELSE} 541 _LARGE_INTEGER = record 542 case Integer of 543 0: ( 544 LowPart: DWORD; 545 HighPart: LONG); 546 1: ( 547 QuadPart: LONGLONG); 548 end; 549 {$EXTERNALSYM _LARGE_INTEGER} 550 LARGE_INTEGER = _LARGE_INTEGER; 551 {$EXTERNALSYM LARGE_INTEGER} 552 TLargeInteger = LARGE_INTEGER; 553 {$ENDIF USE_DELPHI_TYPES} 554 555 PLARGE_INTEGER = ^LARGE_INTEGER; 556 {$EXTERNALSYM PLARGE_INTEGER} 557 PLargeInteger = LPLARGE_INTEGER; 558 559 LPULARGE_INTEGER = ^ULARGE_INTEGER; 560 {$EXTERNALSYM LPULARGE_INTEGER} 561 562 {$IFDEF USE_DELPHI_TYPES} 563 ULARGE_INTEGER = Windows.ULARGE_INTEGER; 564 TULargeInteger = Windows.TULargeInteger; 565 PULargeInteger = Windows.PULargeInteger; 566 {$ELSE} 567 ULARGE_INTEGER = record 568 case Integer of 569 0: ( 570 LowPart: DWORD; 571 HighPart: DWORD); 572 1: ( 573 QuadPart: LONGLONG); 574 end; 575 {$EXTERNALSYM ULARGE_INTEGER} 576 TULargeInteger = ULARGE_INTEGER; 577 PULargeInteger = LPULARGE_INTEGER; 578 {$ENDIF USE_DELPHI_TYPES} 579 580 PULARGE_INTEGER = ^ULARGE_INTEGER; 581 {$EXTERNALSYM PULARGE_INTEGER} 582 583 TIME = LARGE_INTEGER; 584 {$EXTERNALSYM TIME} 585 _TIME = _LARGE_INTEGER; 586 {$EXTERNALSYM _TIME} 587 PTIME = PLARGE_INTEGER; 588 {$EXTERNALSYM PTIME} 589 590 // 591 // _M_IX86 included so that EM CONTEXT structure compiles with 592 // x86 programs. *** TBD should this be for all architectures? 593 // 594 595 // 596 // 16 byte aligned type for 128 bit floats 597 // 598 599 // 600 // For we define a 128 bit structure and use __declspec(align(16)) pragma to 601 // align to 128 bits. 602 // 603 604 type 605 PFloat128 = ^TFloat128; 606 _FLOAT128 = record 607 LowPart: Int64; 608 HighPart: Int64; 609 end; 610 {$EXTERNALSYM _FLOAT128} 611 FLOAT128 = _FLOAT128; 612 {$EXTERNALSYM FLOAT128} 613 TFloat128 = FLOAT128; 614 615 // Update Sequence Number 616 617 USN = LONGLONG; 618 {$EXTERNALSYM USN} 619 620 // 621 // Locally Unique Identifier 622 // 623 624 type 625 PLuid = ^LUID; 626 _LUID = record 627 LowPart: DWORD; 628 HighPart: LONG; 629 end; 630 {$EXTERNALSYM _LUID} 631 LUID = _LUID; 632 {$EXTERNALSYM LUID} 633 TLuid = LUID; 634 635 DWORDLONG = ULONGLONG; 636 {$EXTERNALSYM DWORDLONG} 637 PDWORDLONG = ^DWORDLONG; 638 {$EXTERNALSYM PDWORDLONG} 639 640 // 641 // Physical address. 642 // 643 644 PHYSICAL_ADDRESS = LARGE_INTEGER; 645 {$EXTERNALSYM PHYSICAL_ADDRESS} 646 PPHYSICAL_ADDRESS = ^LARGE_INTEGER; 647 {$EXTERNALSYM PPHYSICAL_ADDRESS} 648 649 // 650 // Define operations to logically shift an int64 by 0..31 bits and to multiply 651 // 32-bits by 32-bits to form a 64-bit product. 652 // 653 654 // 655 // The x86 C compiler understands inline assembler. Therefore, inline functions 656 // that employ inline assembler are used for shifts of 0..31. The multiplies 657 // rely on the compiler recognizing the cast of the multiplicand to int64 to 658 // generate the optimal code inline. 659 // 660 661 function Int32x32To64(a, b: LONG): LONGLONG; 662 {$EXTERNALSYM Int32x32To64} 663 function UInt32x32To64(a, b: DWORD): ULONGLONG; 664 {$EXTERNALSYM UInt32x32To64} 665 666 function Int64ShllMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG; 667 668 {$EXTERNALSYM Int64ShllMod32} 669 function Int64ShraMod32(Value: LONGLONG; ShiftCount: DWORD): LONGLONG; 670 {$EXTERNALSYM Int64ShraMod32} 671 function Int64ShrlMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG; 672 {$EXTERNALSYM Int64ShrlMod32} 673 674 // 675 // Event type 676 // 677 678 type 679 _EVENT_TYPE = (NotificationEvent, SynchronizationEvent); 680 {$EXTERNALSYM _EVENT_TYPE} 681 EVENT_TYPE = _EVENT_TYPE; 682 {$EXTERNALSYM EVENT_TYPE} 683 TEventType = _EVENT_TYPE; 684 685 // 686 // Timer type 687 // 688 689 _TIMER_TYPE = (NotificationTimer, SynchronizationTimer); 690 {$EXTERNALSYM _TIMER_TYPE} 691 TIMER_TYPE = _TIMER_TYPE; 692 {$EXTERNALSYM TIMER_TYPE} 693 694 // 695 // Wait type 696 // 697 698 _WAIT_TYPE = (WaitAll, WaitAny); 699 {$EXTERNALSYM _WAIT_TYPE} 700 WAIT_TYPE = _WAIT_TYPE; 701 {$EXTERNALSYM WAIT_TYPE} 702 703 // 704 // Pointer to an Asciiz string 705 // 706 707 PSZ = ^CHAR; 708 {$EXTERNALSYM PSZ} 709 PCSZ = ^CHAR; 710 {$EXTERNALSYM PCSZ} 711 712 // 713 // Counted String 714 // 715 716 PString = ^TString; 717 _STRING = record 718 Length: USHORT; 719 MaximumLength: USHORT; 720 Buffer: PCHAR; 721 end; 722 {$EXTERNALSYM _STRING} 723 TString = _STRING; 724 725 ANSI_STRING = _STRING; 726 {$EXTERNALSYM ANSI_STRING} 727 PANSI_STRING = PSTRING; 728 {$EXTERNALSYM PANSI_STRING} 729 730 OEM_STRING = _STRING; 731 {$EXTERNALSYM OEM_STRING} 732 POEM_STRING = PSTRING; 733 {$EXTERNALSYM POEM_STRING} 734 735 // 736 // CONSTCounted String 737 // 738 739 PCString = ^CSTRING; 740 _CSTRING = record 741 Length: USHORT; 742 MaximumLength: USHORT; 743 Buffer: PCHAR; 744 end; 745 {$EXTERNALSYM _CSTRING} 746 CSTRING = _CSTRING; 747 {$EXTERNALSYM CSTRING} 748 TCString = CSTRING; 749 750 const 751 ANSI_NULL = CHAR(0); 752 {$EXTERNALSYM ANSI_NULL} 753 UNICODE_NULL = WCHAR(0); 754 {$EXTERNALSYM UNICODE_NULL} 755 UNICODE_STRING_MAX_BYTES = WORD(65534); 756 {$EXTERNALSYM UNICODE_STRING_MAX_BYTES} 757 UNICODE_STRING_MAX_CHARS = 32767; 758 {$EXTERNALSYM UNICODE_STRING_MAX_CHARS} 759 760 type 761 CANSI_STRING = _STRING; 762 {$EXTERNALSYM CANSI_STRING} 763 PCANSI_STRING = PSTRING; 764 {$EXTERNALSYM PCANSI_STRING} 765 766 // 767 // Unicode strings are counted 16-bit character strings. If they are 768 // NULL terminated, Length does not include trailing NULL. 769 // 770 771 type 772 PUNICODE_STRING = ^UNICODE_STRING; 773 {$EXTERNALSYM PUNICODE_STRING} 774 _UNICODE_STRING = record 775 Length: USHORT; 776 MaximumLength: USHORT; 777 Buffer: PWSTR; 778 end; 779 {$EXTERNALSYM _UNICODE_STRING} 780 UNICODE_STRING = _UNICODE_STRING; 781 {$EXTERNALSYM UNICODE_STRING} 782 PCUNICODE_STRING = ^UNICODE_STRING; 783 {$EXTERNALSYM PCUNICODE_STRING} 784 TUnicodeString = UNICODE_STRING; 785 PUnicodeString = PUNICODE_STRING; 786 787 // 788 // Boolean 789 // 790 791 type 792 //typedef UCHAR BOOLEAN; 793 PBOOLEAN = ^ByteBool; 794 {$EXTERNALSYM PBOOLEAN} 795 796 // 797 // Doubly linked list structure. Can be used as either a list head, or 798 // as link words. 799 // 800 801 type 802 PLIST_ENTRY = ^LIST_ENTRY; 803 {$EXTERNALSYM PLIST_ENTRY} 804 805 {$IFDEF USE_DELPHI_TYPES} 806 _LIST_ENTRY = Windows._LIST_ENTRY; 807 LIST_ENTRY = Windows.LIST_ENTRY; 808 TListEntry = Windows.TListEntry; 809 PListEntry = Windows.PListEntry; 810 {$ELSE} 811 _LIST_ENTRY = record 812 Flink: PLIST_ENTRY; 813 Blink: PLIST_ENTRY; 814 end; 815 {$EXTERNALSYM _LIST_ENTRY} 816 LIST_ENTRY = _LIST_ENTRY; 817 {$EXTERNALSYM LIST_ENTRY} 818 TListEntry = LIST_ENTRY; 819 PListEntry = PLIST_ENTRY; 820 {$ENDIF USE_DELPHI_TYPES} 821 822 PRLIST_ENTRY = ^LIST_ENTRY; 823 {$EXTERNALSYM PLIST_ENTRY} 824 825 // 826 // Singly linked list structure. Can be used as either a list head, or 827 // as link words. 828 // 829 830 PSINGLE_LIST_ENTRY = ^SINGLE_LIST_ENTRY; 831 {$EXTERNALSYM PSINGLE_LIST_ENTRY} 832 _SINGLE_LIST_ENTRY = record 833 Next: PSINGLE_LIST_ENTRY; 834 end; 835 {$EXTERNALSYM _SINGLE_LIST_ENTRY} 836 SINGLE_LIST_ENTRY = _SINGLE_LIST_ENTRY; 837 {$EXTERNALSYM SINGLE_LIST_ENTRY} 838 TSingleListEntry = SINGLE_LIST_ENTRY; 839 PSingleListEntry = PSINGLE_LIST_ENTRY; 840 841 // 842 // These are needed for portable debugger support. 843 // 844 845 PLIST_ENTRY32 = ^LIST_ENTRY32; 846 {$EXTERNALSYM PLIST_ENTRY32} 847 {$EXTERNALSYM PLIST_ENTRY32} 848 LIST_ENTRY32 = record 849 Flink: DWORD; 850 Blink: DWORD; 851 end; 852 {$EXTERNALSYM LIST_ENTRY32} 853 TListEntry32 = LIST_ENTRY32; 854 PListEntry32 = PLIST_ENTRY32; 855 856 PLIST_ENTRY64 = ^LIST_ENTRY64; 857 {$EXTERNALSYM PLIST_ENTRY64} 858 LIST_ENTRY64 = record 859 Flink: ULONGLONG; 860 Blink: ULONGLONG; 861 end; 862 {$EXTERNALSYM LIST_ENTRY64} 863 TListEntry64 = LIST_ENTRY64; 864 PListEntry64 = PLIST_ENTRY64; 865 866 procedure ListEntry32To64(l32: PLIST_ENTRY32; l64: PLIST_ENTRY64); 867 {$EXTERNALSYM ListEntry32To64} 868 869 procedure ListEntry64To32(l64: PLIST_ENTRY64; l32: PLIST_ENTRY32); 870 {$EXTERNALSYM ListEntry64To32} 871 872 // 873 // These macros are used to walk lists on a target system 874 // 875 876 { 877 #define CONTAINING_RECORD32(address, type, field) ( \ 878 (ULONG_PTR)(address) - \ 879 (ULONG_PTR)(&((type *)0)->field)) 880 881 #define CONTAINING_RECORD64(address, type, field) ( \ 882 (ULONGLONG)(address) - \ 883 (ULONGLONG)(&((type *)0)->field)) 884 } 885 886 type 887 PString32 = ^STRING32; 888 _STRING32 = record 889 Length: USHORT; 890 MaximumLength: USHORT; 891 Buffer: ULONG; 892 end; 893 {$EXTERNALSYM _STRING32} 894 STRING32 = _STRING32; 895 {$EXTERNALSYM STRING32} 896 TString32 = STRING32; 897 898 UNICODE_STRING32 = STRING32; 899 {$EXTERNALSYM UNICODE_STRING32} 900 PUNICODE_STRING32 = ^UNICODE_STRING32; 901 {$EXTERNALSYM PUNICODE_STRING32} 902 903 ANSI_STRING32 = STRING32; 904 {$EXTERNALSYM ANSI_STRING32} 905 PANSI_STRING32 = ^ANSI_STRING32; 906 {$EXTERNALSYM PANSI_STRING32} 907 908 PString64 = ^STRING64; 909 _STRING64 = record 910 Length: USHORT; 911 MaximumLength: USHORT; 912 Buffer: ULONGLONG; 913 end; 914 {$EXTERNALSYM _STRING64} 915 STRING64 = _STRING64; 916 {$EXTERNALSYM STRING64} 917 TString64 = STRING64; 918 919 UNICODE_STRING64 = STRING64; 920 {$EXTERNALSYM UNICODE_STRING64} 921 PUNICODE_STRING64 = ^UNICODE_STRING64; 922 {$EXTERNALSYM PUNICODE_STRING64} 923 924 ANSI_STRING64 = STRING64; 925 {$EXTERNALSYM ANSI_STRING64} 926 PANSI_STRING64 = ^ANSI_STRING64; 927 {$EXTERNALSYM PANSI_STRING64} 928 929 // 930 // Valid values for the Attributes field 931 // 932 933 const 934 OBJ_INHERIT = $00000002; 935 {$EXTERNALSYM OBJ_INHERIT} 936 OBJ_PERMANENT = $00000010; 937 {$EXTERNALSYM OBJ_PERMANENT} 938 OBJ_EXCLUSIVE = $00000020; 939 {$EXTERNALSYM OBJ_EXCLUSIVE} 940 OBJ_CASE_INSENSITIVE = $00000040; 941 {$EXTERNALSYM OBJ_CASE_INSENSITIVE} 942 OBJ_OPENIF = $00000080; 943 {$EXTERNALSYM OBJ_OPENIF} 944 OBJ_OPENLINK = $00000100; 945 {$EXTERNALSYM OBJ_OPENLINK} 946 OBJ_KERNEL_HANDLE = $00000200; 947 {$EXTERNALSYM OBJ_KERNEL_HANDLE} 948 OBJ_VALID_ATTRIBUTES = $000003F2; 949 {$EXTERNALSYM OBJ_VALID_ATTRIBUTES} 950 951 // 952 // Object Attributes structure 953 // 954 955 type 956 POBJECT_ATTRIBUTES = ^OBJECT_ATTRIBUTES; 957 {$EXTERNALSYM POBJECT_ATTRIBUTES} 958 _OBJECT_ATTRIBUTES = record 959 Length: ULONG; 960 RootDirectory: HANDLE; 961 ObjectName: PUNICODE_STRING; 962 Attributes: ULONG; 963 SecurityDescriptor: PVOID; // Points to type SECURITY_DESCRIPTOR 964 SecurityQualityOfService: PVOID; // Points to type SECURITY_QUALITY_OF_SERVICE 965 end; 966 {$EXTERNALSYM _OBJECT_ATTRIBUTES} 967 OBJECT_ATTRIBUTES = _OBJECT_ATTRIBUTES; 968 {$EXTERNALSYM OBJECT_ATTRIBUTES} 969 TObjectAttributes = OBJECT_ATTRIBUTES; 970 PObjectAttributes = POBJECT_ATTRIBUTES; 971 972 procedure InitializeObjectAttributes(p: POBJECT_ATTRIBUTES; n: PUNICODE_STRING; 973 a: ULONG; r: HANDLE; s: PVOID{PSECURITY_DESCRIPTOR}); 974 {$EXTERNALSYM InitializeObjectAttributes} 975 976 // 977 // Constants 978 // 979 980 const 981 982 //#define FALSE 0 983 //#define TRUE 1 984 985 NULL = 0; 986 {$EXTERNALSYM NULL} 987 NULL64 = 0; 988 {$EXTERNALSYM NULL64} 989 990 //#include <guiddef.h> 991 992 type 993 PObjectId = ^OBJECTID; 994 _OBJECTID = record // size is 20 995 Lineage: GUID; 996 Uniquifier: ULONG; 997 end; 998 {$EXTERNALSYM _OBJECTID} 999 OBJECTID = _OBJECTID; 1000 {$EXTERNALSYM OBJECTID} 1001 TObjectId = OBJECTID; 1002 1003 const 1004 MINCHAR = $80; 1005 {$EXTERNALSYM MINCHAR} 1006 MAXCHAR = $7f; 1007 {$EXTERNALSYM MAXCHAR} 1008 MINSHORT = $8000; 1009 {$EXTERNALSYM MINSHORT} 1010 MAXSHORT = $7fff; 1011 {$EXTERNALSYM MAXSHORT} 1012 MINLONG = DWORD($80000000); 1013 {$EXTERNALSYM MINLONG} 1014 MAXLONG = $7fffffff; 1015 {$EXTERNALSYM MAXLONG} 1016 MAXUCHAR = $ff; 1017 {$EXTERNALSYM MAXUCHAR} 1018 MAXUSHORT = $ffff; 1019 {$EXTERNALSYM MAXUSHORT} 1020 MAXULONG = DWORD($ffffffff); 1021 {$EXTERNALSYM MAXULONG} 1022 1023 // 1024 // Useful Helper Macros 1025 // 1026 1027 // 1028 // Determine if an argument is present by testing the value of the pointer 1029 // to the argument value. 1030 // 1031 1032 function ARGUMENT_PRESENT(ArgumentPointer: Pointer): BOOL; 1033 {$EXTERNALSYM ARGUMENT_PRESENT} 1034 1035 // 1036 // Exception handler routine definition. 1037 // 1038 1039 // struct _CONTEXT; 1040 // struct _EXCEPTION_RECORD; 1041 1042 //type 1043 // PEXCEPTION_ROUTINE = function(ExceptionRecord: LP_EXCEPTION_RECORD; 1044 // EstablisherFrame: PVOID; ContextRecord: LPCONTEXT; 1045 // DispatcherContext: PVOID): EXCEPTION_DISPOSITION; stdcall; 1046 // {$EXTERNALSYM PEXCEPTION_ROUTINE} 1047 1048 // 1049 // Interrupt Request Level (IRQL) 1050 // 1051 1052 type 1053 KIRQL = UCHAR; 1054 {$EXTERNALSYM KIRQL} 1055 PKIRQL = ^KIRQL; 1056 {$EXTERNALSYM PKIRQL} 1057 1058 // 1059 // Product types 1060 // 1061 1062 _NT_PRODUCT_TYPE = (Filler0, NtProductWinNt, NtProductLanManNt, NtProductServer); 1063 {$EXTERNALSYM _NT_PRODUCT_TYPE} 1064 NT_PRODUCT_TYPE = _NT_PRODUCT_TYPE; 1065 {$EXTERNALSYM NT_PRODUCT_TYPE} 1066 PNT_PRODUCT_TYPE = ^NT_PRODUCT_TYPE; 1067 TNtProductType = _NT_PRODUCT_TYPE; 1068 1069 // 1070 // the bit mask, SharedUserData->SuiteMask, is a ULONG 1071 // so there can be a maximum of 32 entries 1072 // in this enum. 1073 // 1074 1075 type 1076 _SUITE_TYPE = ( 1077 SmallBusiness, 1078 Enterprise, 1079 BackOffice, 1080 CommunicationServer, 1081 TerminalServer, 1082 SmallBusinessRestricted, 1083 EmbeddedNT, 1084 DataCenter, 1085 SingleUserTS, 1086 MaxSuiteType); 1087 {$EXTERNALSYM _SUITE_TYPE} 1088 SUITE_TYPE = _SUITE_TYPE; 1089 {$EXTERNALSYM SUITE_TYPE} 1090 TSuiteType = SUITE_TYPE; 1091 1092 1093 const 1094 VER_SERVER_NT = DWORD($80000000); 1095 {$EXTERNALSYM VER_SERVER_NT} 1096 VER_WORKSTATION_NT = $40000000; 1097 {$EXTERNALSYM VER_WORKSTATION_NT} 1098 VER_SUITE_SMALLBUSINESS = $00000001; 1099 {$EXTERNALSYM VER_SUITE_SMALLBUSINESS} 1100 VER_SUITE_ENTERPRISE = $00000002; 1101 {$EXTERNALSYM VER_SUITE_ENTERPRISE} 1102 VER_SUITE_BACKOFFICE = $00000004; 1103 {$EXTERNALSYM VER_SUITE_BACKOFFICE} 1104 VER_SUITE_COMMUNICATIONS = $00000008; 1105 {$EXTERNALSYM VER_SUITE_COMMUNICATIONS} 1106 VER_SUITE_TERMINAL = $00000010; 1107 {$EXTERNALSYM VER_SUITE_TERMINAL} 1108 VER_SUITE_SMALLBUSINESS_RESTRICTED = $00000020; 1109 {$EXTERNALSYM VER_SUITE_SMALLBUSINESS_RESTRICTED} 1110 VER_SUITE_EMBEDDEDNT = $00000040; 1111 {$EXTERNALSYM VER_SUITE_EMBEDDEDNT} 1112 VER_SUITE_DATACENTER = $00000080; 1113 {$EXTERNALSYM VER_SUITE_DATACENTER} 1114 VER_SUITE_SINGLEUSERTS = $00000100; 1115 {$EXTERNALSYM VER_SUITE_SINGLEUSERTS} 1116 VER_SUITE_PERSONAL = $00000200; 1117 {$EXTERNALSYM VER_SUITE_PERSONAL} 1118 VER_SUITE_BLADE = $00000400; 1119 {$EXTERNALSYM VER_SUITE_BLADE} 1120 1121 // ntdef.h 1122 1123 type 1124 error_status_t = Longword; 1125 {$EXTERNALSYM error_status_t} 1126 wchar_t = Word; 1127 {$EXTERNALSYM wchar_t} 1128 1129 // 1130 // The following types are guaranteed to be signed and 32 bits wide. 1131 // 1132 1133 type 1134 INT_PTR = PtrInt; 1135 {$EXTERNALSYM INT_PTR} 1136 PINT_PTR = ^INT_PTR; 1137 {$EXTERNALSYM PINT_PTR} 1138 UINT_PTR = PtrUint; 1139 {$EXTERNALSYM UINT_PTR} 1140 PUINT_PTR = ^UINT_PTR; 1141 {$EXTERNALSYM PUINT_PTR} 1142 LONG_PTR = PtrInt; 1143 {$EXTERNALSYM LONG_PTR} 1144 PLONG_PTR = ^LONG_PTR; 1145 {$EXTERNALSYM PLONG_PTR} 1146 ULONG_PTR = PTRUINT; 1147 {$EXTERNALSYM ULONG_PTR} 1148 PULONG_PTR = ^ULONG_PTR; 1149 {$EXTERNALSYM PULONG_PTR} 1150 1151 LONG32 = Integer; 1152 {$EXTERNALSYM LONG32} 1153 PLONG32 = ^LONG32; 1154 {$EXTERNALSYM PLONG32} 1155 INT32 = Integer; 1156 {$EXTERNALSYM INT32} 1157 PINT32 = ^INT32; 1158 {$EXTERNALSYM PINT32} 1159 1160 // 1161 // The following types are guaranteed to be unsigned and 32 bits wide. 1162 // 1163 1164 ULONG32 = Longword; 1165 {$EXTERNALSYM ULONG32} 1166 PULONG32 = ^ULONG32; 1167 {$EXTERNALSYM PULONG32} 1168 DWORD32 = Longword; 1169 {$EXTERNALSYM DWORD32} 1170 PDWORD32 = ^DWORD32; 1171 {$EXTERNALSYM PDWORD32} 1172 UINT32 = Longword; 1173 {$EXTERNALSYM UINT32} 1174 PUINT32 = ^UINT32; 1175 {$EXTERNALSYM PUINT32} 1176 1177 const 1178 MAX_PATH = 260; 1179 {$EXTERNALSYM MAX_PATH} 1180 1181 type 1182 1183 //unsigned char BYTE; 1184 //unsigned short WORD; 1185 1186 FLOAT = Single; 1187 {$EXTERNALSYM FLOAT} 1188 PFLOAT = ^FLOAT; 1189 {$EXTERNALSYM PFLOAT} 1190 PBOOL = {$IFDEF USE_DELPHI_TYPES} Windows.PBOOL {$ELSE} ^BOOL {$ENDIF}; 1191 {$EXTERNALSYM PBOOL} 1192 LPBOOL = {$IFDEF USE_DELPHI_TYPES} Windows.PBOOL {$ELSE} ^BOOL {$ENDIF}; 1193 {$EXTERNALSYM LPBOOL} 1194 PBYTE = {$IFDEF USE_DELPHI_TYPES} Windows.PBYTE {$ELSE} ^Byte {$ENDIF}; 1195 {$EXTERNALSYM PBYTE} 1196 LPBYTE = {$IFDEF USE_DELPHI_TYPES} Windows.PBYTE {$ELSE} ^Byte {$ENDIF}; 1197 {$EXTERNALSYM LPBYTE} 1198 PINT = {$IFDEF USE_DELPHI_TYPES} Windows.PINT {$ELSE} ^INT {$ENDIF}; 1199 {$EXTERNALSYM PINT} 1200 PUINT = {$IFDEF USE_DELPHI_TYPES} Windows.PUINT {$ELSE} ^UINT {$ENDIF}; 1201 {$EXTERNALSYM PUINT} 1202 LPUINT = {$IFDEF USE_DELPHI_TYPES} Windows.PUINT {$ELSE} ^UINT {$ENDIF}; 1203 {$EXTERNALSYM LPUINT} 1204 LPINT = {$IFDEF USE_DELPHI_TYPES} Windows.PINT {$ELSE} ^INT {$ENDIF}; 1205 {$EXTERNALSYM LPINT} 1206 PWORD = {$IFDEF USE_DELPHI_TYPES} Windows.PWORD {$ELSE} ^WORD {$ENDIF}; 1207 {$EXTERNALSYM PWORD} 1208 LPWORD = {$IFDEF USE_DELPHI_TYPES} Windows.PWORD {$ELSE} ^WORD {$ENDIF}; 1209 {$EXTERNALSYM LPWORD} 1210 LPLONG = ^LONG; 1211 {$EXTERNALSYM LPLONG} 1212 PDWORD = {$IFDEF USE_DELPHI_TYPES} Windows.PDWORD {$ELSE} ^DWORD {$ENDIF}; 1213 {$EXTERNALSYM PDWORD} 1214 LPDWORD = {$IFDEF USE_DELPHI_TYPES} Windows.LPDWORD {$ELSE} ^DWORD {$ENDIF}; 1215 {$EXTERNALSYM LPDWORD} 1216 LPVOID = Pointer; 1217 {$EXTERNALSYM LPVOID} 1218 LPCVOID = Pointer; 1219 {$EXTERNALSYM LPCVOID} 1220 LPLPVOID = ^LPVOID; 1221 {$NODEFINE LPVOID} 1222 1223 INT = Integer; 1224 {$EXTERNALSYM INT} 1225 UINT = {$IFDEF USE_DELPHI_TYPES} Windows.UINT {$ELSE} Longword {$ENDIF}; 1226 {$EXTERNALSYM UINT} 1227 1228 // Types use for passing & returning polymorphic values 1229 1230 WPARAM = {$IFDEF USE_DELPHI_TYPES} Windows.WPARAM {$ELSE} UINT_PTR {$ENDIF}; 1231 {$EXTERNALSYM WPARAM} 1232 LPARAM = {$IFDEF USE_DELPHI_TYPES} Windows.LPARAM {$ELSE} LONG_PTR {$ENDIF}; 1233 {$EXTERNALSYM LPARAM} 1234 LRESULT = {$IFDEF USE_DELPHI_TYPES} Windows.LRESULT {$ELSE} LONG_PTR {$ENDIF}; 1235 {$EXTERNALSYM LRESULT} 1236 1237 function MAKEWORD(a, b: BYTE): WORD; 1238 {$EXTERNALSYM MAKEWORD} 1239 function MAKELONG(a, b: WORD): DWORD; 1240 {$EXTERNALSYM MAKELONG} 1241 1242 function LOWORD(L: DWORD): WORD; 1243 {$EXTERNALSYM LOWORD} 1244 function HIWORD(L: DWORD): WORD; 1245 {$EXTERNALSYM HIWORD} 1246 function LOBYTE(W: WORD): BYTE; 1247 {$EXTERNALSYM LOBYTE} 1248 function HIBYTE(W: WORD): BYTE; 1249 {$EXTERNALSYM HIBYTE} 1250 1251 type 1252 HWND = {$IFDEF USE_DELPHI_TYPES} Windows.HWND {$ELSE} HANDLE {$ENDIF}; 1253 {$EXTERNALSYM HWND} 1254 LPHWND = ^HWND; 1255 {$EXTERNALSYM LPHWND} 1256 HHOOK = {$IFDEF USE_DELPHI_TYPES} Windows.HHOOK {$ELSE} HANDLE {$ENDIF}; 1257 {$EXTERNALSYM HHOOK} 1258 LPHHOOK = ^HHOOK; 1259 {$EXTERNALSYM LPHHOOK} 1260 HEVENT = HANDLE; 1261 {$EXTERNALSYM HEVENT} 1262 1263 ATOM = {$IFDEF USE_DELPHI_TYPES} Windows.ATOM {$ELSE} WORD {$ENDIF}; 1264 {$EXTERNALSYM ATOM} 1265 1266 SPHANDLE = ^HANDLE; 1267 {$EXTERNALSYM SPHANDLE} 1268 LPHANDLE = ^HANDLE; 1269 {$EXTERNALSYM LPHANDLE} 1270 HGLOBAL = {$IFDEF USE_DELPHI_TYPES} Windows.HGLOBAL {$ELSE} HANDLE {$ENDIF}; 1271 {$EXTERNALSYM HGLOBAL} 1272 HLOCAL = {$IFDEF USE_DELPHI_TYPES} Windows.HLOCAL {$ELSE} HANDLE {$ENDIF}; 1273 {$EXTERNALSYM HLOCAL} 1274 //GLOBALHANDLE = HANDLE; 1275 //{$EXTERNALSYM GLOBALHANDLE} // clashes with WinBase.GlobalHandle function 1276 //LOCALHANDLE = HANDLE; // todo clashes with WinBase.LocalHandle function 1277 //{$EXTERNALSYM LOCALHANDLE} 1278 FARPROC = {$IFDEF USE_DELPHI_TYPES} Windows.FARPROC {$ELSE} function: Integer; stdcall {$ENDIF}; 1279 {$EXTERNALSYM FARPROC} 1280 NEARPROC = function: Integer; stdcall; 1281 {$EXTERNALSYM NEARPROC} 1282 PROC = function: Integer; stdcall; 1283 {$EXTERNALSYM PROC} 1284 1285 HGDIOBJ = {$IFDEF USE_DELPHI_TYPES} Windows.HGDIOBJ {$ELSE} HANDLE {$ENDIF}; 1286 {$EXTERNALSYM HGDIOBJ} 1287 1288 HKEY = {$IFDEF USE_DELPHI_TYPES} Windows.HKEY {$ELSE} HANDLE {$ENDIF}; 1289 {$EXTERNALSYM HKEY} 1290 PHKEY = {$IFDEF USE_DELPHI_TYPES} Windows.PHKEY {$ELSE} ^HKEY {$ENDIF}; 1291 {$EXTERNALSYM PHKEY} 1292 1293 HACCEL = {$IFDEF USE_DELPHI_TYPES} Windows.HACCEL {$ELSE} HANDLE {$ENDIF}; 1294 {$EXTERNALSYM HACCEL} 1295 1296 HBITMAP = {$IFDEF USE_DELPHI_TYPES} Windows.HBITMAP {$ELSE} HANDLE {$ENDIF}; 1297 {$EXTERNALSYM HBITMAP} 1298 HBRUSH = {$IFDEF USE_DELPHI_TYPES} Windows.HBRUSH {$ELSE} HANDLE {$ENDIF}; 1299 {$EXTERNALSYM HBRUSH} 1300 1301 HCOLORSPACE = {$IFDEF USE_DELPHI_TYPES} Windows.HCOLORSPACE {$ELSE} HANDLE {$ENDIF}; 1302 {$EXTERNALSYM HCOLORSPACE} 1303 1304 HDC = {$IFDEF USE_DELPHI_TYPES} Windows.HDC {$ELSE} HANDLE {$ENDIF}; 1305 {$EXTERNALSYM HDC} 1306 HGLRC = {$IFDEF USE_DELPHI_TYPES} Windows.HGLRC {$ELSE} HANDLE {$ENDIF}; 1307 {$EXTERNALSYM HGLRC} 1308 HDESK = {$IFDEF USE_DELPHI_TYPES} Windows.HDESK {$ELSE} HANDLE {$ENDIF}; 1309 {$EXTERNALSYM HDESK} 1310 HENHMETAFILE = {$IFDEF USE_DELPHI_TYPES} Windows.HENHMETAFILE {$ELSE} HANDLE {$ENDIF}; 1311 {$EXTERNALSYM HENHMETAFILE} 1312 HFONT = {$IFDEF USE_DELPHI_TYPES} Windows.HFONT {$ELSE} HANDLE {$ENDIF}; 1313 {$EXTERNALSYM HFONT} 1314 HICON = {$IFDEF USE_DELPHI_TYPES} Windows.HICON {$ELSE} HANDLE {$ENDIF}; 1315 {$EXTERNALSYM HICON} 1316 HMENU = {$IFDEF USE_DELPHI_TYPES} Windows.HMENU {$ELSE} HANDLE {$ENDIF}; 1317 {$EXTERNALSYM HMENU} 1318 HMETAFILE = {$IFDEF USE_DELPHI_TYPES} Windows.HMETAFILE {$ELSE} HANDLE {$ENDIF}; 1319 {$EXTERNALSYM HMETAFILE} 1320 1321 // (rom) HINSTANCE collides with Delphi HInstance global variable 1322 HINST = {$IFDEF USE_DELPHI_TYPES} Windows.HINST {$ELSE} HANDLE {$ENDIF}; 1323 1324 HMODULE = {$IFDEF USE_DELPHI_TYPES} Windows.HMODULE {$ELSE} HINST {$ENDIF}; 1325 {$EXTERNALSYM HMODULE} 1326 HPALETTE = {$IFDEF USE_DELPHI_TYPES} Windows.HPALETTE {$ELSE} HANDLE {$ENDIF}; 1327 {$EXTERNALSYM HPALETTE} 1328 HPEN = {$IFDEF USE_DELPHI_TYPES} Windows.HPEN {$ELSE} HANDLE {$ENDIF}; 1329 {$EXTERNALSYM HPEN} 1330 HRGN = {$IFDEF USE_DELPHI_TYPES} Windows.HRGN {$ELSE} HANDLE {$ENDIF}; 1331 {$EXTERNALSYM HRGN} 1332 HRSRC = {$IFDEF USE_DELPHI_TYPES} Windows.HRSRC {$ELSE} HANDLE {$ENDIF}; 1333 {$EXTERNALSYM HRSRC} 1334 HSTR = {$IFDEF USE_DELPHI_TYPES} Windows.HSTR {$ELSE} HANDLE {$ENDIF}; 1335 {$EXTERNALSYM HSTR} 1336 HTASK = {$IFDEF USE_DELPHI_TYPES} Windows.HTASK {$ELSE} HANDLE {$ENDIF}; 1337 {$EXTERNALSYM HTASK} 1338 HWINSTA = {$IFDEF USE_DELPHI_TYPES} Windows.HWINSTA {$ELSE} HANDLE {$ENDIF}; 1339 {$EXTERNALSYM HWINSTA} 1340 HKL = {$IFDEF USE_DELPHI_TYPES} Windows.HKL {$ELSE} HANDLE {$ENDIF}; 1341 {$EXTERNALSYM HKL} 1342 PHKL = {$IFDEF USE_DELPHI_TYPES} ^HKL {$ELSE} ^HANDLE {$ENDIF}; 1343 {$EXTERNALSYM PHKL} 1344 1345 HMONITOR = HANDLE; 1346 {$EXTERNALSYM HMONITOR} 1347 HWINEVENTHOOK = HANDLE; 1348 {$EXTERNALSYM HWINEVENTHOOK} 1349 HUMPD = HANDLE; 1350 {$EXTERNALSYM HUMPD} 1351 1352 HFILE = {$IFDEF USE_DELPHI_TYPES} Windows.HFILE {$ELSE} Longword {$ENDIF}; 1353 {$EXTERNALSYM HFILE} 1354 HCURSOR = {$IFDEF USE_DELPHI_TYPES} Windows.HCURSOR {$ELSE} HICON {$ENDIF}; 1355 {$EXTERNALSYM HCURSOR} 1356 1357 COLORREF = {$IFDEF USE_DELPHI_TYPES} Windows.COLORREF {$ELSE} DWORD {$ENDIF}; 1358 {$EXTERNALSYM COLORREF} 1359 LPCOLORREF = ^COLORREF; 1360 {$EXTERNALSYM LPCOLORREF} 1361 1362 PHMODULE = ^HMODULE; 1363 {$NODEFINE PHMODULE} 1364 1365 const 1366 HFILE_ERROR = HFILE(-1); 1367 {$EXTERNALSYM HFILE_ERROR} 1368 1369 type 1370 LPRECT = ^RECT; 1371 {$EXTERNALSYM LPRECT} 1372 tagRECT = record 1373 left: LONG; 1374 top: LONG; 1375 right: LONG; 1376 bottom: LONG; 1377 end; 1378 {$EXTERNALSYM tagRECT} 1379 RECT = {$IFDEF USE_DELPHI_TYPES} Windows.TRect {$ELSE} tagRECT {$ENDIF}; 1380 {$EXTERNALSYM RECT} 1381 NPRECT = ^RECT; 1382 {$EXTERNALSYM NPRECT} 1383 LPCRECT = ^RECT; 1384 {$EXTERNALSYM LPCRECT} 1385 TRect = {$IFDEF USE_DELPHI_TYPES} Windows.TRect {$ELSE} RECT {$ENDIF}; 1386 PRect = {$IFDEF USE_DELPHI_TYPES} Windows.PRect {$ELSE} LPRECT {$ENDIF}; 1387 1388 LPRECTL = ^RECTL; 1389 {$EXTERNALSYM LPRECTL} 1390 _RECTL = record 1391 left: LONG; 1392 top: LONG; 1393 right: LONG; 1394 bottom: LONG; 1395 end; 1396 {$EXTERNALSYM _RECTL} 1397 RECTL = _RECTL; 1398 {$EXTERNALSYM RECTL} 1399 LPCRECTL = ^_RECTL; 1400 {$EXTERNALSYM LPCRECTL} 1401 TRectl = RECTL; 1402 PRectl = LPRECTL; 1403 1404 LPPOINT = ^POINT; 1405 {$EXTERNALSYM LPPOINT} 1406 tagPOINT = record 1407 x: LONG; 1408 y: LONG; 1409 end; 1410 {$EXTERNALSYM tagPOINT} 1411 NPPOINT = ^tagPoint; 1412 {$EXTERNALSYM NPPOINT} 1413 POINT = tagPOINT; 1414 {$EXTERNALSYM tagPOINT} 1415 TPoint = {$IFDEF USE_DELPHI_TYPES} Windows.TPoint {$ELSE} POINT {$ENDIF}; 1416 PPoint = {$IFDEF USE_DELPHI_TYPES} Windows.PPoint {$ELSE} LPPOINT {$ENDIF}; 1417 1418 PPointl = ^POINTL; 1419 _POINTL = record 1420 x: LONG; 1421 y: LONG; 1422 end; 1423 {$EXTERNALSYM _POINTL} 1424 POINTL = _POINTL; 1425 {$EXTERNALSYM POINTL} 1426 TPointl = POINTL; 1427 1428 LPSIZE = ^TSize; 1429 {$EXTERNALSYM LPSIZE} 1430 1431 {$IFDEF USE_DELPHI_TYPES} 1432 TSize = Windows.TSize; 1433 PSize = Windows.PSize; 1434 {$ELSE} 1435 tagSIZE = record 1436 cx: LONG; 1437 cy: LONG; 1438 end; 1439 {$EXTERNALSYM tagSIZE} 1440 TSize = tagSIZE; 1441 PSize = LPSIZE; 1442 {$ENDIF USE_DELPHI_TYPES} 1443 1444 SIZE = TSize; 1445 {$EXTERNALSYM SIZE} 1446 SIZEL = TSize; 1447 {$EXTERNALSYM SIZEL} 1448 PSIZEL = PSize; 1449 {$EXTERNALSYM PSIZEL} 1450 LPSIZEL = PSize; 1451 {$EXTERNALSYM LPSIZEL} 1452 1453 LPPOINTS = ^POINTS; 1454 {$EXTERNALSYM LPPOINTS} 1455 tagPOINTS = record 1456 x: SHORT; 1457 y: SHORT; 1458 end; 1459 {$EXTERNALSYM tagPOINTS} 1460 POINTS = tagPOINTS; 1461 {$EXTERNALSYM POINTS} 1462 TPoints = POINTS; 1463 PPoints = LPPOINTS; 1464 1465 // 1466 // File System time stamps are represented with the following structure: 1467 // 1468 1469 _FILETIME = record 1470 dwLowDateTime: DWORD; 1471 dwHighDateTime: DWORD; 1472 end; 1473 {$EXTERNALSYM _FILETIME} 1474 FILETIME = _FILETIME; 1475 {$EXTERNALSYM FILETIME} 1476 PFILETIME = ^FILETIME; 1477 {$EXTERNALSYM PFILETIME} 1478 LPFILETIME = PFILETIME; 1479 {$EXTERNALSYM LPFILETIME} 1480 TFileTime = FILETIME; 1481 1482 // mode selections for the device mode function 1483 1484 const 1485 DM_UPDATE = 1; 1486 {$EXTERNALSYM DM_UPDATE} 1487 DM_COPY = 2; 1488 {$EXTERNALSYM DM_COPY} 1489 DM_PROMPT = 4; 1490 {$EXTERNALSYM DM_PROMPT} 1491 DM_MODIFY = 8; 1492 {$EXTERNALSYM DM_MODIFY} 1493 1494 DM_IN_BUFFER = DM_MODIFY; 1495 {$EXTERNALSYM DM_IN_BUFFER} 1496 DM_IN_PROMPT = DM_PROMPT; 1497 {$EXTERNALSYM DM_IN_PROMPT} 1498 DM_OUT_BUFFER = DM_COPY; 1499 {$EXTERNALSYM DM_OUT_BUFFER} 1500 DM_OUT_DEFAULT = DM_UPDATE; 1501 {$EXTERNALSYM DM_OUT_DEFAULT} 1502 1503 // device capabilities indices 1504 1505 DC_FIELDS = 1; 1506 {$EXTERNALSYM DC_FIELDS} 1507 DC_PAPERS = 2; 1508 {$EXTERNALSYM DC_PAPERS} 1509 DC_PAPERSIZE = 3; 1510 {$EXTERNALSYM DC_PAPERSIZE} 1511 DC_MINEXTENT = 4; 1512 {$EXTERNALSYM DC_MINEXTENT} 1513 DC_MAXEXTENT = 5; 1514 {$EXTERNALSYM DC_MAXEXTENT} 1515 DC_BINS = 6; 1516 {$EXTERNALSYM DC_BINS} 1517 DC_DUPLEX = 7; 1518 {$EXTERNALSYM DC_DUPLEX} 1519 DC_SIZE = 8; 1520 {$EXTERNALSYM DC_SIZE} 1521 DC_EXTRA = 9; 1522 {$EXTERNALSYM DC_EXTRA} 1523 DC_VERSION = 10; 1524 {$EXTERNALSYM DC_VERSION} 1525 DC_DRIVER = 11; 1526 {$EXTERNALSYM DC_DRIVER} 1527 DC_BINNAMES = 12; 1528 {$EXTERNALSYM DC_BINNAMES} 1529 DC_ENUMRESOLUTIONS = 13; 1530 {$EXTERNALSYM DC_ENUMRESOLUTIONS} 1531 DC_FILEDEPENDENCIES = 14; 1532 {$EXTERNALSYM DC_FILEDEPENDENCIES} 1533 DC_TRUETYPE = 15; 1534 {$EXTERNALSYM DC_TRUETYPE} 1535 DC_PAPERNAMES = 16; 1536 {$EXTERNALSYM DC_PAPERNAMES} 1537 DC_ORIENTATION = 17; 1538 {$EXTERNALSYM DC_ORIENTATION} 1539 DC_COPIES = 18; 1540 {$EXTERNALSYM DC_COPIES} 1541 1542 // 1543 // HALF_PTR is half the size of a pointer it intended for use with 1544 // within strcuture which contain a pointer and two small fields. 1545 // UHALF_PTR is the unsigned variation. 1546 // 1547 1548 const 1549 ADDRESS_TAG_BIT = DWORD($80000000); 1550 {$EXTERNALSYM ADDRESS_TAG_BIT} 1551 1552 type 1553 UHALF_PTR = Byte; 1554 {$EXTERNALSYM UHALF_PTR} 1555 PUHALF_PTR = ^UHALF_PTR; 1556 {$EXTERNALSYM PUHALF_PTR} 1557 HALF_PTR = Shortint; 1558 {$EXTERNALSYM HALF_PTR} 1559 PHALF_PTR = ^HALF_PTR; 1560 {$EXTERNALSYM PHALF_PTR} 1561 1562 SHANDLE_PTR = Longint; 1563 {$EXTERNALSYM SHANDLE_PTR} 1564 HANDLE_PTR = Longint; 1565 {$EXTERNALSYM HANDLE_PTR} 1566 1567 // 1568 // SIZE_T used for counts or ranges which need to span the range of 1569 // of a pointer. SSIZE_T is the signed variation. 1570 // 1571 1572 SIZE_T = ULONG_PTR; 1573 {$EXTERNALSYM SIZE_T} 1574 PSIZE_T = ^SIZE_T; 1575 {$EXTERNALSYM PSIZE_T} 1576 SSIZE_T = LONG_PTR; 1577 {$EXTERNALSYM SSIZE_T} 1578 PSSIZE_T = ^SSIZE_T; 1579 {$EXTERNALSYM PSSIZE_T} 1580 1581 // 1582 // Add Windows flavor DWORD_PTR types 1583 // 1584 1585 DWORD_PTR = ULONG_PTR; 1586 {$EXTERNALSYM DWORD_PTR} 1587 PDWORD_PTR = ^DWORD_PTR; 1588 {$EXTERNALSYM PDWORD_PTR} 1589 1590 // 1591 // The following types are guaranteed to be signed and 64 bits wide. 1592 // 1593 1594 LONG64 = Int64; 1595 {$EXTERNALSYM LONG64} 1596 PLONG64 = ^LONG64; 1597 {$EXTERNALSYM PLONG64} 1598 1599 PINT64 = ^Int64; 1600 {$EXTERNALSYM PINT64} 1601 1602 // 1603 // The following types are guaranteed to be unsigned and 64 bits wide. 1604 // 1605 1606 ULONG64 = Int64; 1607 {$EXTERNALSYM ULONG64} 1608 PULONG64 = ^ULONG64; 1609 {$EXTERNALSYM PULONG64} 1610 DWORD64 = Int64; 1611 {$EXTERNALSYM DWORD64} 1612 PDWORD64 = ^DWORD64; 1613 {$EXTERNALSYM PDWORD64} 1614 UINT64 = Int64; 1615 {$EXTERNALSYM UINT64} 1616 PUINT64 = ^UINT64; 1617 {$EXTERNALSYM PUINT64} 1618 1619 const 1620 MAXUINT_PTR = not UINT_PTR(0); 1621 {$EXTERNALSYM MAXUINT_PTR} 1622 MAXINT_PTR = INT_PTR((MAXUINT_PTR shr 1)); 1623 {$EXTERNALSYM MAXINT_PTR} 1624 MININT_PTR = not MAXINT_PTR; 1625 {$EXTERNALSYM MININT_PTR} 1626 1627 MAXULONG_PTR = not ULONG_PTR(0); 1628 {$EXTERNALSYM MAXULONG_PTR} 1629 MAXLONG_PTR = LONG_PTR(MAXULONG_PTR shr 1); 1630 {$EXTERNALSYM MAXLONG_PTR} 1631 MINLONG_PTR = not MAXLONG_PTR; 1632 {$EXTERNALSYM MINLONG_PTR} 1633 1634 MAXUHALF_PTR = UHALF_PTR( not 0); 1635 {$EXTERNALSYM MAXUHALF_PTR} 1636 MAXHALF_PTR = HALF_PTR(MAXUHALF_PTR shr 1); 1637 {$EXTERNALSYM MAXHALF_PTR} 1638 MINHALF_PTR = not MAXHALF_PTR; 1639 {$EXTERNALSYM MINHALF_PTR} 1640 1641 // basetsd 1642 1643 type 1644 INT8 = Shortint; 1645 {$EXTERNALSYM INT8} 1646 PINT8 = ^INT8; 1647 {$EXTERNALSYM PINT8} 1648 INT16 = Smallint; 1649 {$EXTERNALSYM INT16} 1650 PINT16 = ^INT16; 1651 {$EXTERNALSYM PINT16} 1652 UINT8 = Byte; 1653 {$EXTERNALSYM UINT8} 1654 PUINT8 = ^UINT8; 1655 {$EXTERNALSYM PUINT8} 1656 UINT16 = Word; 1657 {$EXTERNALSYM UINT16} 1658 PUINT16 = ^UINT16; 1659 {$EXTERNALSYM PUINT16} 1660 1661 // 1662 // Thread affinity. 1663 // 1664 1665 KAFFINITY = ULONG_PTR; 1666 {$EXTERNALSYM KAFFINITY} 1667 PKAFFINITY = ^KAFFINITY; 1668 {$EXTERNALSYM PKAFFINITY} 1669 1670 // (rom) missing types 1671 LPCASTR = ^AnsiChar; 1672 LPASTR = ^AnsiChar; 1673 PCASTR = ^AnsiChar; 1674 PASTR = ^AnsiChar; 1675 1676 PPCWSTR = ^LPCWSTR; 1677 PPCASTR = ^LPCASTR; 1678 PPCSTR = ^LPCTSTR; 1679 PPWSTR = ^LPWSTR; 1680 PPASTR = ^LPASTR; 1681 PPSTR = ^LPTSTR; 1682 PPTCHAR = ^PTCHAR; 1683 LPLPCTSTR = ^LPCTSTR; 1684 1685 1686 {$ENDIF JWA_IMPLEMENTATIONSECTION} 1687 //*** 1688 1689 1690 1691 {$IFNDEF JWA_OMIT_SECTIONS} 1692 implementation 1693 1694 uses 1695 JwaWinNT; 1696 {$ENDIF JWA_OMIT_SECTIONS} 1697 1698 {$IFNDEF JWA_INTERFACESECTION} 1699 1700 {$IFNDEF USE_DELPHI_TYPES} 1701 const 1702 kernel32 = 'kernel32.dll'; 1703 {$ENDIF !USE_DELPHI_TYPES} 1704 1705 function Int32x32To64(a, b: LONG): LONGLONG; 1706 begin 1707 Result := a * b; 1708 end; 1709 1710 function UInt32x32To64(a, b: DWORD): ULONGLONG; 1711 begin 1712 Result := a * b; 1713 end; 1714 1715 function Int64ShllMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG; 1716 {$ifdef Win32} 1717 asm 1718 MOV ECX, ShiftCount 1719 MOV EAX, DWORD PTR [Value] 1720 MOV EDX, DWORD PTR [Value + 4] 1721 SHLD EDX, EAX, CL 1722 SHL EAX, CL 1723 end; 1724 {$else} 1725 begin 1726 Result := Value shl ShiftCount; 1727 end; 1728 {$endif} 1729 1730 function Int64ShraMod32(Value: LONGLONG; ShiftCount: DWORD): LONGLONG; 1731 {$ifdef Win32} 1732 asm 1733 MOV ECX, ShiftCount 1734 MOV EAX, DWORD PTR [Value] 1735 MOV EDX, DWORD PTR [Value + 4] 1736 SHRD EAX, EDX, CL 1737 SAR EDX, CL 1738 end; 1739 {$else} 1740 begin 1741 Result := SarInt64(Value, ShiftCount); 1742 end; 1743 {$endif} 1744 1745 function Int64ShrlMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG; 1746 {$ifdef Win32} 1747 asm 1748 MOV ECX, ShiftCount 1749 MOV EAX, DWORD PTR [Value] 1750 MOV EDX, DWORD PTR [Value + 4] 1751 SHRD EAX, EDX, CL 1752 SHR EDX, CL 1753 end; 1754 {$else} 1755 begin 1756 Result := Value shr ShiftCount; 1757 end; 1758 {$endif} 1759 1760 procedure ListEntry32To64(l32: PLIST_ENTRY32; l64: PLIST_ENTRY64); 1761 begin 1762 l64^.Flink := l32^.Flink; 1763 l64^.Blink := l32^.Blink; 1764 end; 1765 1766 procedure ListEntry64To32(l64: PLIST_ENTRY64; l32: PLIST_ENTRY32); 1767 begin 1768 l32^.Flink := ULONG(l64^.Flink); 1769 l32^.Blink := ULONG(l64^.Blink); 1770 end; 1771 1772 function NT_SUCCESS(Status: NTSTATUS): BOOL; 1773 begin 1774 Result := Status >= 0; 1775 end; 1776 1777 function NT_INFORMATION(Status: NTSTATUS): BOOL; 1778 begin 1779 Result := (ULONG(Status) shr 30) = 1; 1780 end; 1781 1782 function NT_WARNING(Status: NTSTATUS): BOOL; 1783 begin 1784 Result := (ULONG(Status) shr 30) = 2; 1785 end; 1786 1787 function NT_ERROR(Status: NTSTATUS): BOOL; 1788 begin 1789 Result := (ULONG(Status) shr 30) = 3; 1790 end; 1791 1792 procedure InitializeObjectAttributes(p: POBJECT_ATTRIBUTES; n: PUNICODE_STRING; 1793 a: ULONG; r: HANDLE; s: PVOID{PSECURITY_DESCRIPTOR}); 1794 begin 1795 p^.Length := SizeOf(OBJECT_ATTRIBUTES); 1796 p^.RootDirectory := r; 1797 p^.Attributes := a; 1798 p^.ObjectName := n; 1799 p^.SecurityDescriptor := s; 1800 p^.SecurityQualityOfService := nil; 1801 end; 1802 1803 function ARGUMENT_PRESENT(ArgumentPointer: Pointer): BOOL; 1804 begin 1805 Result := ArgumentPointer <> nil; 1806 end; 1807 1808 function MAKEWORD(a, b: BYTE): WORD; 1809 begin 1810 Result := (b shl 8) or a; 1811 end; 1812 1813 function MAKELONG(a, b: WORD): DWORD; 1814 begin 1815 Result := (b shl 16) or a; 1816 end; 1817 1818 function LOWORD(L: DWORD): WORD; 1819 begin 1820 Result := L and $0000FFFF; 1821 end; 1822 1823 function HIWORD(L: DWORD): WORD; 1824 begin 1825 Result := L shr 16; 1826 end; 1827 1828 function LOBYTE(W: WORD): BYTE; 1829 begin 1830 Result := W and $FF; 1831 end; 1832 1833 function HIBYTE(W: WORD): BYTE; 1834 begin 1835 Result := W shr 8; 1836 end; 1837 1838 {$IFDEF JWA_INCLUDEMODE} //prevents stackoverflow in GetProcedureAddress 1839 function JwaWinType_GetModuleHandle(lpModuleName: LPCSTR): HMODULE; stdcall; external kernel32 name 'GetModuleHandleA'; 1840 function JwaWinType_LoadLibrary(lpLibFileName: LPCSTR): HMODULE; stdcall; external kernel32 name 'LoadLibraryA'; 1841 function JwaWinType_GetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC; stdcall; external kernel32 name 'GetProcAddress'; 1842 {$ELSE} 1843 function GetModuleHandle(lpModuleName: LPCSTR): HMODULE; stdcall; external kernel32 name 'GetModuleHandleA'; 1844 function LoadLibrary(lpLibFileName: LPCSTR): HMODULE; stdcall; external kernel32 name 'LoadLibraryA'; 1845 function GetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC; stdcall; external kernel32 name 'GetProcAddress'; 1846 {$ENDIF JWA_INCLUDEMODE} 1847 1848 const 1849 RsELibraryNotFound = 'Library not found: %s'; 1850 RsEFunctionNotFound = 'Function not found: %s.%s'; 1851 1852 procedure GetProcedureAddress(var P: Pointer; const ModuleName, ProcName: string); 1853 var 1854 ModuleHandle: HMODULE; 1855 begin 1856 if not Assigned(P) then 1857 begin 1858 ModuleHandle := {$IFDEF JWA_INCLUDEMODE}jwaWinType_GetModuleHandle 1859 {$ELSE}GetModuleHandle 1860 {$ENDIF JWA_INCLUDEMODE} 1861 (PChar(ModuleName)); 1862 if ModuleHandle = 0 then 1863 begin 1864 ModuleHandle := {$IFDEF JWA_INCLUDEMODE}jwaWinType_LoadLibrary 1865 {$ELSE}LoadLibrary 1866 {$ENDIF JWA_INCLUDEMODE}(PChar(ModuleName)); 1867 if ModuleHandle = 0 then 1868 raise EJwaLoadLibraryError.CreateFmt(RsELibraryNotFound, [ModuleName]); 1869 end; 1870 P := Pointer({$IFDEF JWA_INCLUDEMODE}jwaWinType_GetProcAddress 1871 {$ELSE}GetProcAddress 1872 {$ENDIF JWA_INCLUDEMODE}(ModuleHandle, PChar(ProcName))); 1873 if not Assigned(P) then 1874 raise EJwaGetProcAddressError.CreateFmt(RsEFunctionNotFound, [ModuleName, ProcName]); 1875 end; 1876 end; 1877 1878 {$ENDIF JWA_INTERFACESECTION} 1879 1880 1881 {$IFNDEF JWA_OMIT_SECTIONS} 1882 end. 1883 {$ENDIF JWA_OMIT_SECTIONS} 1884 1885 1886 1887 1888 1889 1890 1891 1892