We help IT Professionals succeed at work.

Delphi and C-dll (written in visual C++)

phv
phv asked
on
1,147 Views
Last Modified: 2008-02-01
I'm having troubles to use some of the functions of a C-dll.
I have to pass a record to the function.
This is the function in the C-dll :
INT WINAPI SCP_send ( INT, USHORT, char *);
The 3rd parameter should be a record, so I use a pointer to
the record and pass this pointer to the C-function. The result is that the C-funtion returns me a neg. number, which probably means that it has a bad parameter (can't be anything else then the record pointer) I also used the PChar declaration and even Typecasting -> still nothing...
Who can help me ?
Comment
Watch Question

Commented:
char* usually points to a null terminated sequence of characters.

Also watch the byte offset. If you need to point to a record
then the byte offset in C++ is often different than Delphi.

Can you show me what record you need to pass ?

John.

Commented:
Take a look at the JEDI knight page.  They're translating C headers into Delphi, and have a tutorial on how to do it.  It worked for me! (Sorry - don't know the URL, but I found it at Excite)

Bryan
Commented:
Unlock this solution and get a sample of our free trial.
(No credit card required)
UNLOCK SOLUTION

Commented:
I forgot, you could also declare the buffer as a pointer and e.g. use this kinda code:

var AStruct : TMyStruct;
begin
  FillStruct(AStruct);
  SCP_Send(1, 1, @AStruct);
end;

Slash/d003303
phv

Author

Commented:
Thanks guys for the support, but most of the things you told me I've already tried except for the proposal of John about the byte offset. I think my problem is going that way. John :
here is the program and de corresponding C-header which is killing me... :(


/***************************************************************************
 *                                                                         *
 *  PROGRAM     : FDLdemo.c                                                *
 *                                                                         *
 *  PURPOSE     : FDL Demo Program for Windows                             *
 *                                                                         *
 *  This demo Program realizes a Sample Communication to a FDL Partner     *                                                                     *
 *  Station.                                                               *
 *                                                                         *
 *                                                                         *
 *  FDL Demo Program Copyright (c) SIEMENS AG 1994-1998                    *
 *                                                                         *
 ***************************************************************************
 *
 * The following comments are inserted by the source code control tool
 *
 * $Workfile:   FDLdemo.c  $
 * $Date:   Nov 11 1997 10:42:36  $
 * $Modtime:   Nov 11 1997 10:15:36  $
 * $Revision:   1.6  $
 *
 ***************************************************************************/

#include <malloc.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include "fdl_rb.h"
#include "FDLdemo.h"
#include "wintool.h"
#include "resource.h"

#pragma pack (1)


/*********************** Version String ***********************************/

// This string appears in the about box. See handling of the IDM_ABOUT
//
#define FDL_DEMO_PROGRAMM_VERSION  " Version 2.0 ($Revision:   1.6  $) "



/**************************************************************************/
/*                          DEFINES                                       */
/**************************************************************************/

#define LEN_SAP_ACTIVATE        sizeof(struct fdl_sap)
#define LEN_BUS_PARAMETER       sizeof(struct bus_parameter_block)
#define NETTO_DATA_OFFSET       12
#define FDL_ERROR              -1     /* return codes of functions        */
#define OK                      0
#define NOT_OPENED             -1     /* SCP not opened, invalid          */
#define SST_NOT_USED            0     /* SAP State: not activated         */
#define SST_ACTIVATED           1     /* SAP State: not activated         */



/**************************************************************************/
/*                      GLOBAL VARIABLES                                  */
/**************************************************************************/
HANDLE          hInst;
HWND            hWnd;
INT             hdlg;

int             ssap;
int             rsap;
BYTE            remote_address;
BYTE            cp;


char            title[80];

int             handle=NOT_OPENED;     /* device handle for SCP_open calls */
int             sapState = SST_NOT_USED; /* state of the local SAP */
int             cmdshow;

unsigned char   ts;
int             len;


BYTE            servclass=low;              /* priority */
fdl_rb          fdl_rqb;                    /* request block */
fdl_rb          fdl_recv_rb;                /* receive request block */

fdl_rb          *rqb = &fdl_rqb;            /* universal pointer to request block */
fdl_rb          *recv_rb = &fdl_recv_rb;    /* pointer to received request block */


int             counter=0;

int             sda_running=0;           /* indicates continuous data transfer */



/**************************************************************************/
/*                  FUNCTION FORWARD DECLARATION                          */
/**************************************************************************/
void                dispatch_sinec();
BOOL                dispatch_command(WPARAM);
LRESULT CALLBACK    FDLWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
int                 fdl_close(HWND hWnd);
void                HandleSinecIndication();
void                HandleSinecConfirmation();
void                HandleSinecRequest();



/****************************************************************************
 *                                                                          *
 *  FUNCTION   : WinMain                                                    *
 *                                                                          *
 *  PURPOSE    : Creates the main app. window, calls an initialization      *
 *               function and enters the message loop.                      *
 *                                                                          *
 ****************************************************************************/
int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HWND        hwnd;
    WNDCLASS    WndClass;
    MSG         msg;



    fcolor=STDFCOL; /* set colors */
    bcolor=STDBCOL;


    /* Register main window class if this is the first instance of the app. */
    if (!hPrevInstance) {
        WndClass.style         = CS_HREDRAW | CS_VREDRAW;
        WndClass.lpfnWndProc   = (WNDPROC)FDLWndProc;
        WndClass.cbClsExtra    = 0;
        WndClass.cbWndExtra    = 0;
        WndClass.hInstance     = hInstance;
        WndClass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
        WndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
        WndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
        WndClass.lpszMenuName  = (LPSTR) "L2Menu";
        WndClass.lpszClassName = (LPSTR) "FDLdemo";

        RegisterClass (&WndClass);
        }


    hInst = hInstance;
    cmdshow=nCmdShow;


    cp = 1;
    ssap = rsap = 0;
    remote_address = 0;
    wsprintf(title,"FDL Demo Program (cp = %d remote_address = %d rem_sap = %d)", cp, remote_address, rsap);

    hwnd = CreateWindow ("FDLdemo", title, WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         (HWND) NULL, NULL, hInstance, (LPSTR) NULL);

    if (!hwnd) return 0;

    ShowWindow (hwnd, nCmdShow);
    UpdateWindow (hwnd);


    WinPrintf(hwnd,"Remote address = %d", remote_address);
    WinPrintf(hwnd,"Local and remote Sap = %d", ssap);

    WinPrintf(hwnd,"FDL demo program, please choose FDL-Interface -> SCP_OPEN");



    while (GetMessage(&msg, NULL, 0, 0))
        {
        TranslateMessage (&msg);
        DispatchMessage (&msg);
        }

    return msg.wParam;
}




