jwaactiveds.pas

比较全面的win32api开发包

//-----------------------------------------------------------------------------

function ADsPropCheckIfWritable(pwzAttr: PWSTR; pWritableAttrs: PADS_ATTR_INFO): BOOL; stdcall;
{$EXTERNALSYM ADsPropCheckIfWritable}

implementation

const
  adslib = 'activeds.dll';
  dsprop = 'dsprop.dll';

// adshlp.h


{$IFDEF DYNAMIC_LINK}
var
  _ADsGetObject: Pointer;

function ADsGetObject;
begin
  GetProcedureAddress(_ADsGetObject, adslib, 'ADsGetObject');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsGetObject]
  end;
end;
{$ELSE}
function ADsGetObject; external adslib name 'ADsGetObject';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsBuildEnumerator: Pointer;

function ADsBuildEnumerator;
begin
  GetProcedureAddress(_ADsBuildEnumerator, adslib, 'ADsBuildEnumerator');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsBuildEnumerator]
  end;
end;
{$ELSE}
function ADsBuildEnumerator; external adslib name 'ADsBuildEnumerator';
{$ENDIF DYNAMIC_LINK}

function _ADsFreeEnumerator(pEnumVariant: IEnumVARIANT): HRESULT; stdcall; external adslib name 'ADsFreeEnumerator';

function ADsFreeEnumerator(var pEnumVariant: IEnumVARIANT): HRESULT;
begin
  Result := _ADsFreeEnumerator(pEnumVariant);
  // ADsFreeEnumerator doesn't set pEnumVariant to nil causing Delphi to call
  // Release() again when pEnumVariant leaves scope. Result would be an access
  // violation, explicitly setting the interface to nil prevents this.
  if Result = 0{S_OK} then Pointer(pEnumVariant) := nil;
end;


{$IFDEF DYNAMIC_LINK}
var
  _ADsEnumerateNext: Pointer;

function ADsEnumerateNext;
begin
  GetProcedureAddress(_ADsEnumerateNext, adslib, 'ADsEnumerateNext');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsEnumerateNext]
  end;
end;
{$ELSE}
function ADsEnumerateNext; external adslib name 'ADsEnumerateNext';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsBuildVarArrayStr: Pointer;

function ADsBuildVarArrayStr;
begin
  GetProcedureAddress(_ADsBuildVarArrayStr, adslib, 'ADsBuildVarArrayStr');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsBuildVarArrayStr]
  end;
end;
{$ELSE}
function ADsBuildVarArrayStr; external adslib name 'ADsBuildVarArrayStr';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsBuildVarArrayInt: Pointer;

function ADsBuildVarArrayInt;
begin
  GetProcedureAddress(_ADsBuildVarArrayInt, adslib, 'ADsBuildVarArrayInt');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsBuildVarArrayInt]
  end;
end;
{$ELSE}
function ADsBuildVarArrayInt; external adslib name 'ADsBuildVarArrayInt';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsOpenObject: Pointer;

function ADsOpenObject;
begin
  GetProcedureAddress(_ADsOpenObject, adslib, 'ADsOpenObject');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsOpenObject]
  end;
end;
{$ELSE}
function ADsOpenObject; external adslib name 'ADsOpenObject';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsGetLastError: Pointer;

function ADsGetLastError;
begin
  GetProcedureAddress(_ADsGetLastError, adslib, 'ADsGetLastError');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsGetLastError]
  end;
end;
{$ELSE}
function ADsGetLastError; external adslib name 'ADsGetLastError';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsSetLastError: Pointer;

procedure ADsSetLastError;
begin
  GetProcedureAddress(_ADsSetLastError, adslib, 'ADsSetLastError');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsSetLastError]
  end;
end;
{$ELSE}
procedure ADsSetLastError; external adslib name 'ADsSetLastError';
{$ENDIF DYNAMIC_LINK}
//procedure ADsFreeAllErrorRecords

{$IFDEF DYNAMIC_LINK}
var
  _AllocADsMem: Pointer;

function AllocADsMem;
begin
  GetProcedureAddress(_AllocADsMem, adslib, 'AllocADsMem');
  asm
    mov esp, ebp
    pop ebp
    jmp [_AllocADsMem]
  end;
end;
{$ELSE}
function AllocADsMem; external adslib name 'AllocADsMem';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _FreeADsMem: Pointer;

function FreeADsMem;
begin
  GetProcedureAddress(_FreeADsMem, adslib, 'FreeADsMem');
  asm
    mov esp, ebp
    pop ebp
    jmp [_FreeADsMem]
  end;
end;
{$ELSE}
function FreeADsMem; external adslib name 'FreeADsMem';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ReallocADsMem: Pointer;

function ReallocADsMem;
begin
  GetProcedureAddress(_ReallocADsMem, adslib, 'ReallocADsMem');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ReallocADsMem]
  end;
