pnbastsd.pas

Delphi源码REAlRMSDK.rar

unit PnBasTsd;

interface

//***************************************************************************
//
//  $Id: pnbastsd.h,v 1.2 1999/01/29 18:32:10 hboone Exp $
//
//  Copyright (C) 1995-1999 RealNetworks, Inc. All rights reserved.
//
//  http://www.real.com/devzone
//
//  This file is a replacement for the basetsd.h file from VC++ 6.0.
//  This will automatically be included by pntypes.h when using VC++
//  6.0 or greater. This file correctly defines the basic sized types
//  so they don't conflict with the G2 SDK.
//
//

//
// The following types are 32 bits wide and unsigned.
//

type
  PULONG32 = ^Cardinal;
  {$EXTERNALSYM PULONG32}
  DWORD32 = Cardinal;
  {$EXTERNALSYM DWORD32}
  PDWORD32 = ^DWORD32;
  {$EXTERNALSYM PDWORD32}
  PUINT32 = ^Cardinal;
  {$EXTERNALSYM PUINT32}

//
// INT_PTR is the same size as a pointer.  Its size changes with pointer
// size (32 bit or 64 bit).  HALF_PTR is half the size of a pointer.
//

{$IFDEF _WIN64}

type
  INT_PTR = Int64;
  {$EXTERNALSYM INT_PTR}
  PINT_PTR = ^INT_PTR;
  {$EXTERNALSYM PINT_PTR}
  UINT_PTR = Int64;
  {$EXTERNALSYM UINT_PTR}
  PUINT_PTR = ^UINT_PTR;
  {$EXTERNALSYM PUINT_PTR}

const
  MAXINT_PTR = $7fffffffffffffff;
  {$EXTERNALSYM MAXINT_PTR}
  MININT_PTR = $8000000000000000;
  {$EXTERNALSYM MININT_PTR}
  MAXUINT_PTR = $ffffffffffffffff;
  {$EXTERNALSYM MAXUINT_PTR}

type
  UHALF_PTR = Cardinal;
  {$EXTERNALSYM UHALF_PTR}
  PUHALF_PTR = ^UHALF_PTR;
  {$EXTERNALSYM PUHALF_PTR}
  HALF_PTR = Integer;
  {$EXTERNALSYM HALF_PTR}
  PHALF_PTR = ^HALF_PTR;
  {$EXTERNALSYM PHALF_PTR}

const
  MAXUHALF_PTR = DWORD($ffffffff);
  {$EXTERNALSYM MAXUHALF_PTR}
  MAXHALF_PTR = DWORD($7fffffff);
  {$EXTERNALSYM MAXHALF_PTR}
  MINHALF_PTR = DWORD($80000000);
  {$EXTERNALSYM MINHALF_PTR}

{$IFNDEF __midl}

(* MVB TODO
__inline
unsigned long
HandleToUlong(
    void *h
    )
{
    return((unsigned long) h );
}

__inline
unsigned long
PtrToUlong(
    void  *p
    )
{
    return((unsigned long) p );
}

__inline
unsigned short
PtrToUshort(
    void  *p
    )
{
    return((unsigned short) p );
}

__inline
long
PtrToLong(
    void  *p
    )
{
    return((long) p );
}

__inline
short
PtrToShort(
    void  *p
    )
{
    return((short) p );
}
*)

{$ENDIF __midl}

{$ELSE} // _WIN64

type
  INT_PTR = Longint;
  {$EXTERNALSYM INT_PTR}
  PINT_PTR = ^INT_PTR;
  {$EXTERNALSYM PINT_PTR}
  UINT_PTR = Longword;
  {$EXTERNALSYM UINT_PTR}
  PUINT_PTR = ^UINT_PTR;
  {$EXTERNALSYM PUINT_PTR}

const
  MAXINT_PTR = Longword($7fffffff);
  {$EXTERNALSYM MAXINT_PTR}
  MININT_PTR = Longword($80000000);
  {$EXTERNALSYM MININT_PTR}
  MAXUINT_PTR = Longword($ffffffff);
  {$EXTERNALSYM MAXUINT_PTR}

type
  UHALF_PTR = Word;
  {$EXTERNALSYM UHALF_PTR}
  PUHALF_PTR = ^UHALF_PTR;
  {$EXTERNALSYM PUHALF_PTR}
  HALF_PTR = SmallInt;
  {$EXTERNALSYM HALF_PTR}
  PHALF_PTR = HALF_PTR;
  {$EXTERNALSYM PHALF_PTR}

const
  MAXUHALF_PTR = Word($ffff);
  MAXHALF_PTR = Word($7fff);
  MINHALF_PTR = Word($8000);

{ MVB TODO
#define HandleToUlong( h ) ((ULONG) (h) )
#define PtrToUlong( p ) ((ULONG) (p) )
#define PtrToLong( p ) ((LONG) (p) )
#define PtrToUshort( p ) ((unsigned short) (p) )
#define PtrToShort( p ) ((short) (p) )
}

{$ENDIF _WIN64}

//
// Basic SIZE_T support.
//

type
  SIZE_T = UINT_PTR;
  {$EXTERNALSYM SIZE_T}
  PSIZE_T = ^SIZE_T;
  {$EXTERNALSYM PSIZE_T}
  SSIZE_T = INT_PTR;
  {$EXTERNALSYM SSIZE_T}
  PSSIZE_T = ^SSIZE_T;
  {$EXTERNALSYM PSSIZE_T}

//
// These types are 64 bits wide and signed.
//

type
  LONG64 = Int64;
  {$EXTERNALSYM LONG64}
  PLONG64 = ^LONG64;
  {$EXTERNALSYM PLONG64}
  //INT64 = Int64;
  //{$EXTERNALSYM INT64}
  //PINT64 = ^INT64;
  //{$EXTERNALSYM PINT64}

//
// These types are 64 bits wide and unsigned.
//

type
  ULONG64 = Int64;
  {$EXTERNALSYM ULONG64}
  PULONG64 = ^ULONG64;
  {$EXTERNALSYM PULONG64}
  DWORD64 = Int64;
  {$EXTERNALSYM DWORD64}
  PDWORD64 = ^DWORD64;
  {$EXTERNALSYM PDWORD64}
  UINT64 = Int64;
  {$EXTERNALSYM UINT64}
  PUINT64 = ^UINT64;
  {$EXTERNALSYM PUINT64}

implementation

end.