/*****************************************************************************
 *                                                                           *
 *  FUNCTION   : FDLWndProc (hwnd, message, wParam, lParam)                  *
 *                                                                           *
 *  PURPOSE    : Window function for the main app. window. Processes all the *
 *               menu selections and other messages.                         *
 *                                                                           *
 *****************************************************************************/
LRESULT CALLBACK FDLWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

    hWnd = hwnd;

    switch (message) {
        case WM_COMMAND:
            if (dispatch_command(wParam))
                return 0;
            break;

        case WM_PAINT:
            DoWmPaint(hWnd);
            return 0;

        case WM_KEYDOWN:
            /* stop data transfer */
            sda_running = 0;
            break;

        case WM_SINEC:
            dispatch_sinec();   /* dispatch SINEC Message */
            return 0;


        case WM_DESTROY:
            if (handle!=NOT_OPENED) fdl_close(hWnd);
            PostQuitMessage (0);
            return 0;
        }
    return DefWindowProc(hWnd, message, wParam, lParam);
}







/*****************************************************************************/
/*                                                                           */
/*  fdl_read                                                                 */
/*                                                                           */
/*  polls SCP_receive                                                        */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
int fdl_read(HWND hWnd,fdl_rb *rb) {

    int     ret;
    SHORT   data_len;

    if (handle == NOT_OPENED) {
        WinPrintf(hWnd,"SCP_open() not yet opened");
        return(-1);
        }

    ret = SCP_receive(handle,0, &data_len, sizeof(fdl_rb), (char *)rb); // asynchronous (polling) mode

    return (ret);
}


/**************************************************************************/
/*                                                                        */
/*   fdl_write                                                            */
/*                                                                        */
/*   sends request block to communication interface                       */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
int fdl_write(HWND hWnd,fdl_rb *rb) {

    int ret;
    char errtxt[80];


    if (handle == NOT_OPENED) {

        WinPrintf(hWnd,"SCP_open() not yet opened");
        return(-1);
        }

    ret = SCP_send(handle,(USHORT) sizeof(fdl_rb), (CHAR *)rb);

    // analyzing return code (never forget!)
    switch (ret) {

        case 0: wsprintf(errtxt,"request (serv code %d) successfully passed to CP",
                         rb->application_block.service.code);
                break;

        case -1:wsprintf(errtxt,"SCP_send error ");
                break;

        default:wsprintf(errtxt,"unknown errorcode %d ?",ret);
                break;
        } /* end switch ret */

    WinPrintf(hWnd,"SCP_send:%s",errtxt);

    return(ret);
    }


/**************************************************************************/
/*                                                                        */
/*  fdl_open(HWND)                                                        */
/*                                                                        */
/*  function to intialize communication system                            */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
int fdl_open(HWND hWnd)
{
    char errtxt[80];
    int  retValue;
    char *cpPathPtr;


    if (handle != NOT_OPENED) {
        WinPrintf(hWnd,"SCP already opened");
        return(handle);
    }

    cp = 1;
    ssap = rsap = 0;
    remote_address = 0;

    if (ReadBox("Enter no. of CP (1 or 2)!", &retValue)) {
      cp = (BYTE)retValue;
      // check input, set valid values: 1, 2
      if (cp < 1)
        cp = 1;
      else if (cp > 2)
        cp = 2;
      wsprintf(title,"FDLdemo Program (cp = %d remote_address = %d rem_sap = %d)", cp, remote_address, rsap);
      SetWindowText(hWnd, title);
    }
    else
      return(handle);        // abort  ---> EXIT

    if (cp == 1)
       cpPathPtr="/CP_L2_1:/FLC";
    else
      cpPathPtr="/CP_L2_2:/FLC";


    if (ReadBox("Enter address of remote station!", &retValue)) {
        remote_address = (BYTE)retValue;
        wsprintf(title,"FDLdemo Program (cp = %d remote_address = %d rem_sap = %d)", cp, remote_address, rsap);
        SetWindowText(hWnd, title);
    }
    else
        return(handle);        // abort  ---> EXIT


    ssap = rsap  = 0;
    if (ReadBox("Enter no. of SAP (remote SAP = local SAP)!", &retValue)) {
        ssap = (BYTE)retValue;
        rsap = (BYTE)retValue;
        wsprintf(title,"FDLdemo Program (cp = %d remote_address = %d rem_sap = %d)", cp, remote_address, rsap);
        SetWindowText(hWnd, title);
    }
    else
        return(handle);        // abort  ---> EXIT

    // open cp channel

    handle=SCP_open(cpPathPtr);

    switch (handle) {

        case -1:wsprintf(errtxt,"error opening driver, errorcode : %#04x",SCP_get_errno() );
                break;

        default:wsprintf(errtxt,"communication system initialisation o.k.");
                break;
        } // end switch

    if (handle >= 0) SetSinecHWnd(handle,hWnd); // to enable WM_SINEC messages for main window

    WinPrintf(hWnd,"SCP_open handle=%d,%s",handle,errtxt);

    if (handle >= 0) WinPrintf(hWnd,"Please choose Other Services -> SAP ACTIVATE");

    return(handle);

} // end of fdl_open()



/**************************************************************************/
/*                                                                        */
/*  fdl_close                                                             */
/*                                                                        */
/*  close communication system                                            */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
int fdl_close(HWND hWnd) {

    int ret;

    if (handle==NOT_OPENED) {

        WinPrintf(hWnd,"SCP_open() not yet opened");
        return(-1);
        }

    ret = SCP_close(handle);

    switch (ret) {

        case 0:
          WinPrintf(hWnd,"FDL successfully closed, o.k.");
          handle   = NOT_OPENED;           // to mark handle as 'not opened'
          sapState = SST_NOT_USED;         //
          cp = 0;
          ssap = rsap = 0;
          remote_address = 0;
          wsprintf(title,"FDLdemo Program (cp = %d remote_address = %d rem_sap = %d)", cp, remote_address, rsap);
          SetWindowText(hWnd, title);
          break;

        case -1:
          WinPrintf(hWnd,"FDL: Error in SCP_close");
          break;

        default:
          WinPrintf(hWnd,"wrong return code at SCP_close()");
          break;
    } // end switch ret


    return (ret);
    }


