Thread: struct initialization / memcpy / pointer to memory

Hi,
I want to initialize a struct using a constructor, fill in the variables using memcpy with values from msgDescriptor and create a pointer to the beginning of the memory adress for this struct (sorry I am not native speaker)
But it doesn' t work.. Could someone tell me what I am doing wrong?

HyqcmqprHandler.cpp

Code:

void
TestHandler::callMsgTransmit(
    char * reqQName, 
    IMQMsg * msg, 
    bool reliably)
    throw(EBBaseExcept)
{
    if (reliably)
    {
        try
        {


            if ((BASTrx::Current::getSingleton())->get_status() !=
                BASTrx::Status::StatusActive)
            {
                throw BASTrxRequiredExcept(MQ_TRC_GRP,
                            _callMsgTransmitFctName,
                            _callMsgTransmitFctName,
                            _FILE_, _LINE_);
            }
        }
        catch(...)
        {
            throw BASTrxRequiredExcept(MQ_TRC_GRP,
                    _callMsgTransmitFctName,
                    _callMsgTransmitFctName,
                    _FILE_, _LINE_);
        }
    }


    MQMD1 & msgDescriptor = msg->msgDescriptor(); 
    MQPMOputMsgOptions = { MQPMO_DEFAULT }; 
    putMsgOptions.Options = defaultPutOptions;
    if ( ! reliably)
    {
        (putMsgOptions.Options) &= ~MQPMO_SYNCPOINT;
        (putMsgOptions.Options) |= MQPMO_NO_SYNCPOINT;
    }


    const BASBuffer & buffer = msg->buffer(); 
    const char * data = buffer.getBuffer(); 
    MQLONG dataLength = buffer.tell();
    if ((0 == data) || (dataLength < 1))
    {
        throw EBinvParValExcept(MQ_TRC_GRP,
                _callMsgTransmitFctName,
                "msg->buffer()", 0, 0,
                "(0 == (msg->buffer()).getBuffer()) ||"
                " ((msg->buffer()).tell() < 1",
                _FILE_, _LINE_);
    }


    //---------------------------------------------------------
    // struct 'TestHandler::TestParms'
    //---------------------------------------------------------
    const char validEyeCatcher[8] = { 'H', 'Y', 'Q', 'C', 'M', 'Q', 'P', 'R' };


    const char version_1_0[4] = { '0' , '1', '0', '0' };




    TestParms MsgParms;


    memcpy(MsgParms.m_eyeCatcher, validEyeCatcher, sizeof(MsgParms.m_eyeCatcher));


    memcpy(MsgParms.m_version, version_1_0, sizeof(MsgParms.m_version));


    memcpy(MsgParms.m_mqprQueueMgr, &msgDescriptor.ReplyToQMgr, sizeof(MsgParms.m_mqprQueueMgr));


    memcpy(MsgParms.m_mqprQueue, &reqQName, sizeof(MsgParms.m_mqprQueue));


    memcpy(MsgParms.m_mqprReplyQueue, &msgDescriptor.ReplyToQ, sizeof(MsgParms.m_mqprReplyQueue));
 
    memcpy(MsgParms.m_mqprMessageP, &data, sizeof(MsgParms.m_mqprMessageP));


    memcpy(MsgParms.m_mqprMessageL, &dataLength, sizeof(MsgParms.m_mqprMessageL));


    memcpy(MsgParms.m_mqprMessageId, &msgDescriptor.MsgId, sizeof(MsgParms.m_mqprMessageId));


    memcpy(MsgParms.m_mqprCorrelId, &msgDescriptor.CorrelId, sizeof(MsgParms.m_mqprCorrelId));


    memcpy(MsgParms.m_mqprCommitScope, &putMsgOptions.Options, sizeof(MsgParms.m_mqprCommitScope));


    memcpy(MsgParms.m_mqprFormat, &msgDescriptor.Format, sizeof(MsgParms.m_mqprFormat));


    memcpy(MsgParms.m_mqprPersistency, &msgDescriptor.Persistence, sizeof(MsgParms.m_mqprPersistency));


    memcpy(MsgParms.m_mqprPriority, &msgDescriptor.Priority, sizeof(MsgParms.m_mqprPriority));


    memcpy(MsgParms.m_mqprExpiry, &msgDescriptor.Expiry, sizeof(MsgParms.m_mqprExpiry)); 


    memset(MsgParms.m_mqprTargetEntity, ' ', sizeof(MsgParms.m_mqprTargetEntity));


    memset(MsgParms.m_reserved1, ' ', sizeof(MsgParms.m_reserved1));




    IMQSspSvcStdPar::SspSvcStdPar * svcStdPar = IMQSspSvcStdPar::getSingleton().sspSvcStdPar();


    //    note:
    // on OS/390 a pointer is a 31 bits quantity kept in a 4 bytes word;
    // COBOL functions (the COBOL run time system) expect(s)
    // the most significant bit of the last parameter to be set 
    TestParms * hyqcmqprParmsPtr = &MsgParms; 
    TestParms * _hyqcmqprParmsPtr = 
        (TestParms *)(((int)hyqcmqprParmsPtr) | 0x80000000);


    {
        hyqcmqprHandlerFct(
            svcStdPar,
            _hyqcmqprParmsPtr);
    }


    if (IMQSspSvcStdPar::getSingleton().rc1() == IMQSspSvcStdPar::FAILED)
    {
        throw EBCLibFctErrExcept(
            SRV_CONT_TRC_GRP,
            _callMsgTransmitFctName, 
            hyqcmqprHandlerFct, 0, 0, 0,
            IMQSspSvcStdPar::getSingleton()._rc1(),
            0,
            _FILE_, _LINE_ );


        TC_TRACE_LEAVE(SRV_CONT_TRC_GRP);
        return ;
    }
}

