Solved

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

Posted on 1998-06-25
6
1,087 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 ?
0
Comment
Question by:phv
6 Comments
 
LVL 1

Expert Comment

by:jturpin
ID: 1355868
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.
0
 
LVL 1

Expert Comment

by:bcrotaz
ID: 1355869
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
0
 
LVL 4

Accepted Solution

by:
d003303 earned 100 total points
ID: 1355870
Yo,
in general, this function would be declared in pascal as

function SCP_Send(AnInt : Integer; AShort : ShortInt; Buffer : PChar): Integer; stdcall;

The stdcall directive is important because it is declared with the WINAPI calling convention.

Slash/d003303
0
What Is Threat Intelligence?

Threat intelligence is often discussed, but rarely understood. Starting with a precise definition, along with clear business goals, is essential.

 
LVL 4

Expert Comment

by:d003303
ID: 1355871
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
0
 

Author Comment

by:phv
ID: 1355872
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         */
/*                                                                          */
/****************************************************************************/





0
 
LVL 4

Expert Comment

by:d003303
ID: 1355873
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
0

Featured Post

Highfive Gives IT Their Time Back

Highfive is so simple that setting up every meeting room takes just minutes and every employee will be able to start or join a call from any room with ease. Never be called into a meeting just to get it started again. This is how video conferencing should work!

Join & Write a Comment

Have you ever had your Delphi form/application just hanging while waiting for data to load? This is the article to read if you want to learn some things about adding threads for data loading in the background. First, I'll setup a general applica…
In my programming career I have only very rarely run into situations where operator overloading would be of any use in my work.  Normally those situations involved math with either overly large numbers (hundreds of thousands of digits or accuracy re…
In this seventh video of the Xpdf series, we discuss and demonstrate the PDFfonts utility, which lists all the fonts used in a PDF file. It does this via a command line interface, making it suitable for use in programs, scripts, batch files — any pl…
Here's a very brief overview of the methods PRTG Network Monitor (https://www.paessler.com/prtg) offers for monitoring bandwidth, to help you decide which methods you´d like to investigate in more detail.  The methods are covered in more detail in o…

759 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

17 Experts available now in Live!

Get 1:1 Help Now