/**************************************************************************/
/*                                                                        */
/*  build_head                                                            */
/*                                                                        */
/*                                                                        */
/*  fills header parameters                                               */
/*                                                                        */
/**************************************************************************/
void build_head (fdl_rb *rb) {

    rb -> rb2_header.length           = 80;
    rb -> rb2_header.user             = 0; /* use this for local block identifications */
    rb -> rb2_header.rb_type          = 2;
    rb -> rb2_header.priority         = low;
    rb -> rb2_header.subsystem        = FLC_Subsys; /* for Layer2 */
    rb -> rb2_header.opcode           = request;
    rb -> rb2_header.response         = 0;


    rb -> rb2_header.fill_length_1    = 246;
    rb -> rb2_header.seg_length_1     = 255;
    rb -> rb2_header.offset_1         = 80;

    rb -> rb2_header.fill_length_2    = 0;
    rb -> rb2_header.seg_length_2     = 0;
    rb -> rb2_header.offset_2         = 0;

    rb -> application_block.opcode    = request;
    rb -> application_block.subsystem = FLC_Subsys;
    }


/**********************************************************************/
/*  D e s c r i p t i o n :                                           */
/*                                                                    */
/*  build request_block for sap_activate for all services             */
/**********************************************************************/
void build_rqb_sap_activate (fdl_rb *rb,BYTE sap_nr) {

    struct fdl_sap * sptr;

    build_head(rb);

    // fill header params
    rb -> rb2_header.seg_length_1        = LEN_SAP_ACTIVATE;
    rb -> rb2_header.offset_1            = 80;
    rb -> rb2_header.fill_length_1       = LEN_SAP_ACTIVATE;

    rb -> rb2_header.seg_length_2        = 0;
    rb -> rb2_header.fill_length_2       = 0;
    rb -> rb2_header.offset_2            = 0;

    rb -> application_block.service.code = sap_activate;
    rb -> application_block.dsap         = sap_nr;
    rb -> application_block.ssap         = 0;


    sptr = (struct fdl_sap *) &rb->user_data_1;

    sptr->max_l_sdu_length               = 246;
    sptr->access_sap                     = ALL;     // no reservations
    sptr->access_station                 = ALL;     // no reservations
    sptr->sda                            = BOTH_ROLES;
    sptr->sdn                            = BOTH_ROLES;
    sptr->srd                            = BOTH_ROLES;
    }


/**************************************************************************/
/*                                                                        */
/*  fdl_sap_activate(sap_nr)                                              */
/*                                                                        */
/*  activates Service Access Point for all services                       */
/*  sends only request                                                    */
/*                                                                        */
/**************************************************************************/
int fdl_sap_activate(HWND hWnd,BYTE lsap) {

    int ret;

    // fill request block
    build_rqb_sap_activate(rqb, lsap);

    ret = fdl_write(hWnd, rqb);

    return(ret);
    }


/**********************************************************************/
/*  D e s c r i p t i o n :                                           */
/*                                                                    */
/*  build request_block for await_indication  for this SAP            */
/**********************************************************************/
void build_rqb_await_indication (fdl_rb *rb,BYTE remsap) {

     build_head(rb);

    // fill header params
    rb -> rb2_header.seg_length_1                = 260;
    rb -> rb2_header.offset_1                    = 80;
    rb -> rb2_header.fill_length_1               = 0;

    rb -> rb2_header.seg_length_2                = 0;
    rb -> rb2_header.fill_length_2               = 0;
    rb -> rb2_header.offset_2                    = 0;

    // application block params
    rb -> application_block.service.code         = await_indication;
    rb -> application_block.dsap                 = remsap;
    rb -> application_block.rem_add.segment      = NO_SEGMENT;
    rb -> application_block.serv_class           = low;
    rb -> application_block.receive_l_sdu.length = 255; // maximum length
    rb -> application_block.send_l_sdu.buffer_ptr= 0 ;
    rb -> application_block.send_l_sdu.length    = 1;
    }


/**************************************************************************/
/*                                                                        */
/*  fdl_await_indication                                                  */
/*                                                                        */
/*  sends await_indication block to CP, which will be used as             */
/*  receive-Buffer in case of an indication                               */
/*                                                                        */
/**************************************************************************/
int fdl_await_indication(HWND hWnd) {

    int ret;

    // fill request block
    build_rqb_await_indication(rqb,(BYTE)ssap);

    ret = fdl_write(hWnd,rqb);

    return(ret);
    }



/**************************************************************************/
/*                                                                        */
/*  int get_busparam(HWND hWnd)                                           */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
int get_busparam(HWND hWnd) {

    int ret;

    build_head(rqb);

    rqb -> rb2_header.fill_length_1    = 0;
    rqb -> rb2_header.seg_length_1     = LEN_BUS_PARAMETER;
    rqb -> rb2_header.offset_1         = 80;

    // application block params
    rqb -> application_block.service.code = fdl_read_value;

    ret = fdl_write(hWnd,rqb);

    return(ret);
    }



/**************************************************************************/
/*                                                                        */
/*  fdl_withdraw_indication                                               */
/*                                                                        */
/*                                                                        */
/*  fetch back all await_indication ressources                            */
/*                                                                        */
/**************************************************************************/
int fdl_withdraw_indication(HWND hWnd) {

    int ret;


    // fill request block
    build_rqb_await_indication(rqb,(BYTE)ssap);

    // same request block as 'await_indication, except service.code
    rqb->application_block.service.code = withdraw_indication;

    ret = fdl_write(hWnd,rqb);
    return(ret);
    }