end;
{$ELSE}
function ReallocADsMem; external adslib name 'ReallocADsMem';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _AllocADsStr: Pointer;

function AllocADsStr;
begin
  GetProcedureAddress(_AllocADsStr, adslib, 'AllocADsStr');
  asm
    mov esp, ebp
    pop ebp
    jmp [_AllocADsStr]
  end;
end;
{$ELSE}
function AllocADsStr; external adslib name 'AllocADsStr';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _FreeADsStr: Pointer;

function FreeADsStr;
begin
  GetProcedureAddress(_FreeADsStr, adslib, 'FreeADsStr');
  asm
    mov esp, ebp
    pop ebp
    jmp [_FreeADsStr]
  end;
end;
{$ELSE}
function FreeADsStr; external adslib name 'FreeADsStr';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ReallocADsStr: Pointer;

function ReallocADsStr;
begin
  GetProcedureAddress(_ReallocADsStr, adslib, 'ReallocADsStr');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ReallocADsStr]
  end;
end;
{$ELSE}
function ReallocADsStr; external adslib name 'ReallocADsStr';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsEncodeBinaryData: Pointer;

function ADsEncodeBinaryData;
begin
  GetProcedureAddress(_ADsEncodeBinaryData, adslib, 'ADsEncodeBinaryData');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsEncodeBinaryData]
  end;
end;
{$ELSE}
function ADsEncodeBinaryData; external adslib name 'ADsEncodeBinaryData';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsDecodeBinaryData: Pointer;

function ADsDecodeBinaryData;
begin
  GetProcedureAddress(_ADsDecodeBinaryData, adslib, 'ADsDecodeBinaryData');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsDecodeBinaryData]
  end;
end;
{$ELSE}
function ADsDecodeBinaryData; external adslib name 'ADsDecodeBinaryData';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _PropVariantToAdsType: Pointer;

function PropVariantToAdsType;
begin
  GetProcedureAddress(_PropVariantToAdsType, adslib, 'PropVariantToAdsType');
  asm
    mov esp, ebp
    pop ebp
    jmp [_PropVariantToAdsType]
  end;
end;
{$ELSE}
function PropVariantToAdsType; external adslib name 'PropVariantToAdsType';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _AdsTypeToPropVariant: Pointer;

function AdsTypeToPropVariant;
begin
  GetProcedureAddress(_AdsTypeToPropVariant, adslib, 'AdsTypeToPropVariant');
  asm
    mov esp, ebp
    pop ebp
    jmp [_AdsTypeToPropVariant]
  end;
end;
{$ELSE}
function AdsTypeToPropVariant; external adslib name 'AdsTypeToPropVariant';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _AdsFreeAdsValues: Pointer;

procedure AdsFreeAdsValues;
begin
  GetProcedureAddress(_AdsFreeAdsValues, adslib, 'AdsFreeAdsValues');
  asm
    mov esp, ebp
    pop ebp
    jmp [_AdsFreeAdsValues]
  end;
end;
{$ELSE}
procedure AdsFreeAdsValues; external adslib name 'AdsFreeAdsValues';
{$ENDIF DYNAMIC_LINK}

// adsprop.h


{$IFDEF DYNAMIC_LINK}
var
  _ADsPropCreateNotifyObj: Pointer;

function ADsPropCreateNotifyObj;
begin
  GetProcedureAddress(_ADsPropCreateNotifyObj, dsprop, 'ADsPropCreateNotifyObj');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsPropCreateNotifyObj]
  end;
end;
{$ELSE}
function ADsPropCreateNotifyObj; external dsprop name 'ADsPropCreateNotifyObj';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsPropGetInitInfo: Pointer;

function ADsPropGetInitInfo;
begin
  GetProcedureAddress(_ADsPropGetInitInfo, dsprop, 'ADsPropGetInitInfo');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsPropGetInitInfo]
  end;
end;
{$ELSE}
function ADsPropGetInitInfo; external dsprop name 'ADsPropGetInitInfo';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsPropSetHwnd: Pointer;

function ADsPropSetHwnd;
begin
  GetProcedureAddress(_ADsPropSetHwnd, dsprop, 'ADsPropSetHwnd');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsPropSetHwnd]
  end;
end;
{$ELSE}
function ADsPropSetHwnd; external dsprop name 'ADsPropSetHwnd';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _ADsPropCheckIfWritable: Pointer;

function ADsPropCheckIfWritable;
begin
  GetProcedureAddress(_ADsPropCheckIfWritable, dsprop, 'ADsPropCheckIfWritable');
  asm
    mov esp, ebp
    pop ebp
    jmp [_ADsPropCheckIfWritable]
  end;
end;
{$ELSE}
function ADsPropCheckIfWritable; external dsprop name 'ADsPropCheckIfWritable';
{$ENDIF DYNAMIC_LINK}

end.