Logo Search packages:      
Sourcecode: baycomusb version File versions  Download package

trxctrl-skels.c

/*
 * This file was generated by orbit-idl - DO NOT EDIT!
 */

#include <string.h>
#include "trxctrl.h"

void
_ORBIT_Trx_TrxError_marshal(GIOPSendBuffer * _ORBIT_send_buffer,
                      CORBA_Environment * ev)
{
   register CORBA_unsigned_long _ORBIT_tmpvar_0;
   CORBA_unsigned_long _ORBIT_tmpvar_1;
   Trx_TrxError *_ORBIT_exdata = ev->_params;

   _ORBIT_tmpvar_1 = strlen((*_ORBIT_exdata).reason) + 1;
   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
                            4);
   giop_send_buffer_append_mem_indirect(GIOP_SEND_BUFFER(_ORBIT_send_buffer),
                              &(_ORBIT_tmpvar_1),
                              sizeof(_ORBIT_tmpvar_1));
   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
                          ((*_ORBIT_exdata).reason),
                          sizeof((*_ORBIT_exdata).
                               reason[_ORBIT_tmpvar_0]) *
                          _ORBIT_tmpvar_1);
}

void
_ORBIT_skel_Trx_Control_GetDescription(POA_Trx_Control * _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl_GetDescription)
                               (PortableServer_Servant _servant,
                              Trx_TrxDescription ** desc,
                              CORBA_Environment * ev))
{
   Trx_TrxDescription *desc;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_GetDescription(_ORBIT_servant, &(desc), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          CORBA_unsigned_long _ORBIT_tmpvar_1;
          register CORBA_unsigned_long _ORBIT_tmpvar_2;
          CORBA_unsigned_long _ORBIT_tmpvar_3;
          register CORBA_unsigned_long _ORBIT_tmpvar_4;
          CORBA_unsigned_long _ORBIT_tmpvar_5;
          register CORBA_unsigned_long _ORBIT_tmpvar_6;
          CORBA_unsigned_long _ORBIT_tmpvar_7;
          register CORBA_unsigned_long _ORBIT_tmpvar_8;
          register CORBA_unsigned_long _ORBIT_tmpvar_9;

          _ORBIT_tmpvar_1 = strlen((*desc).manufacturer) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_1));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 ((*desc).manufacturer),
                                 sizeof((*desc).
                                      manufacturer
                                      [_ORBIT_tmpvar_0]) *
                                 _ORBIT_tmpvar_1);
          _ORBIT_tmpvar_3 = strlen((*desc).model) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_3));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_3), sizeof(_ORBIT_tmpvar_3));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_3));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 ((*desc).model),
                                 sizeof((*desc).
                                      model[_ORBIT_tmpvar_2]) *
                                 _ORBIT_tmpvar_3);
          _ORBIT_tmpvar_5 = strlen((*desc).copyright) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_5));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_5), sizeof(_ORBIT_tmpvar_5));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_5));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 ((*desc).copyright),
                                 sizeof((*desc).
                                      copyright[_ORBIT_tmpvar_4])
                                 * _ORBIT_tmpvar_5);
          _ORBIT_tmpvar_7 = strlen((*desc).instid) + 1;
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_7));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_7), sizeof(_ORBIT_tmpvar_7));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_7));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 ((*desc).instid),
                                 sizeof((*desc).
                                      instid[_ORBIT_tmpvar_6]) *
                                 _ORBIT_tmpvar_7);
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*desc).rxbands._length));
             memcpy(_ORBIT_t, &((*desc).rxbands._length),
                  sizeof((*desc).rxbands._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*desc).rxbands.
                                         _length));
          }
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 8);
          {
             guchar *_ORBIT_t;

             _ORBIT_t =
              alloca(sizeof((*desc).rxbands._buffer[_ORBIT_tmpvar_8]) *
                   (*desc).rxbands._length);
             memcpy(_ORBIT_t, ((*desc).rxbands._buffer),
                  sizeof((*desc).rxbands._buffer[_ORBIT_tmpvar_8]) *
                  (*desc).rxbands._length);
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*desc).rxbands.
                                         _buffer[_ORBIT_tmpvar_8])
                                    * (*desc).rxbands._length);
          }
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*desc).txbands._length));
             memcpy(_ORBIT_t, &((*desc).txbands._length),
                  sizeof((*desc).txbands._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*desc).txbands.
                                         _length));
          }
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 8);
          {
             guchar *_ORBIT_t;

             _ORBIT_t =
              alloca(sizeof((*desc).txbands._buffer[_ORBIT_tmpvar_9]) *
                   (*desc).txbands._length);
             memcpy(_ORBIT_t, ((*desc).txbands._buffer),
                  sizeof((*desc).txbands._buffer[_ORBIT_tmpvar_9]) *
                  (*desc).txbands._length);
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*desc).txbands.
                                         _buffer[_ORBIT_tmpvar_9])
                                    * (*desc).txbands._length);
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &((*desc).rssimin),
                                 sizeof((*desc).rssimin));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &((*desc).rssimax),
                                 sizeof((*desc).rssimax));
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(desc);
   }
}
void
_ORBIT_skel_Trx_Control_GetState(POA_Trx_Control * _ORBIT_servant,
                         GIOPRecvBuffer * _ORBIT_recv_buffer,
                         CORBA_Environment * ev,
                         void (*_impl_GetState)
                         (PortableServer_Servant _servant,
                          Trx_TrxState * state,
                          CORBA_Environment * ev))
{
   Trx_TrxState state;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_GetState(_ORBIT_servant, &(state), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(state.mode), sizeof(state.mode));
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 8);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(state.rxfreq),
                                 sizeof(state.rxfreq));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(state.txfreq),
                                 sizeof(state.txfreq));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(state.ptt),
                                 sizeof(state.ptt));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(state.manualptt),
                                 sizeof(state.manualptt));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(state.dcd),
                                 sizeof(state.dcd));
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(state.rssi), sizeof(state.rssi));
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_SetPTT(POA_Trx_Control * _ORBIT_servant,
                         GIOPRecvBuffer * _ORBIT_recv_buffer,
                         CORBA_Environment * ev,
                         void (*_impl_SetPTT) (PortableServer_Servant
                                         _servant,
                                         const CORBA_boolean ptt,
                                         CORBA_Environment * ev))
{
   CORBA_boolean ptt;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       ptt = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
       ptt = *((CORBA_boolean *) _ORBIT_curptr);
      }
   }
   _impl_SetPTT(_ORBIT_servant, ptt, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_SetFrequency(POA_Trx_Control * _ORBIT_servant,
                             GIOPRecvBuffer * _ORBIT_recv_buffer,
                             CORBA_Environment * ev,
                             void (*_impl_SetFrequency)
                             (PortableServer_Servant _servant,
                              const Trx_frequency rx,
                              const Trx_frequency tx,
                              CORBA_Environment * ev))
{
   Trx_frequency rx;
   Trx_frequency tx;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 8);
       iiop_byteswap((guchar *) & (rx), _ORBIT_curptr, 8);
       _ORBIT_curptr += 8;
       iiop_byteswap((guchar *) & (tx), _ORBIT_curptr, 8);
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 8);
       rx = *((Trx_frequency *) _ORBIT_curptr);
       _ORBIT_curptr += 8;
       tx = *((Trx_frequency *) _ORBIT_curptr);
      }
   }
   _impl_SetFrequency(_ORBIT_servant, rx, tx, ev);
}