/**********************************************************************/
/*  D e s c r i p t i o n :                                           */
/*                                                                    */
/*  build request_block for send_sda                                  */
/*                                                                    */
/*                                                                    */
/*                                                                    */
/*                                                                    */
/*                                                                    */
/**********************************************************************/
void build_rqb_sda(fdl_rb *rb,BYTE remadd,BYTE remsap,BYTE dataLen) {

    int i;

    build_head(rb);

    rb -> rb2_header.fill_length_1               = dataLen + NETTO_DATA_OFFSET;
    rb -> rb2_header.seg_length_1                = 260;
    rb -> rb2_header.offset_1                    = 80;


    rb -> rb2_header.fill_length_2               = 0;
    rb -> rb2_header.seg_length_2                = 0;
    rb -> rb2_header.offset_2                    = 0;

    rb -> application_block.service.code         = sda;
    rb -> application_block.dsap                 = remsap;
    rb -> application_block.ssap                 = ssap;   // local SAP
    rb -> application_block.rem_add.station      = remadd;
    rb -> application_block.rem_add.segment      = NO_SEGMENT;
    rb -> application_block.serv_class           = servclass;
    rb -> application_block.send_l_sdu.length    = dataLen;
    rb -> user_data_1[0]                         = NETTO_DATA_OFFSET;

    // initialize Data
    for (i = 0; i < dataLen; i++)
        rb -> user_data_1[NETTO_DATA_OFFSET+i] = i;
    }


/**************************************************************************/
/*                                                                        */
/*  fdl_send_sda(HWND,remote station,remote SAP)                          */
/*                                                                        */
/*  sends sda request block      to CP                                    */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
int fdl_send_sda(HWND hWnd,BYTE remadd,BYTE remsap) {

    int         ret;
    static int  dataLen;

    if (handle == NOT_OPENED) {
        WinPrintf(hWnd,"invalid handle, SCP not opened? Choose: FDL-Interface -> SCP_open");
        return(-1);
    }

    if (sapState != SST_ACTIVATED) {
        WinPrintf(hWnd,"local SAP not activated. Choose: Other Services -> SAP ACTIVATE");
        return(-1);
    }

    if (!sda_running) {
        ReadBox("Enter datalength (1-240).", &dataLen);
        if (dataLen > 240 || dataLen < 1) {
           WinPrintf(hWnd,"invalid data length, defaulting to 240");
           dataLen = 240;
        }
    }


    // fill request block
    build_rqb_sda(rqb, remadd, remsap, (BYTE)dataLen);

    ret = fdl_write(hWnd, rqb);

    return(ret);
    }




/**************************************************************************/
/*                                                                        */
/*  dispatch_sinec()                                                      */
/*                                                                        */
/*  central function to catch WM_SINEC Message                            */
/*  WM_SINEC MESSAGE indicates an incoming confirmation or indication     */
/*  this will be fetched fy this function                                 */
/*                                                                        */
/*  in data transfer mode (running==TRUE), a new request block will       */
/*  be passed to the CP as soon as the last request is processed          */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
void dispatch_sinec() {

    int ret;


    ret = fdl_read(hWnd,recv_rb);
    if (ret < 0) return; // in case of error


    switch (recv_rb->application_block.opcode) {

        case indication: // remote data received
            HandleSinecIndication();
            break;

        case confirm:   // local confirmation received
            HandleSinecConfirmation();
            break;

        case request:
            HandleSinecRequest();
            break;

        default:
            WinPrintf(hWnd,"wrong opcode (%d)",recv_rb->application_block.opcode);
        } // end switch opcode


    return;
    }



/**************************************************************************/
/*                                                                        */
/*  void HandleSinecIndication()                                          */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
void HandleSinecIndication() {

    BYTE offset;
    char datastring[100];


            switch (recv_rb->application_block.service.code) {

                case sda:
                        len = recv_rb->application_block.receive_l_sdu.length;
                        WinPrintf(hWnd,"sda indication from St.%u,remote SAP %u, %u bytes",
                        recv_rb->application_block.rem_add.station,recv_rb->application_block.dsap,len);

                        // First byte of user_data_1[] contains offset to user data
                        offset = recv_rb->user_data_1[0];

                        sdump(datastring,(char *)&(recv_rb->user_data_1[offset]),1);
                        WinPrintf(hWnd,"Data:%s",datastring);

                        // and don't forget to pass a new receive-Block to the CP !
                        fdl_await_indication(hWnd);
                        return;
                } // end switch service.code


    WinPrintf(hWnd,"unexpected indication serv.code:%u",
              recv_rb->application_block.service.code);
}



/**************************************************************************/
/*                                                                        */
/*  void HandleSinecConfirmation()                                        */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
void HandleSinecConfirmation() {

            switch (recv_rb->application_block.service.code) {

                case sap_activate:
                    if (recv_rb->application_block.l_status == ok) {
                        sapState = SST_ACTIVATED;
                        WinPrintf(hWnd,"sap_activate ok");
                    }
                    else
                        WinPrintf(hWnd,"error activating SAP l_status:%02u",recv_rb->application_block.l_status);
                    return;

                case sda:
                    switch (recv_rb->application_block.l_status) {

                        case ok:
                            WinPrintf(hWnd,"sda ok");
                            break;

                        case rr:
                            WinPrintf(hWnd,"no ressource available at remote station");
                            break;

                        case rs:
                            WinPrintf(hWnd,"service on SAP from remote Station not activated");
                            break;

                        case ls:
                            WinPrintf(hWnd,"local SAP not activated");
                            break;

                        case na:
                            WinPrintf(hWnd,"no reaction from remote Station");
                            break;

                        case iv:
                            WinPrintf(hWnd,"invalid parameter in request");
                            break;

                        default:
                            WinPrintf(hWnd,"error sending sda l_status:%02u",
                                      recv_rb->application_block.l_status);
                        } /* end switch l_status */

                    if (sda_running) {
                        // send next data frame
                        fdl_send_sda(hWnd,remote_address,(BYTE)rsap);
                        }
                    return;  // sda confirm

                case withdraw_indication:
                    WinPrintf(hWnd,"%u ressources will be withdrawn",
                    recv_rb->application_block.send_l_sdu.length);
                    return;

                case fdl_read_value:
                    if (recv_rb->application_block.l_status == ok) {
                        struct bus_parameter_block *temp_ptr;
                        temp_ptr = (struct bus_parameter_block *)recv_rb->user_data_1;

                        WinPrintf(hWnd,"fdl_read_value ok");
                        WinPrintf(hWnd,"hsa: %u",temp_ptr->hsa);
                        WinPrintf(hWnd,"ts: %u",temp_ptr->ts);
                        WinPrintf(hWnd,"sty: %u",temp_ptr->station_type);
                        WinPrintf(hWnd,"baudrate: %u",temp_ptr->baud_rate);
                        WinPrintf(hWnd,"retry_ctr: %u",temp_ptr->retry_ctr);
                        WinPrintf(hWnd,"default_sap: %u",temp_ptr->default_sap);
                        WinPrintf(hWnd,"tsl: %u",temp_ptr->tsl);
                        WinPrintf(hWnd,"tqui: %u",temp_ptr->tqui);
                        WinPrintf(hWnd,"tset: %u",temp_ptr->tset);
                        WinPrintf(hWnd,"min_tsdr: %u",temp_ptr->min_tsdr);
                        WinPrintf(hWnd,"max_tsdr: %u",temp_ptr->max_tsdr);
                        WinPrintf(hWnd,"ttr: %u",temp_ptr->ttr);
                        WinPrintf(hWnd,"gap: %u",temp_ptr->g);
                        }
                    else
                        WinPrintf(hWnd,"error fdl_read_value:%02u",recv_rb->application_block.l_status);
                    return;

                } // end switch service.code


    WinPrintf(hWnd,"received unexpectet service code :%u",
              recv_rb->application_block.service.code);

    } // END HandleSinecConfirmation()



