Search  

---

C:/temp/src/j2k/QNX4/Group5/Message.cpp

Go to the documentation of this file.

/***
   NAME
     message
   PURPOSE
     Message stuff.  Runs a message loop.
   NOTES
     Messages have the following format:

     int msgnum;
     char args[1];

     msgnum 0 means that the thread should terminate.  
    It takes no arguments.
***/

#ifndef __J2K__Train__Message_CPP__
#define __J2K__Train__Message_CPP__

#include "message.hh"
#include <sys/kernel.h>
#include <unistd.h>
#include <stdio.h>

// Overall message format
struct message
{
    int msgnum;
    char args[1];               // really dependent on what's there
};

/*
 * Purpose:  Built a message thread.
 *
 * Input:    None.
 *
 * Output:   None.
 */

Message_thread::Message_thread() : Schedule_thread() { }

/*
 * Purpose:  Runs the message loop and dispatches to the proper
 *           function.
 *
 * Input:    None
 *
 * Output:   None
 */
void Message_thread::run()
{
    message* msg;
    pid_type pid;
    int status;

    while(1)
    {
        if((pid = Receive(0, buffer_, sizeof(buffer_))) < 0)
            continue;           // try again
        // convert message
        msg = (message*)buffer_;

        // message 0 is destroy message
        if(msg->msgnum == 0)
            break;

        // filter out message
        if(message_filter(msg->msgnum, msg->args, pid))
            continue;
        // Get entry and call it
        status = dispatch(this, msg->msgnum, msg->args, pid);
        // when we get >= 0, it means that's the status code
        if(status >= 0)
            Reply(pid, &status, sizeof(status));
    }

    // send confirmation for destruction
    Reply(pid, NULL, 0);
}

/*
 * Purpose:  Dispatch message into given table entry
 */
int Message_thread::dispatch(Message_thread* self,
                             int msg,
                             char* buffer,
                             pid_type pid)
{
    const message_table_entry* entry;

//    printf("In dispatch: msg = %d, pid = %d\n", msg, pid);
//    fflush(stdout);
    entry = self->find_entry(msg);
    if(!entry) return 0;
//    fflush(stdout);
//    printf("In dispatch: find_entry returned marshal %p function %p\n",
//           entry->marshal, entry->function);
    return (*entry->marshal)(self, entry->function, msg, buffer, pid);
}

/*
 * Purpose:  Send message to thread
 *
 * Input:    buffer  : message to send
 *           length  : how long it is
 *           reply   : reply buffer
 *           rlength : how long it is
 *
 * Output:   None.
 */
void Message_thread::send(const void* buffer, int length,
                          void* reply, int rlength)
{
    if(pid_ < 0) { return; }
    Send(pid_, buffer, reply, length, rlength);
}

/*
 * Purpose:  Stops the current thread (if running)
 *
 */
int Message_thread::stop()
{
    static const int terminate_message = 0;
    if(pid_ < 0) { return -1; }

    // try to send message 0
    send(&terminate_message, sizeof(terminate_message), NULL, 0);

    pid_ = -1;
    return 0;
}

#endif

---