I'm new in delphi, my program developed in delphi working with a dll developed in C++, I need working with pointer functions that throw exceptions of Access Violation address and after many test I don't know how resolve It.
this is defintion of the pointer function in delphi that translate since header c++
type
TMICRCallback = function: Integer of Object; stdcall;
TStatusCallback = function(dwParam: Cardinal): Integer of Object; stdcall;
type
TBiMICRSetReadBackFunction =
function(const nHande: Integer;
pMicrCB: TMICRCallback;
var pReadBuffSize: Byte;
var readCharBuff: Byte;
var pStatus: Byte;
var pDetail: Byte
): Integer; stdcall;
var
BiMICRSetReadBackFunction: TBiMICRSetReadBackFunction;
type
TBiMICRSetReadBackFunction =
function(const nHande: Integer;
pMicrCB: TMICRCallback;
var pReadBuffSize: Byte;
var readCharBuff: Byte;
var pStatus: Byte;
var pDetail: Byte
): Integer; stdcall;
var
BiMICRSetReadBackFunction: TBiMICRSetReadBackFunction;
this is a code that call the pointer functions
type
function CBMICRRead : Integer; stdcall;
function CBMICRStatus(dwStatus: LongWord) : Integer; stdcall;
Respuesta : TMICRCallback;
Estado : TStatusCallback;
BiSetStatusBackFunction(m_hApi, Estado);
BiMICRSetReadBackFunction (m_hApi,
Respuesta,
m_MICRReadBuffSize,
m_MICRReadBuff[0],
m_MICRReadStatus,
m_MICRReadStDetail);
This is the C++ side of the interface:
typedef int (CALLBACK* MICRCallback)(void);
typedef int (CALLBACK* StatusCallback)(DWORD);
int WINAPI BiSetStatusBackFunction(int nHandle,
int (CALLBACK *pStatusCB)(DWORD dwStatus));
int WINAPI BiMICRSetReadBackFunction(int nHandle,
int (CALLBACK *pMicrCB)(void),
LPBYTE pReadBuffSize,
LPBYTE readCharBuff,
LPBYTE pStatus,
LPBYTE pDetail);
You must avoid Object as passing parameters from/to DLL function call result.
TMICRCallback = function: Integer; stdcall;
TStatusCallback = function(dwParam: Cardinal): Integer; stdcall;
Related
I have a library written in C and I have a header file with a description of the interface in C. The DLL has a function to get this interface. How to describe it correctly and get it in the DELPHI application?
using DllCallbackClassPtr = void*;
using DllCallbackFunction = void(*)(const char *, DllCallbackClassPtr);
#ifdef _WIN32
#include <Windows.h>
__interface IXeoma
{
public:
enum ConnectErrorCode {
OK = 0,
SERVER_NOT_FOUND,
WRONG_PASSWORD,
UNKNOWN
};
// return ConnectErrorCode
virtual int start(const char* connectionString) = 0;
virtual bool isConnected() = 0;
virtual void stop() = 0;
virtual void requestData(const char* request, const char* additionalData, DllCallbackClassPtr classPtr, DllCallbackFunction callbackFunc) = 0;
virtual const char* getRequestResult(const char* request) = 0;
virtual void setCameraRenderHandle(const char* previewId, HWND hWnd) = 0;
};
The library is loaded, but the function returns nil.
type
IXeoma = interface
function Start(connectionString: PChar): integer;
end;
type
TCreateXeomaInterface = function() : IXeoma; stdcall;
var
Form1: TForm1;
CreateXeomaInterface: TCreateXeomaInterface;
implementation
{$R *.dfm}
var
LibraryHandle: THandle;
procedure TForm1.Button1Click(Sender: TObject);
var
XeomaInt: IXeoma;
i: integer;
begin
LibraryHandle := LoadLibrary(PChar('D:\Projects\XeomaSDK\Win32\Debug\xeomaclientdll.dll'));
if LibraryHandle >= 32 then
begin
#CreateXeomaInterface := GetProcAddress(LibraryHandle, 'createXeomaInterface');
end;
XeomaInt := CreateXeomaInterface();
// Here XeomaInt = nil
end;
The __interface extension in Visual C++, and the interface keyword in Delphi, are not the same thing, and are not compatible with each other.
IXeoma in the C++ code is just an ordinary class type, not a COM interface. But in Delphi, all interfaces derive from IUnknown, and all classes derive from TObject, neither of which you want in this situation. So, you are going to have to use a plain record instead, and declare TCreateXeomaInterface as returning a pointer to that record.
Also, note that a Delphi record can't have virtual methods, but the C++ class does have them, so you are going to have to manually account for the C++ class's vtable in Delphi.
Try something like this:
type
DllCallbackClassPtr = Pointer;
DllCallbackFunction = procedure(Param1: PAnsiChar; Param2: DllCallbackClassPtr); cdecl;
IXeomaPtr = ^IXeoma;
IXeomaVTable = record
start: function(_Self: IXeomaPtr; connectionString: PAnsiChar): Integer; cdecl;
isConnected: function(_Self: IXeomaPtr): Boolean; cdecl;;
stop: procedure(_Self: IXeomaPtr); cdecl;
requestData: procedure(_Self: IXeomaPtr; request: PAnsiChar; additionalData: PAnsiChar; classPtr: DllCallbackClassPtr; callbackFunc: DllCallbackFunction); cdecl;
getRequestResult: function(_Self: IXeomaPtr; request: PAnsiChar): PAnsiChar; cdecl;
setCameraRenderHandle: procedure(_Self: IXeomaPtr; previewId: PAnsiChar; hWnd: HWND); cdecl;
end;
ConnectErrorCode = (
OK = 0,
SERVER_NOT_FOUND,
WRONG_PASSWORD,
UNKNOWN
);
IXeoma = record
vtable: ^IXeomaVTable:
end;
type
TCreateXeomaInterface = function() : IXeomaPtr; stdcall;
var
Form1: TForm1;
CreateXeomaInterface: TCreateXeomaInterface;
implementation
{$R *.dfm}
var
LibraryHandle: THandle;
procedure TForm1.Button1Click(Sender: TObject);
var
XeomaInt: IXeomaPtr;
i: integer;
begin
XeomaInt := nil;
LibraryHandle := LoadLibrary('D:\Projects\XeomaSDK\Win32\Debug\xeomaclientdll.dll');
if LibraryHandle >= 32 then
begin
#CreateXeomaInterface := GetProcAddress(LibraryHandle, 'createXeomaInterface');
XeomaInt := CreateXeomaInterface();
if XeomaInt <> nil then
XeomaInt^.vtable^.start(XeomaInt, '123:123#localhost:8090');
end;
...
end;
I admit I'm not a Delphi expert, so I need some advice.
I have a pre-built class with this definition
TS7Helper = class
private
function GetInt(pval: pointer): smallint;
procedure SetInt(pval: pointer; const Value: smallint);
function GetWord(pval: pointer): word;
procedure SetWord(pval: pointer; const Value: word);
function GetDInt(pval: pointer): longint;
procedure SetDInt(pval: pointer; const Value: longint);
function GetDWord(pval: pointer): longword;
procedure SetDWord(pval: pointer; const Value: longword);
function GetDateTime(pval: pointer): TDateTime;
procedure SetDateTime(pval: pointer; const Value: TDateTime);
function GetReal(pval: pointer): single;
procedure SetReal(pval: pointer; const Value: single);
function GetBit(pval: pointer; BitIndex: integer): boolean;
procedure SetBit(pval: pointer; BitIndex: integer; const Value: boolean);
public
procedure Reverse(pval : pointer; const S7Type : TS7Type);
property ValBit[pval : pointer; BitIndex : integer] : boolean read GetBit write SetBit;
property ValInt[pval : pointer] : smallint read GetInt write SetInt;
property ValDInt[pval : pointer] : longint read GetDInt write SetDInt;
property ValWord[pval : pointer] : word read GetWord write SetWord;
property ValDWord[pval : pointer] : longword read GetDWord write SetDWord;
property ValReal[pval : pointer] : single read GetReal write SetReal;
property ValDateTime[pval : pointer] : TDateTime read GetDateTime write SetDateTime;
end;
Var
S7 : TS7Helper;
procedure TS7Helper.SetInt(pval: pointer; const Value: smallint);
Var
BW : packed array[0..1] of byte absolute value;
begin
pbyte(NativeInt(pval)+1)^:=BW[0];
pbyte(pval)^:=BW[1];
end;
(I cut some code, so don't look for the implementation clause, etc... the helper class is compiling ok....)
Trivially, I want to invoke the SetInt property (as stated in the class documentation)... but the following code gives me an error "Cannot access private symbol TS7Helper.SetInt".
S7.SetInt(#MySnap7Array[i * 2], gaPlcDataScrittura[i]);
What am I doing wrong ?
SetInt and GetInt is the getter and setter for ValInt property as stated in the definition of ValInt. So you shoud use S7.ValInt like
S7.ValInt[#MySnap7Array[i * 2]] := gaPlcDataScrittura[i];
In Delphi,
A private member is invisible outside of the unit or program where its class is declared.
Note: "program" refers to files starting with program keyword (usually the .dpr file), not to the project as a whole.
So you can only call TS7Helper.SetInt from the same unit where TS7Helper class is declared.
Otherwise, #DmLam answer is the correct way to solve it.
I would like to call SPSS 'backend' from Delphi. There is a DLL that I can use (it seems): SPSSio64.DLL. But I can not find the interface definition.
What I have found is an example in PowerBasic:
Read and write SPSS sav files
DECLARE FUNCTION spssOpenRead LIB "spssio32.dll" ALIAS "spssOpenRead#8" (BYVAL fileName AS STRING, BYREF hHandle AS LONG) AS LONG
DECLARE FUNCTION spssCloseRead LIB "spssio32.dll" ALIAS "spssCloseRead#4" (BYVAL hHandle AS LONG) AS LONG
Since I only need functions to read and write a file (all the processing will be done via a syntax in that file), I thought that this example might be enough to deduce how to call equivalent functions from Delphi.
So the question is: how would these declarations be in Delphi (64-bit)?
Based on the SPSS 14.0 for Windows Developer's Guide, and PowerBasic documentation, try something like this:
32-bit:
// spssio32.dll exports both 'spssOpenRead' and 'spssOpenRead#8', which are the same function...
function spssOpenRead(filename: PAnsiChar; var hHandle: Integer): Integer; stdcall; external 'spssio32.dll' {name 'spssOpenRead#8'};
// spssio32.dll exports both 'spssCloseRead' and 'spssCloseRead#4', which are the same function...
function spssCloseRead(hHandle: Integer): Integer; stdcall; external 'spssio32.dll' {name 'spssCloseRead#4'};
64-bit:
// I can't find a copy of spssio64.dll to download, so I can't verify the exported names. Adjust if needed..
function spssOpenRead(filename: PAnsiChar; var hHandle: Integer): Integer; stdcall; external 'spssio64.dll' {name 'spssOpenRead#16'};
function spssCloseRead(hHandle: Integer): Integer; stdcall; external 'spssio64.dll' {name 'spssCloseRead#8'};
For the record, this works:
function LoadDLL(DLLname : string) : Uint64;
var
em : TArithmeticExceptionMask;
begin
em:=GetExceptionmask;
SetExceptionmask(em+[exInvalidOp,exZeroDivide,exOverflow,exUnderflow]);
result:=LoadLibrary(PwideChar(DLLname));
SetExceptionmask(em);
end;
function RunSPSSio(filename : string; instructions : Tinstructions) : boolean;
// This will only read SAV files, not SPS files !
type
TspssOpenRead = function (filename: PAnsiChar; var hHandle: Uint64): Integer;
TspssCloseRead = function(hHandle: Uint64): Integer;
TspssGetInterfaceEncoding = function(hHandle : Uint64): Integer;
TspssSetInterfaceEncoding = function(encoding : integer; hHandle : Uint64): Integer;
const
SPSS_ENCODING_UTF8 = 1;
var
p : integer;
spssOpenRead : TspssOpenRead;
spssCloseRead : TspssCloseRead;
spssGetIFencoding : TspssGetInterfaceEncoding;
spssSetIFencoding : TspssSetInterfaceEncoding;
DLLhandle : Uint64;
fileref : PANSIchar;
begin
result:=false;
DLLhandle:=LoadDLL('C:\SPSS\spssio64.dll'); // hardcoded
if DLLhandle=0
then begin p:=GetLastError();
report('DLL load error '+IntToStr(p));
exit;
end;
try
#SPSSopenRead:=getProcAddress(DLLhandle,'spssOpenRead');
#SPSScloseRead:=getProcAddress(DLLhandle,'spssCloseRead');
#SPSSsetIFencoding:=getProcAddress(DLLhandle,'spssSetInterfaceEncoding');
SPSSsetIFencoding(SPSS_ENCODING_UTF8,DLLhandle);
fileref:=PANSIchar(ANSIstring(filename));
p:=SPSSopenRead(fileref,DLLhandle);
if p<>0
then report('*** SPSSio error '+IntToStr(p))
else begin // SPSS database interactions here
result:=SPSScloseRead(DLLhandle)=0;
end;
finally
freeLibrary(DLLhandle);
end;
end;
I need to call functions from an external DLL in Delphi, the function have defined the bytes of calling, how should I call them, on declaring them in Delphi, it shows syntax error that it expected ; instead got #
function _imp_Com#32(a1: INT64; a2: Pointer; a3: INT64; a4: Pointer;
a5: INT64; a6: Pointer; a7: Pointer; a8: INT64): INT64 cdecl stdcall;external 'imp.dll';
function _imp_Decom#56(a1_compbuf: Pointer; a2_clen: INT64;
a3_out: Pointer; a4_outlen: INT64; a5_crcflag: INT64; a5u: INT64;
a6_verb: INT64; a7_dict: Pointer; a8_dictsize: INT64; a9_cb: Pointer;
a10: INT64; a11: Pointer = 0; a12: INT64 = 0; a14: INT64 = 0)
: INT64 cdecl stdcall;external 'imp.dll';
You can't use that in the name so you need to import the function using a valid identifier. Like this:
function imp_Com(...): Int64; stdcall; external 'imp.dll' name '_imp_Com#32';
A function can't be both cdecl and stdcall. Not sure what that was about in your code. Based on the name decoration, these functions are stdcall.
I have a delphi project that works fine in delphi 6, but when I upgraded to XE it does not work.
I know it has to do with the new unicode type in delphi XE, I have tried changing the definition of the parameter from pchar to pansichar, ansichar but no succes so far. Can anyone see what i have done wrong?
My project calls a function in an third party dll that is defined like this:
type
PPChar = array of PChar;
{$EXTERNALSYM gsapi_init_with_args}
function gsapi_init_with_args(pinstance:Pgs_main_instance;argc:integer;argv:PPChar):integer; stdcall;
Implementation
{$EXTERNALSYM gsapi_init_with_args}
function gsapi_init_with_args; stdcall; external gsdll32 name 'gsapi_init_with_args';
And here is how I call the function.
procedure PSPDF(input : string; output:string);
var
code:integer;
instance:Pointer;
argv:array of PAnsiChar;
begin
new(instance);
setlength(argv,10);
code:=gsapi_new_instance(#instance,nil);
if code<>0 then
begin
raise Exception.Create('Impossible to open an instance of ghostscript. Error code: '+IntToStr(code));
end;
try
argv[0] := PAnsiChar('ps2pdf');
argv[1] := PAnsiChar('-dNOPAUSE');
argv[2] := PAnsiChar('-dBATCH');
argv[3] := PAnsiChar('-dSAFER');
argv[4] := PAnsiChar('-sDEVICE=pdfwrite');
argv[5] := PAnsiChar(PAnsiString('-sOutputFile='+output));
argv[6] := PAnsiChar('-c');
argv[7] := PAnsiChar('.setpdfwrite');
argv[8] := PAnsiChar('-f');
argv[9] := PAnsiChar(PAnsiString(input));
gsapi_new_instance(instance, nil);
code := gsapi_init_with_args(instance,length(argv),#argv[0]);
if code<0 then
raise Exception.Create('ERROR: init_args: '+IntToStr(code));
gsapi_exit(instance);
gsapi_delete_instance(instance);
finally
end;
end;
I will very much appreciate if someone can help me out.
Mario.
Changing PChar to PAnsiChar is the correct thing to do, however array of ... is not safe to use in DLL function parameters and was the wrong thing to use even in your Delphi 6 project. After looking at the official Ghostscript documentation, try this instead, in both projects:
interface
type
PPAnsiChar = ^PAnsiChar;
{$NODEFINE PPAnsiChar}
function gsapi_new_instance(var pinstance: Pointer; caller_handle: Pointer): Integer; stdcall;
{$EXTERNALSYM gsapi_new_instance}
procedure gsapi_delete_instance(instance: Pointer); stdcall;
{$EXTERNALSYM gsapi_delete_instance}
function gsapi_init_with_args(instance: Pointer; argc: Integer; argv: PPAnsiChar): Integer; stdcall;
{$EXTERNALSYM gsapi_init_with_args}
function gsapi_exit(instance: Pointer): Integer; stdcall;
{$EXTERNALSYM gsapi_exit}
implementation
function gsapi_new_instance; external gsdll32 name 'gsapi_new_instance';
procedure gsapi_delete_instance; external gsdll32 name 'gsapi_delete_instance';
function gsapi_init_with_args; external gsdll32 name 'gsapi_init_with_args';
function gsapi_exit; external gsdll32 name 'gsapi_exit';
.
procedure PSPDF(input : AnsiString; output: AnsiString);
var
code:integer;
instance: Pointer;
argv: array of PAnsiChar;
begin
code := gsapi_new_instance(instance, nil);
if code < 0 then
raise Exception.Create('Impossible to open an instance of ghostscript. Error code: '+IntToStr(code));
try
SetLength(argv, 10);
argv[0] := PAnsiChar('ps2pdf');
argv[1] := PAnsiChar('-dNOPAUSE');
argv[2] := PAnsiChar('-dBATCH');
argv[3] := PAnsiChar('-dSAFER');
argv[4] := PAnsiChar('-sDEVICE=pdfwrite');
argv[5] := PAnsiChar('-sOutputFile='+output);
argv[6] := PAnsiChar('-c');
argv[7] := PAnsiChar('.setpdfwrite');
argv[8] := PAnsiChar('-f');
argv[9] := PAnsiChar(input);
code := gsapi_init_with_args(instance, Length(argv), #argv[0]);
if code < 0 then
raise Exception.Create('ERROR: init_args: '+IntToStr(code));
try
...
finally
gsapi_exit(instance);
end;
finally
gsapi_delete_instance(instance);
end;
end;
Update: here is a corrected version of the gsapi.pas unit that should work in both Delphi versions:
// Copyright (c) 2001-2002 Alessandro Briosi
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use, copy,
// modify, merge, publish, distribute, sublicense, and/or sell copies
// of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//
// This software was written by Alessandro Briosi with the
// assistance of Russell Lang, as an example of how the
// Ghostscript DLL may be used Delphi.
//
unit gsapi;
interface
uses
Windows;
// {$HPPEMIT '#include <iminst.h>'}
const
gsdll32 = 'gsdll32.dll';
STDIN_BUF_SIZE = 128;
{$EXTERNALSYM STDIN_BUF_SIZE}
STDOUT_BUF_SIZE = 128;
{$EXTERNALSYM STDOUT_BUF_SIZE}
STDERR_BUF_SIZE = 128;
{$EXTERNALSYM STDERR_BUF_SIZE}
DISPLAY_VERSION_MAJOR = 1;
{$EXTERNALSYM DISPLAY_VERSION_MAJOR}
DISPLAY_VERSION_MINOR = 0;
{$EXTERNALSYM DISPLAY_VERSION_MINOR}
//* Define the color space alternatives */
DISPLAY_COLORS_NATIVE = $01;
{$EXTERNALSYM DISPLAY_COLORS_NATIVE}
DISPLAY_COLORS_GRAY = $02;
{$EXTERNALSYM DISPLAY_COLORS_GRAY}
DISPLAY_COLORS_RGB = $04;
{$EXTERNALSYM DISPLAY_COLORS_RGB}
DISPLAY_COLORS_CMYK = $08;
{$EXTERNALSYM DISPLAY_COLORS_CMYK}
DISPLAY_COLORS_MASK = $000f;
{$EXTERNALSYM DISPLAY_COLORS_MASK}
//* Define whether alpha information, or an extra unused bytes is included */
//* DISPLAY_ALPHA_FIRST and DISPLAY_ALPHA_LAST are not implemented */
DISPLAY_ALPHA_NONE = $00;
{$EXTERNALSYM DISPLAY_ALPHA_NONE}
DISPLAY_ALPHA_FIRST = $10;
{$EXTERNALSYM DISPLAY_ALPHA_FIRST}
DISPLAY_ALPHA_LAST = $20;
{$EXTERNALSYM DISPLAY_ALPHA_LAST}
DISPLAY_UNUSED_FIRST = $40; //* e.g. Mac xRGB */
{$EXTERNALSYM DISPLAY_UNUSED_FIRST}
DISPLAY_UNUSED_LAST = $80; //* e.g. Windows BGRx */
{$EXTERNALSYM DISPLAY_UNUSED_LAST}
DISPLAY_ALPHA_MASK = $0070;
{$EXTERNALSYM DISPLAY_ALPHA_MASK}
// * Define the depth per component for DISPLAY_COLORS_GRAY,
// * DISPLAY_COLORS_RGB and DISPLAY_COLORS_CMYK,
// * or the depth per pixel for DISPLAY_COLORS_NATIVE
// * DISPLAY_DEPTH_2 and DISPLAY_DEPTH_12 have not been tested.
// *
DISPLAY_DEPTH_1 = $0100;
{$EXTERNALSYM DISPLAY_DEPTH_1}
DISPLAY_DEPTH_2 = $0200;
{$EXTERNALSYM DISPLAY_DEPTH_2}
DISPLAY_DEPTH_4 = $0400;
{$EXTERNALSYM DISPLAY_DEPTH_4}
DISPLAY_DEPTH_8 = $0800;
{$EXTERNALSYM DISPLAY_DEPTH_8}
DISPLAY_DEPTH_12 = $1000;
{$EXTERNALSYM DISPLAY_DEPTH_12}
DISPLAY_DEPTH_16 = $2000;
{$EXTERNALSYM DISPLAY_DEPTH_16}
//* unused (1<<14) */
//* unused (1<<15) */
DISPLAY_DEPTH_MASK = $ff00;
{$EXTERNALSYM DISPLAY_DEPTH_MASK}
// * Define whether Red/Cyan should come first,
// * or whether Blue/Black should come first
// */
DISPLAY_BIGENDIAN = $00000; //* Red/Cyan first */
{$EXTERNALSYM DISPLAY_BIGENDIAN}
DISPLAY_LITTLEENDIAN = $10000; //* Blue/Black first */
{$EXTERNALSYM DISPLAY_LITTLEENDIAN}
DISPLAY_ENDIAN_MASK = $00010000;
{$EXTERNALSYM DISPLAY_ENDIAN_MASK}
//* Define whether the raster starts at the top or bottom of the bitmap */
DISPLAY_TOPFIRST = $00000; //* Unix, Mac */
{$EXTERNALSYM DISPLAY_TOPFIRST}
DISPLAY_BOTTOMFIRST = $20000; //* Windows */
{$EXTERNALSYM DISPLAY_BOTTOMFIRST}
DISPLAY_FIRSTROW_MASK = $00020000;
{$EXTERNALSYM DISPLAY_FIRSTROW_MASK}
//* Define whether packing RGB in 16-bits should use 555
// * or 565 (extra bit for green)
// */
DISPLAY_NATIVE_555 = $00000;
{$EXTERNALSYM DISPLAY_NATIVE_555}
DISPLAY_NATIVE_565 = $40000;
{$EXTERNALSYM DISPLAY_NATIVE_565}
DISPLAY_555_MASK = $00040000;
{$EXTERNALSYM DISPLAY_555_MASK}
type
TGSAPIrevision = record
product: PAnsiChar;
copyright: PAnsiChar;
revision: Longint;
revisiondat: Longint;
end;
TStdioFunction = function(caller_handle: Pointer; buf: PAnsiChar; len: Integer): Integer; stdcall;
TPollFunction = function(caller_handle: Pointer): Integer; stdcall;
TDisplayEvent = function(handle: Pointer; device: Pointer): Integer; cdecl;
TDisplayPreResizeEvent = function(handle: Pointer; device: Pointer;
width: Integer; height: Integer; raster: Integer; format: UINT): Integer; cdecl;
TDisplayResizeEvent = function(handle: Pointer; device: Pointer;
width: Integer; height: Integer; raster: Integer; format: UINT; pimage: PAnsiChar): Integer; cdecl;
TDisplayPageEvent = function(handle: Pointer; device: Pointer; copies: Integer; flush: Integer): Integer; cdecl;
TDisplayUpdateEvent = function(handle: Pointer; device: Pointer; x: Integer; y: Integer; w: Integer; h: Integer): Integer; cdecl;
TDisplayMemAlloc = procedure(handle: Pointer; device: Pointer; size: ulong); cdecl;
TDisplayMemFree = function(handle: Pointer; device: Pointer; mem: Pointer): Integer; cdecl;
TDisplayCallback = record
size: Integer;
version_major: Integer;
version_minor: Integer;
// New device has been opened */
// This is the first event from this device. */
display_open: TDisplayEvent;
// Device is about to be closed. */
// Device will not be closed until this function returns. */
display_preclose: TDisplayEvent;
// Device has been closed. */
// This is the last event from this device. */
display_close: TDisplayEvent;
// Device is about to be resized. */
// Resize will only occur if this function returns 0. */
// raster is byte count of a row. */
display_presize: TDisplayPreResizeEvent;
// Device has been resized. */
// New pointer to raster returned in pimage */
display_size: TDisplayResizeEvent;
// flushpage */
display_sync: TDisplayEvent;
// showpage */
// If you want to pause on showpage, then don't return immediately */
display_page: TDisplayPageEvent;
// Notify the caller whenever a portion of the raster is updated. */
// This can be used for cooperative multitasking or for
// progressive update of the display.
// This function pointer may be set to NULL if not required.
//
display_update: TDisplayUpdateEvent;
// Allocate memory for bitmap */
// This is provided in case you need to create memory in a special
// way, e.g. shared. If this is NULL, the Ghostscript memory device
// allocates the bitmap. This will only called to allocate the
// image buffer. The first row will be placed at the address
// returned by display_memalloc.
//
display_memalloc: TDisplayMemAlloc;
// Free memory for bitmap */
// If this is NULL, the Ghostscript memory device will free the bitmap */
display_memfree: TDisplayMemFree;
end;
PPAnsiChar = ^PAnsiChar;
{$NODEFINE PPAnsiChar}
function gsapi_revision(var pr: TGSAPIrevision; len: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_revision}
function gsapi_new_instance(var pinstance: Pointer; caller_handle: Pointer): Integer; stdcall;
{$EXTERNALSYM gsapi_new_instance}
procedure gsapi_delete_instance(pinstance: Pointer); stdcall;
{$EXTERNALSYM gsapi_delete_instance}
function gsapi_set_stdio(pinstance: Pointer;
stdin_fn: TStdioFunction; stdout_fn: TStdioFunction;
stderr_fn: TStdioFunction): Integer; stdcall;
{$EXTERNALSYM gsapi_set_stdio}
function gsapi_set_poll(pinstance: Pointer; poll_fn: TPollFunction): Integer; stdcall;
{$EXTERNALSYM gsapi_set_poll}
function gsapi_set_display_callback(pinstance: Pointer; const callback: TDisplayCallback): Integer; stdcall;
{$EXTERNALSYM gsapi_set_display_callback}
function gsapi_init_with_args(pinstance: Pointer; argc: Integer; argv: PPAnsiChar): Integer; stdcall;
{$EXTERNALSYM gsapi_init_with_args}
function gsapi_run_string_begin(pinstance: Pointer; user_errors: Integer; var pexit_code: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_run_string_begin}
function gsapi_run_string_continue(pinstance: Pointer; str: PAnsiChar; len: Integer; user_errors: Integer; var pexit_code: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_run_string_continue}
function gsapi_run_string_end(pinstance: Pointer; user_errors: Integer; var pexit_code: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_run_string_end}
function gsapi_run_string_with_length(pinstance: Pointer; str: PAnsiChar; len: Integer; user_errors: Integer; var pexit_code: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_run_string_with_length}
function gsapi_run_string(pinstance: Pointer; str: PAnsiChar; user_errors: Integer; var pexit_code: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_run_string}
function gsapi_run_file(pinstance: Pointer; file_name: PAnsiChar; user_errors: Integer; var pexit_code: Integer): Integer; stdcall;
{$EXTERNALSYM gsapi_run_file}
function gsapi_exit(pinstance: Pointer): Integer; stdcall;
{$EXTERNALSYM gsapi_exit}
implementation
function gsapi_revision; external gsdll32 name 'gsapi_revision';
function gsapi_new_instance; external gsdll32 name 'gsapi_new_instance';
procedure gsapi_delete_instance; external gsdll32 name 'gsapi_delete_instance';
function gsapi_set_stdio; external gsdll32 name 'gsapi_set_stdio';
function gsapi_set_poll; external gsdll32 name 'gsapi_set_poll';
function gsapi_set_display_callback; external gsdll32 name 'gsapi_set_display_callback';
function gsapi_init_with_args; external gsdll32 name 'gsapi_init_with_args';
function gsapi_run_string_begin; external gsdll32 name 'gsapi_run_string_begin';
function gsapi_run_string_continue; external gsdll32 name 'gsapi_run_string_continue';
function gsapi_run_string_end; external gsdll32 name 'gsapi_run_string_end';
function gsapi_run_string_with_length; external gsdll32 name 'gsapi_run_string_with_length';
function gsapi_run_string; external gsdll32 name 'gsapi_run_string';
function gsapi_run_file; external gsdll32 name 'gsapi_run_file';
function gsapi_exit; external gsdll32 name 'gsapi_exit';
end.
The old Delphi 6 PChar is PAnsiChar on Unicode Delphi (2009+), so everything should work if you change all the PChar references to PAnsiChar.
(Including your Pgs_main_instance declaration, if any PChar is over there)
type
PPAnsiChar = array of PAnsiChar;
{$EXTERNALSYM gsapi_init_with_args}
function gsapi_init_with_args(pinstance: Pgs_main_instance;
argc: Integer; argv:PPAnsiChar): Integer; stdcall;
implementation
function gsapi_init_with_args(pinstance: Pgs_main_instance;
argc: Integer; argv:PPAnsiChar): Integer;
external gsdll32 name 'gsapi_init_with_args';
Calling code:
var
argv:PPAnsiChar;
instance: Pointer;
begin
new(instance); //how many bytes, this really doesn't make sense with a untyped pointer!
setlength(argv, 4);
argv[0] := PAnsiChar('ps2pdf');
argv[1] := PAnsiChar('-dNOPAUSE');
argv[2] := PAnsiChar('-dBATCH');
argv[3] := PAnsiChar('-dSAFER');
gsapi_init_with_args(instance, Length(argv), argv);
end;
To understand what's new in Unicode, I advise you to read the Delphi and Unicode white paper from Marco Cantù.