/**************************************************************************/
/*                                                                        */
/*  void HandleSinecRequest()                                             */
/*                                                                        */
/*                                                                        */
/**************************************************************************/
void HandleSinecRequest() {

    switch (recv_rb->application_block.service.code) {

        case await_indication:
            WinPrintf(hWnd,"await_indication ressource fetched back");
            return;

        default:
            WinPrintf(hWnd,"unexpected request service.code (%u)",recv_rb->application_block.service.code);
        } // end switch service.code

    } // END HandleSinecRequest()



/**************************************************************************/
/*                                                                        */
/*  dispatch_command(command)                                             */
/*                                                                        */
/*  big switch to catch all the menu commands                             */
/*  returns the function's returncode                                     */
/*                                                                        */
/**************************************************************************/
BOOL dispatch_command(WPARAM command) {

static int value;
INT iErrno;

    switch (command) {

        case IDM_EXIT:
            if (handle != NOT_OPENED) fdl_close(hWnd);
            DestroyWindow (hWnd);
            return TRUE;

        case IDM_ABOUT:
            //FDL_DEMO_PROGRAMM_VERSION is a string defined at the top of this file
            WriteBox(hWnd, "FDLdemo Program for Windows \r\n Copyright (c) SIEMENS AG 1994,1997\r\n" \
                            FDL_DEMO_PROGRAMM_VERSION );
            return TRUE;

        case IDM_SCP_OPEN:
            fdl_open(hWnd);
            iErrno = SCP_get_errno();

            return TRUE;

        case IDM_SCP_CLOSE:
            fdl_close(hWnd);
            return TRUE;

        case IDM_SEND_SDA:
            fdl_send_sda(hWnd,remote_address,(BYTE)rsap);
            return TRUE;

        case IDM_SDA_TRANSFER:
            fdl_send_sda(hWnd,remote_address,(BYTE)rsap);
            sda_running = 1;
            return TRUE;

        case IDM_SDA_TRANSFER_STOP:
            sda_running = 0;
            return TRUE;

        case IDM_SAP_ACTIVATE:
            fdl_sap_activate(hWnd,(BYTE)ssap);
            return TRUE;

        case IDM_AWAIT_INDICATION:
            fdl_await_indication(hWnd);
            return TRUE;

        case IDM_WITHDRAW_INDICATION:
            fdl_withdraw_indication(hWnd);
            return TRUE;

        case IDM_GET_BUS:
            get_busparam(hWnd);
            return TRUE;

        } // end switch(command)

        return(FALSE);  // WM_COMMAND not handled
    }

#pragma pack()

-------------------------------------------------

/****************************************************************************/
/*                                                                          */
/*   Project           : SCI                     ,###.   ,###.   #####      */
/*   Filename          : fdl_rb.h                #   #   #   #     #        */
/*   Version           : 1.4                      #      #         #        */
/*   System            : MSDOS/WINDOWS/WinNT       #     #         #        */
/*                                                  #    #         #        */
/*                                               #   #   #   #     #        */
/*                                               `###'   `###'   #####      */
/*                                                                          */
/****************************************************************************/
/*   Function         : Definitions concerning INA960 commands and request  */
/*                      blocks                                              */
/****************************************************************************/
/*                                                                          */
/*         Copyright (C) Siemens AG 1991, 1997. All Rights Reserved         */
/*                                                                          */
/****************************************************************************/
#pragma pack(1)

#ifndef UBYTE
#define UBYTE unsigned char
#endif
#ifndef UWORD
#define UWORD unsigned short
#endif
#ifndef ULONG
#define ULONG unsigned long
#endif


/* ------------------- */
/* definitions for FLC */
/* ------------------- */

#define   FLC_Subsys    0x22

#define   DEFAULT_SAP   0xff
#define   EVENT_SAP     64
#define   NO_SEGMENT    0xff
#define   BROADCAST     127             /* broadcast-addr.: rem_add.station, dsap = 63  */
#define   MULTICAST     127             /* multicast-addr.: rem_add.station, dsap != 63 */

#define   LEN_MAX_RECEIVE_BUFFER  255    /* max. buffer-length for a receive telegram    */
#define   LEN_MIN_RECEIVE_BUFFER  32     /* min. receive_l_sdu.length                    */

#define   ALL                     0x7f
#define   SEGMENT_VALID           0x80
#define   SEGMENT_INVALID         0x00
#define   SEGMENT_TYP             0x40

    /* example */
    /*   access_sap = ALL or sap_number;                                                */
    /*   access_station = (ALL or station_number) + (SEGMENT_VALID or SEGMENT_INVALID); */
    /*   if SEGMENT_VALID: access_segment = SEGMENT_TYP + segment_number (0 ... 63);    */

    /* SERVICE */
#define   SDA_RESERVED            0x00
#define   SDN_RESERVED            0x01
#define   SRD_RESERVED            0x03
#define   CSRD_RESERVED           0x05

    /* ROLE */
#define   INITIATOR               0x00            /* only possible by "sap_activate"                                      */
#define   RESPONDER               0x10            /* possible by "sap_activate" and mandatory by "rsap_activate"          */
#define   BOTH_ROLES              0x20            /* only possible by "sap_activate"                                      */
#define   SERVICE_NOT_ACTIVATED   0x30            /* service not activated                                                */


#define   STATION_PASSIVE         0x00
#define   STATION_NON_EXISTANT    0x10
#define   STATION_NON_EXISTENT    0x10
#define   STATION_ACTIVE_READY    0x20
#define   STATION_ACTIVE          0x30