void
_ORBIT_skel_Trx_Control_UartSend(POA_Trx_Control * _ORBIT_servant,
                         GIOPRecvBuffer * _ORBIT_recv_buffer,
                         CORBA_Environment * ev,
                         void (*_impl_UartSend)
                         (PortableServer_Servant _servant,
                          const CORBA_char * str,
                          CORBA_Environment * ev))
{
   CORBA_char *str;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (_ORBIT_tmpvar_3))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       str = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(str[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       str = (void *) _ORBIT_curptr;
       _ORBIT_curptr += sizeof(str[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl_UartSend(_ORBIT_servant, str, ev);
}

void
_ORBIT_skel_Trx_Control_UartReceive(POA_Trx_Control * _ORBIT_servant,
                            GIOPRecvBuffer * _ORBIT_recv_buffer,
                            CORBA_Environment * ev,
                            void (*_impl_UartReceive)
                            (PortableServer_Servant _servant,
                             CORBA_unsigned_long * ptr,
                             CORBA_char ** str,
                             CORBA_Environment * ev))
{
   CORBA_unsigned_long ptr;
   CORBA_char *str;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (ptr))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       ptr = *((CORBA_unsigned_long *) _ORBIT_curptr);
      }
   }
   _impl_UartReceive(_ORBIT_servant, &(ptr), &(str), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          CORBA_unsigned_long _ORBIT_tmpvar_1;

          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(ptr),
                                 sizeof(ptr));
          _ORBIT_tmpvar_1 = strlen(str) + 1;
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
             memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof(_ORBIT_tmpvar_1));
          }
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), (str),
                                 sizeof(str[_ORBIT_tmpvar_0]) *
                                 _ORBIT_tmpvar_1);
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(str);
   }
}
void
_ORBIT_skel_Trx_Control_BaycomUSBAdapterGetConfig(POA_Trx_Control *
                                      _ORBIT_servant,
                                      GIOPRecvBuffer *
                                      _ORBIT_recv_buffer,
                                      CORBA_Environment * ev,
                                      void
                                      (*_impl_BaycomUSBAdapterGetConfig)
                                      (PortableServer_Servant
                                       _servant,
                                       Trx_BaycomUSBAdapterConfig
                                       * cfg,
                                       CORBA_Environment * ev))
{
   Trx_BaycomUSBAdapterConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_BaycomUSBAdapterGetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          register CORBA_unsigned_long _ORBIT_tmpvar_1;

          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(cfg.mode),
                                 sizeof(cfg.mode));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(cfg.fclk),
                                 sizeof(cfg.fclk));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.bitraterx),
                                 sizeof(cfg.bitraterx));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.bitratetx),
                                 sizeof(cfg.bitratetx));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.loopback),
                                 sizeof(cfg.loopback));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.pttmute),
                                 sizeof(cfg.pttmute));
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.filtmode),
                                 sizeof(cfg.filtmode));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.samplerate),
                                 sizeof(cfg.samplerate));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(cfg.gain),
                                 sizeof(cfg.gain));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.audiodevin),
                                 sizeof(cfg.
                                      audiodevin[_ORBIT_tmpvar_0])
                                 * 64);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.audiodevout),
                                 sizeof(cfg.
                                      audiodevout
                                      [_ORBIT_tmpvar_1]) * 64);
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.rfsquelch),
                                 sizeof(cfg.rfsquelch));
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.audiosquelch),
                                 sizeof(cfg.audiosquelch));
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_BaycomUSBAdapterSetConfig(POA_Trx_Control *
                                      _ORBIT_servant,
                                      GIOPRecvBuffer *
                                      _ORBIT_recv_buffer,
                                      CORBA_Environment * ev,
                                      void
                                      (*_impl_BaycomUSBAdapterSetConfig)
                                      (PortableServer_Servant
                                       _servant,
                                       const
                                       Trx_BaycomUSBAdapterConfig
                                       * cfg,
                                       CORBA_Environment * ev))
{
   Trx_BaycomUSBAdapterConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      register CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (cfg.mode))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.fclk))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.bitraterx))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.bitratetx))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.loopback))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       cfg.pttmute = *((CORBA_boolean *) _ORBIT_curptr);
       _ORBIT_curptr += 1;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (cfg.filtmode))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.samplerate))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.gain))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       memcpy(cfg.audiodevin, _ORBIT_curptr,
            sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64);
       _ORBIT_curptr += sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64;
       memcpy(cfg.audiodevout, _ORBIT_curptr,
            sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64);
       _ORBIT_curptr += sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (cfg.rfsquelch))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       cfg.audiosquelch = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       cfg.mode = *((Trx_BaycomUSBAdapterMode *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.fclk = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.bitraterx = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.bitratetx = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.loopback = *((Trx_BaycomUSBAdapterLoopback *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.pttmute = *((CORBA_boolean *) _ORBIT_curptr);
       _ORBIT_curptr += 1;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       cfg.filtmode = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.samplerate = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.gain = *((CORBA_float *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       memcpy(cfg.audiodevin, _ORBIT_curptr,
            sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64);
       _ORBIT_curptr += sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64;
       memcpy(cfg.audiodevout, _ORBIT_curptr,
            sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64);
       _ORBIT_curptr += sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64;
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       cfg.rfsquelch = *((Trx_signalstrength *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       cfg.audiosquelch = *((CORBA_boolean *) _ORBIT_curptr);
      }
   }
   _impl_BaycomUSBAdapterSetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_BaycomUSBAdapterGetAudioDevices(POA_Trx_Control *
                                          _ORBIT_servant,
                                          GIOPRecvBuffer *
                                          _ORBIT_recv_buffer,
                                          CORBA_Environment *
                                          ev,
                                          void
                                          (*_impl_BaycomUSBAdapterGetAudioDevices)
                                          (PortableServer_Servant
                                           _servant,
                                           Trx_BaycomUSBAdapterAudioDevs
                                           ** devs,
                                           CORBA_Environment *
                                           ev))
{
   Trx_BaycomUSBAdapterAudioDevs *devs;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_BaycomUSBAdapterGetAudioDevices(_ORBIT_servant, &(devs), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          register CORBA_unsigned_long _ORBIT_tmpvar_1;
          register CORBA_unsigned_long _ORBIT_tmpvar_2;
          register CORBA_unsigned_long _ORBIT_tmpvar_3;

          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*devs).audiodevsin._length));
             memcpy(_ORBIT_t, &((*devs).audiodevsin._length),
                  sizeof((*devs).audiodevsin._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*devs).audiodevsin.
                                         _length));
          }
          {
             guchar *_ORBIT_t;

             _ORBIT_t =
              alloca(sizeof((*devs).audiodevsin._buffer[_ORBIT_tmpvar_0])
                   * (*devs).audiodevsin._length);
             memcpy(_ORBIT_t, ((*devs).audiodevsin._buffer),
                  sizeof((*devs).audiodevsin._buffer[_ORBIT_tmpvar_0]) *
                  (*devs).audiodevsin._length);
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*devs).audiodevsin.
                                         _buffer[_ORBIT_tmpvar_0])
                                    * (*devs).audiodevsin._length);
          }
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*devs).audiodevsout._length));
             memcpy(_ORBIT_t, &((*devs).audiodevsout._length),
                  sizeof((*devs).audiodevsout._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*devs).audiodevsout.
                                         _length));
          }
          {
             guchar *_ORBIT_t;

             _ORBIT_t =
              alloca(sizeof((*devs).audiodevsout._buffer[_ORBIT_tmpvar_2])
                   * (*devs).audiodevsout._length);
             memcpy(_ORBIT_t, ((*devs).audiodevsout._buffer),
                  sizeof((*devs).audiodevsout._buffer[_ORBIT_tmpvar_2]) *
                  (*devs).audiodevsout._length);
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*devs).audiodevsout.
                                         _buffer[_ORBIT_tmpvar_2])
                                    * (*devs).audiodevsout._length);
          }
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(devs);
   }
}
void
_ORBIT_skel_Trx_Control_ChannelAccessGetConfig(POA_Trx_Control *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     void
                                     (*_impl_ChannelAccessGetConfig)
                                     (PortableServer_Servant
                                    _servant,
                                    Trx_ChannelAccessConfig * cfg,
                                    CORBA_Environment * ev))
{
   Trx_ChannelAccessConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_ChannelAccessGetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(cfg),
                                 sizeof(cfg));
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_ChannelAccessSetConfig(POA_Trx_Control *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     void
                                     (*_impl_ChannelAccessSetConfig)
                                     (PortableServer_Servant
                                    _servant,
                                    const Trx_ChannelAccessConfig
                                    * cfg,
                                    CORBA_Environment * ev))
{
   Trx_ChannelAccessConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (cfg.txdelay))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.slottime))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.ppersistence))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.txtail))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       cfg.fullduplex = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       memcpy(&(cfg), _ORBIT_curptr, sizeof(cfg));
      }
   }
   _impl_ChannelAccessSetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_InterfaceGetConfig(POA_Trx_Control * _ORBIT_servant,
                                 GIOPRecvBuffer *
                                 _ORBIT_recv_buffer,
                                 CORBA_Environment * ev,
                                 void (*_impl_InterfaceGetConfig)
                                 (PortableServer_Servant _servant,
                                  Trx_InterfaceConfig * cfg,
                                  CORBA_Environment * ev))
{
   Trx_InterfaceConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_InterfaceGetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;
          register CORBA_unsigned_long _ORBIT_tmpvar_1;
          register CORBA_unsigned_long _ORBIT_tmpvar_2;
          register CORBA_unsigned_long _ORBIT_tmpvar_3;
          register CORBA_unsigned_long _ORBIT_tmpvar_4;
          register CORBA_unsigned_long _ORBIT_tmpvar_5;
          register CORBA_unsigned_long _ORBIT_tmpvar_6;
          register CORBA_unsigned_long _ORBIT_tmpvar_7;

          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), (cfg.ifname),
                                 sizeof(cfg.
                                      ifname[_ORBIT_tmpvar_0]) *
                                 16);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), (cfg.hwaddr),
                                 sizeof(cfg.
                                      hwaddr[_ORBIT_tmpvar_1]) *
                                 16);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), (cfg.ipaddr),
                                 sizeof(cfg.
                                      ipaddr[_ORBIT_tmpvar_2]) *
                                 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.netmask),
                                 sizeof(cfg.
                                      netmask[_ORBIT_tmpvar_3]) *
                                 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.broadcast),
                                 sizeof(cfg.
                                      broadcast[_ORBIT_tmpvar_4])
                                 * 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.gwhwaddr),
                                 sizeof(cfg.
                                      gwhwaddr[_ORBIT_tmpvar_5]) *
                                 128);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.gwipaddr),
                                 sizeof(cfg.
                                      gwipaddr[_ORBIT_tmpvar_6]) *
                                 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 (cfg.gwnetmask),
                                 sizeof(cfg.
                                      gwnetmask[_ORBIT_tmpvar_7])
                                 * 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer),
                                 &(cfg.gwipmode),
                                 sizeof(cfg.gwipmode));
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_InterfaceSetConfig(POA_Trx_Control * _ORBIT_servant,
                                 GIOPRecvBuffer *
                                 _ORBIT_recv_buffer,
                                 CORBA_Environment * ev,
                                 void (*_impl_InterfaceSetConfig)
                                 (PortableServer_Servant _servant,
                                  const Trx_InterfaceConfig * cfg,
                                  CORBA_Environment * ev))
{
   Trx_InterfaceConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_8;
      register CORBA_unsigned_long _ORBIT_tmpvar_9;
      register CORBA_unsigned_long _ORBIT_tmpvar_10;
      register CORBA_unsigned_long _ORBIT_tmpvar_11;
      register CORBA_unsigned_long _ORBIT_tmpvar_12;
      register CORBA_unsigned_long _ORBIT_tmpvar_13;
      register CORBA_unsigned_long _ORBIT_tmpvar_14;
      register CORBA_unsigned_long _ORBIT_tmpvar_15;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       memcpy(cfg.ifname, _ORBIT_curptr,
            sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16);
       _ORBIT_curptr += sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16;
       memcpy(cfg.hwaddr, _ORBIT_curptr,
            sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16);
       _ORBIT_curptr += sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16;
       memcpy(cfg.ipaddr, _ORBIT_curptr,
            sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4);
       _ORBIT_curptr += sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4;
       memcpy(cfg.netmask, _ORBIT_curptr,
            sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4);
       _ORBIT_curptr += sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4;
       memcpy(cfg.broadcast, _ORBIT_curptr,
            sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4);
       _ORBIT_curptr += sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4;
       memcpy(cfg.gwhwaddr, _ORBIT_curptr,
            sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128);
       _ORBIT_curptr += sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128;
       memcpy(cfg.gwipaddr, _ORBIT_curptr,
            sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4);
       _ORBIT_curptr += sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4;
       memcpy(cfg.gwnetmask, _ORBIT_curptr,
            sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4);
       _ORBIT_curptr += sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4;
       cfg.gwipmode = *((CORBA_char *) _ORBIT_curptr);
      } else {
       memcpy(cfg.ifname, _ORBIT_curptr,
            sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16);
       _ORBIT_curptr += sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16;
       memcpy(cfg.hwaddr, _ORBIT_curptr,
            sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16);
       _ORBIT_curptr += sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16;
       memcpy(cfg.ipaddr, _ORBIT_curptr,
            sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4);
       _ORBIT_curptr += sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4;
       memcpy(cfg.netmask, _ORBIT_curptr,
            sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4);
       _ORBIT_curptr += sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4;
       memcpy(cfg.broadcast, _ORBIT_curptr,
            sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4);
       _ORBIT_curptr += sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4;
       memcpy(cfg.gwhwaddr, _ORBIT_curptr,
            sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128);
       _ORBIT_curptr += sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128;
       memcpy(cfg.gwipaddr, _ORBIT_curptr,
            sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4);
       _ORBIT_curptr += sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4;
       memcpy(cfg.gwnetmask, _ORBIT_curptr,
            sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4);
       _ORBIT_curptr += sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4;
       cfg.gwipmode = *((CORBA_char *) _ORBIT_curptr);
      }
   }
   _impl_InterfaceSetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_ModemDisconnectGetConfig(POA_Trx_Control *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     void
                                     (*_impl_ModemDisconnectGetConfig)
                                     (PortableServer_Servant
                                      _servant,
                                      Trx_ModemDisconnectConfig *
                                      cfg,
                                      CORBA_Environment * ev))
{
   Trx_ModemDisconnectConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_ModemDisconnectGetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(cfg),
                                 sizeof(cfg));
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_ModemDisconnectSetConfig(POA_Trx_Control *
                                     _ORBIT_servant,
                                     GIOPRecvBuffer *
                                     _ORBIT_recv_buffer,
                                     CORBA_Environment * ev,
                                     void
                                     (*_impl_ModemDisconnectSetConfig)
                                     (PortableServer_Servant
                                      _servant,
                                      const
                                      Trx_ModemDisconnectConfig *
                                      cfg,
                                      CORBA_Environment * ev))
{
   Trx_ModemDisconnectConfig cfg;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (cfg.output))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.direction))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.rxc))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.txc))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (cfg.txd))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       memcpy(&(cfg), _ORBIT_curptr, sizeof(cfg));
      }
   }
   _impl_ModemDisconnectSetConfig(_ORBIT_servant, &(cfg), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_GetAudioState(POA_Trx_Control * _ORBIT_servant,
                              GIOPRecvBuffer * _ORBIT_recv_buffer,
                              CORBA_Environment * ev,
                              void (*_impl_GetAudioState)
                              (PortableServer_Servant _servant,
                               Trx_TrxAudioState * state,
                               CORBA_Environment * ev))
{
   Trx_TrxAudioState state;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
   }
   _impl_GetAudioState(_ORBIT_servant, &(state), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                 (_ORBIT_send_buffer), &(state),
                                 sizeof(state));
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_GetAudioMicSamples(POA_Trx_Control * _ORBIT_servant,
                                 GIOPRecvBuffer *
                                 _ORBIT_recv_buffer,
                                 CORBA_Environment * ev,
                                 void (*_impl_GetAudioMicSamples)
                                 (PortableServer_Servant _servant,
                                  const CORBA_unsigned_long ptr,
                                  const CORBA_unsigned_long len,
                                  Trx_TrxAudioSamples ** samples,
                                  CORBA_Environment * ev))
{
   CORBA_unsigned_long ptr;
   CORBA_unsigned_long len;
   Trx_TrxAudioSamples *samples;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (ptr))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (len))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       ptr = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       len = *((CORBA_unsigned_long *) _ORBIT_curptr);
      }
   }
   _impl_GetAudioMicSamples(_ORBIT_servant, ptr, len, &(samples), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;

          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*samples)._length));
             memcpy(_ORBIT_t, &((*samples)._length),
                  sizeof((*samples)._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*samples)._length));
          }
          {
             guchar *_ORBIT_t;

             _ORBIT_t =
              alloca(sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
                   (*samples)._length);
             memcpy(_ORBIT_t, ((*samples)._buffer),
                  sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
                  (*samples)._length);
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*samples).
                                         _buffer[_ORBIT_tmpvar_0])
                                    * (*samples)._length);
          }
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(samples);
   }
}
void
_ORBIT_skel_Trx_Control_GetAudioSpkSamples(POA_Trx_Control * _ORBIT_servant,
                                 GIOPRecvBuffer *
                                 _ORBIT_recv_buffer,
                                 CORBA_Environment * ev,
                                 void (*_impl_GetAudioSpkSamples)
                                 (PortableServer_Servant _servant,
                                  const CORBA_unsigned_long ptr,
                                  const CORBA_unsigned_long len,
                                  Trx_TrxAudioSamples ** samples,
                                  CORBA_Environment * ev))
{
   CORBA_unsigned_long ptr;
   CORBA_unsigned_long len;
   Trx_TrxAudioSamples *samples;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (ptr))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       (*((guint32 *) & (len))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       ptr = *((CORBA_unsigned_long *) _ORBIT_curptr);
       _ORBIT_curptr += 4;
       len = *((CORBA_unsigned_long *) _ORBIT_curptr);
      }
   }
   _impl_GetAudioSpkSamples(_ORBIT_servant, ptr, len, &(samples), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
          register CORBA_unsigned_long _ORBIT_tmpvar_0;

          giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
                                   (_ORBIT_send_buffer), 4);
          {
             guchar *_ORBIT_t;

             _ORBIT_t = alloca(sizeof((*samples)._length));
             memcpy(_ORBIT_t, &((*samples)._length),
                  sizeof((*samples)._length));
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*samples)._length));
          }
          {
             guchar *_ORBIT_t;

             _ORBIT_t =
              alloca(sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
                   (*samples)._length);
             memcpy(_ORBIT_t, ((*samples)._buffer),
                  sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
                  (*samples)._length);
             giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
                                    (_ORBIT_send_buffer),
                                    (_ORBIT_t),
                                    sizeof((*samples).
                                         _buffer[_ORBIT_tmpvar_0])
                                    * (*samples)._length);
          }
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
       CORBA_free(samples);
   }
}
void
_ORBIT_skel_Trx_Control_SetAudioDTMF(POA_Trx_Control * _ORBIT_servant,
                             GIOPRecvBuffer * _ORBIT_recv_buffer,
                             CORBA_Environment * ev,
                             void (*_impl_SetAudioDTMF)
                             (PortableServer_Servant _servant,
                              const CORBA_long ch,
                              CORBA_Environment * ev))
{
   CORBA_long ch;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (ch))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       ch = *((CORBA_long *) _ORBIT_curptr);
      }
   }
   _impl_SetAudioDTMF(_ORBIT_servant, ch, ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else if (ev->_major == CORBA_USER_EXCEPTION) {
          static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
             =
             { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
              (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
                                              NULL} };
          ORBit_send_user_exception(_ORBIT_send_buffer, ev,
                              _ORBIT_user_exceptions);
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_SetAudioParams(POA_Trx_Control * _ORBIT_servant,
                               GIOPRecvBuffer * _ORBIT_recv_buffer,
                               CORBA_Environment * ev,
                               void (*_impl_SetAudioParams)
                               (PortableServer_Servant _servant,
                              const Trx_TrxAudioParams * params,
                              CORBA_Environment * ev))
{
   Trx_TrxAudioParams params;

   {                    /* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       (*((guint32 *) & (params.rfsquelch))) =
          GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
       _ORBIT_curptr += 4;
       params.audiosquelch = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
       _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
       memcpy(&(params), _ORBIT_curptr, sizeof(params));
      }
   }
   _impl_SetAudioParams(_ORBIT_servant, &(params), ev);
   {                    /* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
       giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
                            connection, NULL,
                            _ORBIT_recv_buffer->message.u.request.
                            request_id, ev->_major);
      if (_ORBIT_send_buffer) {
       if (ev->_major == CORBA_NO_EXCEPTION) {
       } else
          ORBit_send_system_exception(_ORBIT_send_buffer, ev);
       giop_send_buffer_write(_ORBIT_send_buffer);
       giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
static ORBitSkeleton
get_skel_Trx_Control(POA_Trx_Control * servant,
                 GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'B':
      switch (opname[1]) {
        case 'a':
           switch (opname[2]) {
             case 'y':
              switch (opname[3]) {
                case 'c':
                   switch (opname[4]) {
                   case 'o':
                      switch (opname[5]) {
                        case 'm':
                         switch (opname[6]) {
                           case 'U':
                              switch (opname[7]) {
                              case 'S':
                                 switch (opname[8]) {
                                   case 'B':
                                    switch (opname[9]) {
                                      case 'A':
                                         switch (opname[10]) {
                                           case 'd':
                                            switch (opname[11]) {
                                              case 'a':
                                                 switch (opname
                                                       [12]) {
                                                 case 'p':
                                                    switch
                                                       (opname
                                                      [13])
                                                      {
                                                      case 't':
                                                       switch
                                                          (opname
                                                           [14])
                                                         {
                                                         case 'e':
                                                            switch
                                                             (opname
                                                              [15])
                                                            {
                                                            case 'r':
                                                               switch
                                                                  (opname
                                                                   [16])
                                                                 {
                                                                 case 'G':
                                                                  switch
                                                                     (opname
                                                                      [17])
                                                                    {
                                                                    case 'e':
                                                                       switch
                                                                        (opname
                                                                         [18])
                                                                         {
                                                                         case 't':
                                                                          switch
                                                                             (opname
                                                                              [19])
                                                                            {
                                                                            case 'A':
                                                                               if (strcmp((opname + 20), "udioDevices"))
                                                                                break;
                                                                               *impl
                                                                                =
                                                                                (gpointer)
                                                                                servant->
                                                                                vepv->
                                                                                Trx_Control_epv->
                                                                                BaycomUSBAdapterGetAudioDevices;
                                                                               return
                                                                                (ORBitSkeleton)
                                                                                _ORBIT_skel_Trx_Control_BaycomUSBAdapterGetAudioDevices;
                                                                               break;
                                                                            case 'C':
                                                                               if (strcmp((opname + 20), "onfig"))
                                                                                break;
                                                                               *impl
                                                                                =
                                                                                (gpointer)
                                                                                servant->
                                                                                vepv->
                                                                                Trx_Control_epv->
                                                                                BaycomUSBAdapterGetConfig;
                                                                               return
                                                                                (ORBitSkeleton)
                                                                                _ORBIT_skel_Trx_Control_BaycomUSBAdapterGetConfig;
                                                                               break;
                                                                            default:
                                                                               break;
                                                                          }
                                                                          break;
                                                                         default:
                                                                          break;
                                                                       }
                                                                       break;
                                                                    default:
                                                                       break;
                                                                  }
                                                                  break;
                                                                 case 'S':
                                                                  if (strcmp((opname + 17), "etConfig"))
                                                                     break;
                                                                  *impl
                                                                     =
                                                                     (gpointer)
                                                                     servant->
                                                                     vepv->
                                                                     Trx_Control_epv->
                                                                     BaycomUSBAdapterSetConfig;
                                                                  return
                                                                     (ORBitSkeleton)
                                                                     _ORBIT_skel_Trx_Control_BaycomUSBAdapterSetConfig;
                                                                  break;
                                                                 default:
                                                                  break;
                                                               }
                                                               break;
                                                            default:
                                                               break;
                                                            }
                                                            break;
                                                         default:
                                                            break;
                                                       }
                                                       break;
                                                      default:
                                                       break;
                                                    }
                                                    break;
                                                 default:
                                                    break;
                                                 }
                                                 break;
                                              default:
                                                 break;
                                            }
                                            break;
                                           default:
                                            break;
                                         }
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'C':
      switch (opname[1]) {
        case 'h':
           switch (opname[2]) {
             case 'a':
              switch (opname[3]) {
                case 'n':
                   switch (opname[4]) {
                   case 'n':
                      switch (opname[5]) {
                        case 'e':
                         switch (opname[6]) {
                           case 'l':
                              switch (opname[7]) {
                              case 'A':
                                 switch (opname[8]) {
                                   case 'c':
                                    switch (opname[9]) {
                                      case 'c':
                                         switch (opname[10]) {
                                           case 'e':
                                            switch (opname[11]) {
                                              case 's':
                                                 switch (opname
                                                       [12]) {
                                                 case 's':
                                                    switch
                                                       (opname
                                                      [13])
                                                      {
                                                      case 'G':
                                                       if (strcmp((opname + 14), "etConfig"))
                                                          break;
                                                       *impl
                                                          =
                                                          (gpointer)
                                                          servant->
                                                          vepv->
                                                          Trx_Control_epv->
                                                          ChannelAccessGetConfig;
                                                       return
                                                          (ORBitSkeleton)
                                                          _ORBIT_skel_Trx_Control_ChannelAccessGetConfig;
                                                       break;
                                                      case 'S':
                                                       if (strcmp((opname + 14), "etConfig"))
                                                          break;
                                                       *impl
                                                          =
                                                          (gpointer)
                                                          servant->
                                                          vepv->
                                                          Trx_Control_epv->
                                                          ChannelAccessSetConfig;
                                                       return
                                                          (ORBitSkeleton)
                                                          _ORBIT_skel_Trx_Control_ChannelAccessSetConfig;
                                                       break;
                                                      default:
                                                       break;
                                                    }
                                                    break;
                                                 default:
                                                    break;
                                                 }
                                                 break;
                                              default:
                                                 break;
                                            }
                                            break;
                                           default:
                                            break;
                                         }
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'G':
      switch (opname[1]) {
        case 'e':
           switch (opname[2]) {
             case 't':
              switch (opname[3]) {
                case 'A':
                   switch (opname[4]) {
                   case 'u':
                      switch (opname[5]) {
                        case 'd':
                         switch (opname[6]) {
                           case 'i':
                              switch (opname[7]) {
                              case 'o':
                                 switch (opname[8]) {
                                   case 'M':
                                    if (strcmp
                                        ((opname + 9),
                                         "icSamples"))
                                       break;
                                    *impl =
                                       (gpointer) servant->vepv->
                                       Trx_Control_epv->
                                       GetAudioMicSamples;
                                    return (ORBitSkeleton)
                                       _ORBIT_skel_Trx_Control_GetAudioMicSamples;
                                    break;
                                   case 'S':
                                    switch (opname[9]) {
                                      case 'p':
                                         if (strcmp
                                           ((opname + 10),
                                            "kSamples"))
                                          break;
                                         *impl =
                                          (gpointer) servant->
                                          vepv->
                                          Trx_Control_epv->
                                          GetAudioSpkSamples;
                                         return (ORBitSkeleton)
                                          _ORBIT_skel_Trx_Control_GetAudioSpkSamples;
                                         break;
                                      case 't':
                                         if (strcmp
                                           ((opname + 10),
                                            "ate"))
                                          break;
                                         *impl =
                                          (gpointer) servant->
                                          vepv->
                                          Trx_Control_epv->
                                          GetAudioState;
                                         return (ORBitSkeleton)
                                          _ORBIT_skel_Trx_Control_GetAudioState;
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                case 'D':
                   if (strcmp((opname + 4), "escription"))
                    break;
                   *impl =
                    (gpointer) servant->vepv->Trx_Control_epv->
                    GetDescription;
                   return (ORBitSkeleton)
                    _ORBIT_skel_Trx_Control_GetDescription;
                   break;
                case 'S':
                   if (strcmp((opname + 4), "tate"))
                    break;
                   *impl =
                    (gpointer) servant->vepv->Trx_Control_epv->GetState;
                   return (ORBitSkeleton)
                    _ORBIT_skel_Trx_Control_GetState;
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'I':
      switch (opname[1]) {
        case 'n':
           switch (opname[2]) {
             case 't':
              switch (opname[3]) {
                case 'e':
                   switch (opname[4]) {
                   case 'r':
                      switch (opname[5]) {
                        case 'f':
                         switch (opname[6]) {
                           case 'a':
                              switch (opname[7]) {
                              case 'c':
                                 switch (opname[8]) {
                                   case 'e':
                                    switch (opname[9]) {
                                      case 'G':
                                         if (strcmp
                                           ((opname + 10),
                                            "etConfig"))
                                          break;
                                         *impl =
                                          (gpointer) servant->
                                          vepv->
                                          Trx_Control_epv->
                                          InterfaceGetConfig;
                                         return (ORBitSkeleton)
                                          _ORBIT_skel_Trx_Control_InterfaceGetConfig;
                                         break;
                                      case 'S':
                                         if (strcmp
                                           ((opname + 10),
                                            "etConfig"))
                                          break;
                                         *impl =
                                          (gpointer) servant->
                                          vepv->
                                          Trx_Control_epv->
                                          InterfaceSetConfig;
                                         return (ORBitSkeleton)
                                          _ORBIT_skel_Trx_Control_InterfaceSetConfig;
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'M':
      switch (opname[1]) {
        case 'o':
           switch (opname[2]) {
             case 'd':
              switch (opname[3]) {
                case 'e':
                   switch (opname[4]) {
                   case 'm':
                      switch (opname[5]) {
                        case 'D':
                         switch (opname[6]) {
                           case 'i':
                              switch (opname[7]) {
                              case 's':
                                 switch (opname[8]) {
                                   case 'c':
                                    switch (opname[9]) {
                                      case 'o':
                                         switch (opname[10]) {
                                           case 'n':
                                            switch (opname[11]) {
                                              case 'n':
                                                 switch (opname
                                                       [12]) {
                                                 case 'e':
                                                    switch
                                                       (opname
                                                      [13])
                                                      {
                                                      case 'c':
                                                       switch
                                                          (opname
                                                           [14])
                                                         {
                                                         case 't':
                                                            switch
                                                             (opname
                                                              [15])
                                                            {
                                                            case 'G':
                                                               if (strcmp((opname + 16), "etConfig"))
                                                                  break;
                                                               *impl
                                                                  =
                                                                  (gpointer)
                                                                  servant->
                                                                  vepv->
                                                                  Trx_Control_epv->
                                                                  ModemDisconnectGetConfig;
                                                               return
                                                                  (ORBitSkeleton)
                                                                  _ORBIT_skel_Trx_Control_ModemDisconnectGetConfig;
                                                               break;
                                                            case 'S':
                                                               if (strcmp((opname + 16), "etConfig"))
                                                                  break;
                                                               *impl
                                                                  =
                                                                  (gpointer)
                                                                  servant->
                                                                  vepv->
                                                                  Trx_Control_epv->
                                                                  ModemDisconnectSetConfig;
                                                               return
                                                                  (ORBitSkeleton)
                                                                  _ORBIT_skel_Trx_Control_ModemDisconnectSetConfig;
                                                               break;
                                                            default:
                                                               break;
                                                            }
                                                            break;
                                                         default:
                                                            break;
                                                       }
                                                       break;
                                                      default:
                                                       break;
                                                    }
                                                    break;
                                                 default:
                                                    break;
                                                 }
                                                 break;
                                              default:
                                                 break;
                                            }
                                            break;
                                           default:
                                            break;
                                         }
                                         break;
                                      default:
                                         break;
                                    }
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'S':
      switch (opname[1]) {
        case 'e':
           switch (opname[2]) {
             case 't':
              switch (opname[3]) {
                case 'A':
                   switch (opname[4]) {
                   case 'u':
                      switch (opname[5]) {
                        case 'd':
                         switch (opname[6]) {
                           case 'i':
                              switch (opname[7]) {
                              case 'o':
                                 switch (opname[8]) {
                                   case 'D':
                                    if (strcmp
                                        ((opname + 9), "TMF"))
                                       break;
                                    *impl =
                                       (gpointer) servant->vepv->
                                       Trx_Control_epv->
                                       SetAudioDTMF;
                                    return (ORBitSkeleton)
                                       _ORBIT_skel_Trx_Control_SetAudioDTMF;
                                    break;
                                   case 'P':
                                    if (strcmp
                                        ((opname + 9), "arams"))
                                       break;
                                    *impl =
                                       (gpointer) servant->vepv->
                                       Trx_Control_epv->
                                       SetAudioParams;
                                    return (ORBitSkeleton)
                                       _ORBIT_skel_Trx_Control_SetAudioParams;
                                    break;
                                   default:
                                    break;
                                 }
                                 break;
                              default:
                                 break;
                              }
                              break;
                           default:
                              break;
                         }
                         break;
                        default:
                         break;
                      }
                      break;
                   default:
                      break;
                   }
                   break;
                case 'F':
                   if (strcmp((opname + 4), "requency"))
                    break;
                   *impl =
                    (gpointer) servant->vepv->Trx_Control_epv->
                    SetFrequency;
                   return (ORBitSkeleton)
                    _ORBIT_skel_Trx_Control_SetFrequency;
                   break;
                case 'P':
                   if (strcmp((opname + 4), "TT"))
                    break;
                   *impl =
                    (gpointer) servant->vepv->Trx_Control_epv->SetPTT;
                   return (ORBitSkeleton) _ORBIT_skel_Trx_Control_SetPTT;
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     case 'U':
      switch (opname[1]) {
        case 'a':
           switch (opname[2]) {
             case 'r':
              switch (opname[3]) {
                case 't':
                   switch (opname[4]) {
                   case 'R':
                      if (strcmp((opname + 5), "eceive"))
                         break;
                      *impl =
                         (gpointer) servant->vepv->Trx_Control_epv->
                         UartReceive;
                      return (ORBitSkeleton)
                         _ORBIT_skel_Trx_Control_UartReceive;
                      break;
                   case 'S':
                      if (strcmp((opname + 5), "end"))
                         break;
                      *impl =
                         (gpointer) servant->vepv->Trx_Control_epv->
                         UartSend;
                      return (ORBitSkeleton)
                         _ORBIT_skel_Trx_Control_UartSend;
                      break;
                   default:
                      break;
                   }
                   break;
                default:
                   break;
              }
              break;
             default:
              break;
           }
           break;
        default:
           break;
      }
      break;
     default:
      break;
   }
   return NULL;
}

static void
init_local_objref_Trx_Control(CORBA_Object obj, POA_Trx_Control * servant)
{
   obj->vepv[Trx_Control__classid] = servant->vepv->Trx_Control_epv;
}

void
POA_Trx_Control__init(PortableServer_Servant servant, CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_Trx_Control, "IDL:Trx/Control:1.0",
(ORBit_local_objref_init) & init_local_objref_Trx_Control };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
                            env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!Trx_Control__classid)
      Trx_Control__classid = ORBit_register_class(&class_info);
}

void
POA_Trx_Control__fini(PortableServer_Servant servant, CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

Generated by  Doxygen 1.6.0   Back to index