TestHandler.h

Code:

class TestHandler
{
    public:


    struct TestParms
    {
        
        HyqcmqprParms(void)
            throw();


        
        // Filler                PIC X(8) VALUE 'HYQCMQPR'.
        char m_eyeCatcher[8];


        //
        // values valid for 'm_eyeCatcher'
        //
#pragma variable(TestHandler::TestParms:: \
            validEyeCatcher, NORENT)
            static const char validEyeCatcher[];


        // Filler                PIC X(4) VALUE '0100'.
        char m_version[4];


        //
        // values valid for 'm_version'
        //
#pragma variable(TestHandler::TestParms:: \
            version_1_0, NORENT)
            static const char version_1_0[];




        // MQPR-QueueMgr            PIC X(48) VALUE spaces.   
        char m_mqprQueueMgr[48];


        // MQPR-Queue                PIC X(48) VALUE spaces.
        char m_mqprQueue[48];


        // MQPR-ReplyQueue            PIC X(48) VALUE spaces.
        char m_mqprReplyQueue[48];


        // MQPR-Message-p            POINTER VALUE NULL.
        char m_mqprMessageP[sizeof(void *)];


        // MQPR-Message-l            PIC S9(8) COMP-5 VALUE 0.
        char m_mqprMessageL[sizeof(int)];


        // MQPR-MessageId             PIC X(24) VALUE LOW-VALUES.
        char m_messageId[24];


        // MQPR-CorrelId             PIC X(24) VALUE LOW-VALUES.
        char m_correlId[24];


        // MQPR-CommitScope            PIC S9(4) COMP-5 VALUE 0.
        char m_mqprCommitScope[sizeof(int)];


        // MQPR-Format                PIC S9(4) COMP-5 VALUE 0.
        char m_mqprFormat[sizeof(int)];


        // MQPR-Persistency            PIC S9(4) COMP-5 VALUE 0.
        char m_mqprPersistency[sizeof(int)];


        // MQPR- Priority            PIC S9(4) COMP-5 VALUE 0.
        char m_mqprPriority[sizeof(int)];
    
        // MQPR-Expiry                PIC S9(4) COMP-5 VALUE 0.
        char m_mqprExpiry[sizeof(int)];


        // MQPR-TargetEntity            PIC X(3) VALUE ' '.
        char m_mqprTargetEntity[3];


        // MQPR-FILLER                PIC X(80) VALUE LOW-VALUES.
        char m_reserved1[80];


    };


    static void callMsgTransmit(
    char * reqQName,
    IMQMsg * msg,
    bool reliably = true)
    throw(EBBaseExcept);


    static IMQSspServiceBase::SspFunction hyqcmqprHandlerFct;


#pragma variable(TestHandler:: \
        _callMsgTransmitFctName, NORENT)
        static const char _callMsgTransmitFctName[];


};

But is char[4] or char[8] correct or should it int[4] and int[8]?