typedef enum { flc_false, flc_true } flc_boolean;

enum  com_class
{
    request                 = 0x00,
    confirm                 = 0x01,
    indication              = 0x02
};

enum  service_code
{
    sda                             = 0x00,       /* Send Data with Acknowledge                                           */
    sdn                             = 0x01,       /* Send Data with no Acknowledge                                        */
    sdn_broadcast                   = 0x7f,       /* only for FDL-indication !!! (signs received broadcast-telegram)      */
    srd                             = 0x03,       /* Send and Request Data                                                */
    csrd                            = 0x05,       /* Cyclic Send and Request Data                                         */
    reply_update_single             = 0x06,       /* Reply Update Single Mode                                             */
    reply_update_multiple           = 0x07,       /* Reply Update Multiple Mode                                           */
    fdl_read_value                  = 0x0b,       /* read busparameter                                                    */
    fdl_set_value                   = 0x0c,       /* set busparameter                                                     */
    sap_activate                    = 0x0e,       /* activate local SAP                                                   */
    rsap_activate                   = 0x11,       /* activate local Responder-SAP                                         */
    sap_deactivate                  = 0x12,       /* deactivate local (R)SAP                                              */
    fdl_reset                       = 0x13,       /* reset PHY and FDL; all FDL-information is lost, exc. last busparam.  */
    mac_reset                       = 0x15,       /* reset for MAC; a part of last valid busparameter will be updated     */
    fdl_event                       = 0x18,       /* only for indication, list of events                                  */
    lsap_status                     = 0x19,       /* requests information of remote-SAP or local-SAP                      */
    fdl_life_list_create_remote     = 0x1a,       /* requests list of intact stations                                     */
    fdl_life_list_create_local      = 0x1b,       /* requests quick-list of intact stations (LAS and GAP will be actual)  */
    fdl_ident                       = 0x1c,       /* requests data of software- and hardware-release                      */
    fdl_read_statistic_ctr          = 0x1d,       /* reads counter values of statistic and resets counter                 */
    fdl_read_las_statistic_ctr      = 0x1e,       /* reads LAS and las_cycle_ctr and resets las_cycle_ctr                 */
    await_indication                = 0x1f,       /* provides resources for indication (sap-dependent)                    */
    withdraw_indication             = 0x20,       /* returnes indication-resources                                        */
    load_routing_table              = 0x21,       /* only for network-connection !!!                                      */
    deactivate_routing_table        = 0x22,       /* only for network-connection !!!                                      */
    get_direct_conn                 = 0x23,       /* gets adress of next station                                          */
};

enum  service_class
{
    low                             = 0x00,
    high                            = 0x01
};

enum  link_status
{
    ok                      = 0x00,               /* ACK. positive                                                        */
    ue                      = 0x01,               /* ACK. negative:   remote-USER/FDL interface error                     */
    rr                      = 0x02,               /* ACK. negative:   no remote resource available                        */
    rs                      = 0x03,               /* ACK. negative:   service or rem_add at remote-lsap not activated     */
    dl                      = 0x08,               /* response-data (l_sdu) low available                                  */
    nr                      = 0x09,               /* ACK. negative:   no response-data at remote-FDL available            */
    dh                      = 0x0a,               /* response-data (l_sdu) high available                                 */
    rdl                     = 0x0c,               /* response-data (l_sdu) low available, but negative-ACK for send-data  */
    rdh                     = 0x0d,               /* response-data (l_sdu) high available, but negative-ACK for send-data */
    ls                      = 0x10,               /* service not activated at local sap                                   */
    na                      = 0x11,               /* no reaction (ACK/RES) from remote-station                            */
    ds                      = 0x12,               /* local FDL/PHY not in token-ring                                      */
    no                      = 0x13,               /* ACK. negative:   not ok (different meanings dependant on service)    */
    lr                      = 0x14,               /* resource of local FDL not available                                  */
    iv                      = 0x15,               /* invalid parameter in request                                         */
    lo                      = 0x20,               /* LOw-prior response-data are sent at this srd                         */
    hi                      = 0x21,               /* HIgh-prior response-data are sent at this srd                        */
    no_data                 = 0x22                /* NO-DATA are sent at this srd                                         */
};

enum    poll_element_entry
{
    unlocked                = 0x00,               /* polling enabled for this element                                     */
    locked                  = 0x01,               /* element locked for this poll-cycle                                   */
    not_changed             = 0x02                /* the same meaning as "unlocked", but layer 2 doesn't plausible this   */
                                                  /* service; use only, if this element has already been sent and no      */
                                                  /* parameter changed, but actualize receive_l_sdu.length !!!!!!!!!      */
};

enum    station_type
{
    passive                 = 0x00,
    active                  = 0x01,
    active_fast             = 0x02,
    passive_fast            = 0x03,
    sm_active               = 0x04,               /* possible returned by read_value (PROFIBUS-PA)                        */
    sm_passive              = 0x05
};

enum    baud_rate
{
    kbaud_9_6               = 0x00,
    kbaud_19_2              = 0x01,
    kbaud_93_75             = 0x02,
    kbaud_187_5             = 0x03,
    kbaud_500               = 0x04,
    kbaud_375               = 0x05,
    kbaud_750               = 0x06,
      /*CT_CHANGE*/
    mbaud_1_5               = 0x07,
    mbaud_3                 = 0x08,
    mbaud_6                 = 0x09,
    mbaud_12                = 0x0a,
    kbaud_45_45             = 0x0c                /* 09-06-1997: a new baud rate */
};

enum    redundancy
{
    no_redundancy           = 0x00,
    bus_a_highprior         = 0x01,
    bus_b_highprior         = 0x02,
    redundancy_on           = 0x03
};

enum    physical_layer
{
    rs485                   = 0x00,
    modem                   = 0x01
};

enum    false_bus_parameter             /* "fdl_set_value" : if FDL-User sets false bus_parameter,              */
                                        /* application_block -> l_status = false_bus_parameter + iv;            */
                                        /* that means, high-byte corresponds with number of false parameter     */
{
    false_hsa                       = 0x100,
    false_ts                        = 0x200,
    false_station_type              = 0x300,
    false_baud_rate                 = 0x400,
    false_medium_red                = 0x500,
    false_retry_ctr                 = 0x600,
    false_default_sap               = 0x700,
    false_network_connection_sap    = 0x800,
    false_tsl                       = 0x900,
    false_tqui                      = 0xa00,
    false_tset                      = 0xb00,
    false_min_tsdr                  = 0xc00,
    false_max_tsdr                  = 0xd00,
    false_ttr                       = 0xe00,
    false_g                         = 0xf00,
    false_in_ring_desired           = 0x1000,
    false_physical_layer            = 0x1100,
    false_ident                     = 0x1200
};



struct  service
{
#ifdef M_DOS
   enum  service_code      code;
#else
   short                   code;
#endif
};


struct  remote_address
{
    UBYTE                    station;
    UBYTE                    segment;              /* if no segment is used, set "NO_SEGMENT"                              */
};

struct  link_service_data_unit
{
    void                    *buffer_ptr;
    UBYTE                    length;
};


struct  application_block
{
    UBYTE                          opcode;         /* class of communication                                               */
    UBYTE                          subsystem;      /* number of source-task (only necessary for MTK-user !!!!!)            */
    UWORD                          id;             /* identification of FDL-USER                                           */
    struct  service                service;        /* identification of service                                            */
    struct  remote_address         loc_add;        /* only for network-connection !!!                                      */
    UBYTE                          ssap;           /* source-service-access-point                                          */
    UBYTE                          dsap;           /* destination-service-access-point                                     */
    struct  remote_address         rem_add;        /* address of the remote-station                                        */
#ifdef M_DOS
    enum    service_class          serv_class;     /* priority of service                                                  */
#else      
    short                          serv_class;     /* priority of service                                                  */
#endif
    struct  link_service_data_unit receive_l_sdu;  /* address and length of received netto-data, exception:                */
    UBYTE                          reserved1;      /* (reserved for FDL !!!!!!!!!!)                                        */
    UBYTE                          reserved2;      /* (reserved for FDL !!!!!!!!!!)                                        */
    struct  link_service_data_unit send_l_sdu;     /* address and length of send-netto-data, exception:                    */
                                                   /* 1. csrd                 : length means number of POLL-elements       */
                                                   /* 2. await_indication     : concatenation of application-blocks and    */
                                                   /*    withdraw_indication  : number of application-blocks               */
#ifdef M_DOS
    enum    link_status            l_status;       /* link-status of service or update_state for srd-indication            */
#else
    short                          l_status;       /* link-status of service or update_state for srd-indication            */
#endif
    UBYTE                          reserved3[4];   /* for concatenated lists       (reserved for FDL !!!!!!!!!!)           */
};

typedef struct
{
    UWORD                           reserved [2];
    UBYTE                           length;
    UWORD                           user;
    UBYTE                           rb_type;
    UBYTE                           priority;
    UBYTE                           reserved_1;
    UWORD                           reserved_2;
    UBYTE                           subsystem;
    UBYTE                           opcode;
    UWORD                           response;
    UWORD                           fill_length_1;
    UBYTE                           reserved_3;
    UWORD                           seg_length_1;
    UWORD                           offset_1;
    UWORD                           reserved_4;
    UWORD                           fill_length_2;
    UBYTE                           reserved_5;
    UWORD                           seg_length_2;
    UWORD                           offset_2;
    UWORD                           reserved_6;

} rb2_header_type;

typedef struct
{
    rb2_header_type                 rb2_header;
    struct application_block        application_block;
    UBYTE                           reserved[12];
    UBYTE                           reference[2];
    UBYTE                           user_data_1[260];
    UBYTE                           user_data_2[260];
} fdl_rb;

typedef fdl_rb flc_rb;

/* Moegliche Strukturen der Datenpuffer */

struct  user_poll_element
{
    UBYTE                           dsap;          /* destination-service-access-point                                     */
    struct  remote_address          rem_add;       /* address of the remote-station                                        */
#ifdef M_DOS
    enum    service_class           serv_class;    /* priority of send-telegram                                            */
#else
    short                           serv_class;    /* priority of send-telegram                                            */
#endif
    struct  link_service_data_unit  receive_l_sdu; /* request: length means buffer-length in byte                          */
                                                   /* confirm: length means length of received netto-data                  */
    struct  link_service_data_unit  send_l_sdu;    /* address and length of send-netto-data                                */
    UBYTE                           reserved;      /* reserved for FDL !!!!!                                               */
#ifdef M_DOS
    enum    link_status             l_status;      /* link-status of poll-element-service                                  */
    enum    poll_element_entry      entry;         /* locks or unlocks a poll-element                                      */
#else
    short                           l_status;      /* link-status of poll-element-service                                  */
    short                           entry;         /* locks or unlocks a poll-element                                      */
#endif
    UBYTE                           reserved_2;    /* reserved for FDL !!!!!                                               */
};


struct  ident
{
    UBYTE   reserved_header[8];                    /* reserved for FDL !!!!!                                               */
#ifdef M_DOS
    UBYTE   ident[202];
#else
    UBYTE   ident_info[202];
#endif
    UBYTE   response_telegram_length;              /* reserved for FDL !!!!!                                               */
};


struct  bus_parameter_block
{
    UBYTE                    hsa;                  /* highest station-address                                              */
                                                   /* range of values:  2 ... 126                                          */
    UBYTE                    ts;                   /* FDL-address of this station                                          */
                                                   /* range of values:  0 ... 126                                          */
#ifdef M_DOS
    enum    station_type    station_type;          /* active, passive                                                      */
    enum    baud_rate       baud_rate;             /* transmission rate                                                    */
    enum    redundancy      medium_red;            /* availability of redundant media                                      */
#else
    short                   station_type;          /* active, passive                                                      */
    short                   baud_rate;             /* transmission rate                                                    */
    short                   medium_red;            /* availability of redundant media                                      */
#endif
    UWORD                    retry_ctr;            /* retry-number of requestor, if no reaction of responder               */
                                                   /* range of values:  1 ... 8                                            */
    UBYTE                    default_sap;          /* Default SAP if no address-extension is used                          */
                                                   /* range of values:  2 ... 62                                           */
    UBYTE                    network_connection_sap;/* number of sap for network-connection (only for network-connections) */
                                                   /* range of values:  2 ... 62                                           */
    UWORD                    tsl;                  /* SLOT-time:                                                           */
                                                   /* range of values:  2 exp 0 ... (2 exp 16) - 1   BIT-times             */
    UWORD                    tqui;                 /* Transmitter-Fall-Time / Repeater-Switch-Time:                        */
                                                   /* range of values:  0 ... (2 exp 8) - 1 BIT-times                      */
    UWORD                    tset;                 /* setup-time                                                           */
                                                   /* range of values:  0 ... (2 exp 8) - 1 BIT-times                      */
    UWORD                    min_tsdr;             /* smallest STATION-DELAY-time:                                         */
                                                   /* range of values:  2 exp 0 ... (2 exp 16) - 1   BIT-times             */
    UWORD                    max_tsdr;             /* largest STATION-DELAY-time:                                          */
                                                   /* range of values:  2 exp 0 ... (2 exp 16) - 1   BIT-times             */
    ULONG                    ttr;                  /* TARGET-ROTATION-time:                                                */
                                                   /* range of values:  2 exp 0 ... (2 exp 24) - 1   BIT-times             */
    UBYTE                    g;                    /* GAP-UPDATE-factor: in multiples of ttr                               */
                                                   /* range_of_values:  1 ... 100                                          */
#ifdef M_DOS
    flc_boolean             in_ring_desired;       /* request entrance into the token-ring                                 */
    enum    physical_layer  physical_layer;        /* RS485, modem                                                         */
#else
      short                        in_ring_desired;       /* request entrance into the token-ring                                 */
      short                   physical_layer;        /* RS485, modem                                                         */
#endif
    struct  ident           ident;                 /* vendor-name, controller_type, version of hardware and software       */
};

struct  fdl_sap
{
    UWORD                  user_id;                /* identification for user                                              */
    UBYTE                  max_l_sdu_length;       /* maximal length of netto_data for this sap                            */
    UBYTE                  access_sap;             /* reserved destination_sap                                             */
    UBYTE                  access_station;         /* reserved destination_address                                         */
    UBYTE                  access_segment;         /* reserved destination_segment                                         */
    UBYTE                  sda;                    /* ... .sda = "ROLE"; sda unused by service "rsap_activate"             */
    UBYTE                  sdn;                    /* look sda; sdn unused by service "rsap_activate"                      */
    UBYTE                  srd;                    /* look sda;                                                            */
    UBYTE                  csrd;                   /* if you want to activate csrd for this SAP, type: ... .csrd = "ROLE"; */
                                                   /* (only INITIATOR or SERVICE_NOT_ACTIVATED possible)                   */
                                                   /* csrd unused by service "rsap_activate"                               */
    void                  *rup_l_sdu_ptr_low;      /* reserved for "sap_deactivate"; USER gets rup-buffer returned         */
    void                  *rup_l_sdu_ptr_high;     /* reserved for "sap_deactivate"; USER gets rup-buffer returned         */
    UBYTE                  reserved[22];           /* reserved for FDL !!!!!                                               */
};


/**********************************************************************/
/****************   fdl_event (returned by fma_indication) ************/
/****************   await_indication (for DSAP = EVENT_SAP)************/
/**********************************************************************/


struct  event_ctr
{
    UWORD                    threshold;                      /* if counter achieves threshold, a fma_indication is initiated         */
    UWORD                    counter;
};

struct  event_indication
{
    struct  event_ctr       time_out;
    struct  event_ctr       not_syn;
    struct  event_ctr       uart_error;
    struct  event_ctr       out_of_ring;
    struct  event_ctr       sdn_not_indicated;
    struct  event_ctr       duplicate_address;
    struct  event_ctr       hardware_error;
    struct  event_ctr       mac_error;
};


/**********************************************************************/
/****************   fdl_read_statistic_ctr  ***************************/
/**********************************************************************/

struct  statistic_ctr_list
{
            /* error-counter */
    UWORD                    invalid_start_delimiter_ctr;
    UWORD                    invalid_fcb_fcv_ctr;
    UWORD                    invalid_token_ctr;
    UWORD                    collision_ctr;
    UWORD                    wrong_fcs_or_ed_ctr;
    UWORD                    frame_error_ctr;
    UWORD                    char_error_ctr;
    UWORD                    retry_ctr;
            /* reference-counter */
    ULONG                    start_delimiter_ctr;
    ULONG                    stop_receive_ctr;
    ULONG                    send_confirmed_ctr;
    ULONG                    send_sdn_ctr;
};


/*
 *      Prototypings
 *      ************
 */

/* old prototypes for MSDOS and Windows 3.x */

#ifdef M_DOS

#ifndef MM
#define MM far
#endif

int MM ihi_get_dev_list(short MM *,unsigned short MM *,char MM *);
int MM ihi_open(short);
int MM ihi_open_dev(unsigned short,char MM *);
int MM ihi_write(int,void MM *);
int MM ihi_read(int,short,void MM * MM *);
int MM ihi_close(int);


#ifdef M_WINDOWS
#define WM_SINEC                 500
int MM SetSinecHWnd (int, HWND);
int MM SetSinecHWndMsg(int, HWND, unsigned int);
#endif

#else /* M_DOS */
/* prototypes for Win32 */

#ifdef __cplusplus      
extern "C" {
#endif

INT WINAPI SCP_open ( CHAR *);
INT WINAPI SCP_close ( INT );
INT WINAPI SCP_send ( INT, USHORT, char *);
INT WINAPI SCP_receive ( INT, SHORT, SHORT *, SHORT, CHAR *);
INT WINAPI SetSinecHWndMsg( INT, HANDLE, ULONG );
INT WINAPI SetSinecHWnd( INT,HANDLE);
INT WINAPI SCP_get_errno( VOID );

#ifdef __cplusplus
}
#endif

#define WM_SINEC                 (WM_USER+500)

#endif /* M_DOS */

#pragma pack()


/****************************************************************************/
/*                                                                          */
/*         Copyright (C) Siemens AG 1991, 1997. All Rights Reserved         */
/*                                                                          */
/****************************************************************************/





Commented:
Several of the defined structs contain byte members, and the last statement in the header is #pragma pack(). Delphi aligns is records on a word boundary for faster CPU access. Declare all your records like

type TMyStruct = packed record
  //...stuff
end;

then the records will be aligned member to member.

Slash/d003303
Unlock the solution to this question.
Thanks for using Experts Exchange.

Please provide your email to receive a sample view!

*This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

OR

Please enter a first name

Please enter a last name

8+ characters (letters, numbers, and a symbol)

By clicking, you agree to the Terms of Use and Privacy Policy.