/* $XConsortium: MrmIswap.c /main/7 1996/11/13 13:58:35 drk $ */
/*
* Motif
*
* Copyright (c) 1987-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these librararies and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/*
* HISTORY
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*
*++
* FACILITY:
*
* UIL Resource Manager (URM): IDB Facility
* Byte Swap routines for IDB records
*
* ABSTRACT:
*
*
*--
*/
/*
*
* INCLUDE FILES
*
*/
#include <stdio.h>
#include <Mrm/MrmAppl.h>
#include <Mrm/Mrm.h>
#include <Mrm/IDB.h>
#include "MrmosI.h"
#include "MrmMsgI.h"
/*
*++
*
* PROCEDURE DESCRIPTION:
*
* Idb__BM_SwapBytes performs byte swapping on the (currently 6)
* record types in an IDB file
*
* FORMAL PARAMETERS:
*
* buffer Record buffer to swap in place
*
* IMPLICIT INPUTS:
*
* IMPLICIT OUTPUTS:
*
* FUNCTION VALUE:
*
* MrmSUCCESS operation succeeded
* MrmFAILURE some other failure
*
* SIDE EFFECTS:
*
*--
*/
Cardinal
Idb__BM_SwapRecordBytes (IDBRecordBufferPtr buffer)
{
/*
* Local variables
*/
Cardinal ndx; /* loop index */
IDBDummyRecordPtr idb_record; /* pointer to the generic IDB record */
IDBRecordHeaderPtr idb_header; /* pointer to hdr w/type and record # */
IDBHeaderRecordPtr header_rec; /* pointer to record type IDBrtHeader */
IDBHeaderHdrPtr header_hdr; /* pointer to the header in the header */
IDBIndexLeafRecordPtr leaf_rec; /* pointer to record type IDBrtIndexLeaf */
IDBIndexNodeRecordPtr node_rec; /* pointer to record type IDBrtIndexNode */
IDBridMapRecordPtr ridmap_rec; /* pointer to record type IDBrtRIDMap */
IDBDataRecordPtr data_rec; /* pointer to record type IDBrtData */
char err_msg[300] ;
if ( ! Idb__BM_Valid(buffer) )
return Urm__UT_Error("Idb__BM_MarkActivity", _MrmMMsg_0002,
NULL, NULL, MrmNOT_VALID) ;
/* load pointers to the record and record header */
idb_record = (IDBDummyRecordPtr) buffer->IDB_record ;
idb_header = (IDBRecordHeaderPtr)&idb_record->header ;
/* swap the remaining record entries in IDBRecordHeader */
swapbytes( idb_header->record_type ) ;
swapbytes( idb_header->record_num ) ;
/*
* Swap IDB record items based on record type
*/
switch ( idb_header->record_type )
{
case IDBrtHeader:
header_rec = (IDBHeaderRecordPtr)buffer->IDB_record ;
header_hdr = (IDBHeaderHdrPtr)&header_rec->header_hdr ;
/* swap the HeaderHdr first */
swapbytes( header_hdr->index_root );
swapbytes( header_hdr->num_indexed );
swapbytes( header_hdr->num_RID );
/* VAR check */
#ifdef WORD64
swap4bytes( header_hdr->next_RID.internal_id.map_rec );
swap4bytes( header_hdr->next_RID.internal_id.res_index );
#else
swap2bytes( header_hdr->next_RID.internal_id.map_rec );
swap2bytes( header_hdr->next_RID.internal_id.res_index );
#endif
swapbytes( header_hdr->last_record );
swapbytes( header_hdr->last_data_record );
for( ndx=0 ; ndx < URMgVecSize ; ndx++)
swapbytes(header_hdr->group_counts[ndx]);
for( ndx=0 ; ndx < IDBrtVecSize ; ndx++)
swapbytes(header_hdr->rt_counts[ndx]);
/* now swap the rest of the header */
/* VAR check */
for( ndx=0 ; ndx < IDBHeaderRIDMax ; ndx++)
{
swap2bytes(header_rec->RID_pointers[ndx].internal_id.rec_no);
swap2bytes(header_rec->RID_pointers[ndx].internal_id.item_offs);
}
swapbytes( header_rec->num_entry );
swapbytes( header_rec->last_entry );
swapbytes( header_rec->free_ptr );
swapbytes( header_rec->free_count );
break;
case IDBrtIndexLeaf:
leaf_rec = (IDBIndexLeafRecordPtr)buffer->IDB_record ;
swapbytes( leaf_rec->leaf_header.parent );
swapbytes( leaf_rec->leaf_header.index_count );
swapbytes( leaf_rec->leaf_header.heap_start );
swapbytes( leaf_rec->leaf_header.free_bytes );
for( ndx=0 ; ndx < leaf_rec->leaf_header.index_count ; ndx++ )
{
swapbytes( leaf_rec->index[ndx].index_stg );
swap2bytes( leaf_rec->index[ndx].data.internal_id.rec_no );
swap2bytes( leaf_rec->index[ndx].data.internal_id.item_offs );
}
break;
case IDBrtIndexNode:
node_rec = (IDBIndexNodeRecordPtr)buffer->IDB_record ;
swapbytes( node_rec->node_header.parent );
swapbytes( node_rec->node_header.index_count );
swapbytes( node_rec->node_header.heap_start );
swapbytes( node_rec->node_header.free_bytes );
for( ndx=0 ; ndx < node_rec->node_header.index_count ; ndx++ )
{
swapbytes( node_rec->index[ndx].index_stg );
swap2bytes( node_rec->index[ndx].data.internal_id.rec_no );
swap2bytes( node_rec->index[ndx].data.internal_id.item_offs );
swapbytes( node_rec->index[ndx].LT_record );
swapbytes( node_rec->index[ndx].GT_record );
}
break;
case IDBrtRIDMap:
ridmap_rec = (IDBridMapRecordPtr)buffer->IDB_record ;
ndx = 0;
while ( (ndx < IDBridPtrVecMax) &&
(ridmap_rec->pointers[ndx].internal_id.rec_no != 0) )
{
swap2bytes( ridmap_rec->pointers[ndx].internal_id.rec_no );
swap2bytes( ridmap_rec->pointers[ndx].internal_id.item_offs );
ndx++;
}
break;
case IDBrtData:
data_rec = (IDBDataRecordPtr)buffer->IDB_record ;
swapbytes( data_rec->data_header.num_entry );
swapbytes( data_rec->data_header.last_entry );
swapbytes( data_rec->data_header.free_ptr );
swapbytes( data_rec->data_header.free_count );
break;
default:
sprintf(err_msg, _MrmMMsg_0020, idb_header->record_num,
idb_header->record_type);
return Urm__UT_Error ("Idb__BM_SwapRecordBytes",
err_msg, NULL, NULL, MrmFAILURE) ;
}
return MrmSUCCESS ;
}
unsigned
Urm__SwapValidation (unsigned validation)
{
swapbytes(validation);
return validation;
}
Cardinal
Urm__SwapRGMResourceDesc (RGMResourceDescPtr res_desc)
{
IDBridDesc *idb_rid_ptr;
swapbytes( res_desc->size );
swapbytes( res_desc->annex1 );
if ( res_desc->type == URMrRID )
{
idb_rid_ptr = (IDBridDesc *)&(res_desc->key.id);
#ifdef WORD64
swap4bytes( idb_rid_ptr->internal_id.map_rec );
swap4bytes( idb_rid_ptr->internal_id.res_index );
#else
swap2bytes( idb_rid_ptr->internal_id.map_rec );
swap2bytes( idb_rid_ptr->internal_id.res_index );
#endif
}
return MrmSUCCESS;
}
Cardinal
Urm__SwapRGMCallbackDesc (RGMCallbackDescPtr callb_desc,
RGMWidgetRecordPtr widget_rec)
{
Cardinal ndx; /* inner loop index */
RGMResourceDescPtr res_desc; /* resource description literal */
char err_msg[300];
swapbytes( callb_desc->validation );
swapbytes( callb_desc->count );
swapbytes( callb_desc->annex );
swapbytes( callb_desc->unres_ref_count );
for (ndx=0 ; ndx < callb_desc->count ; ndx++)
{
#ifdef WORD64
swap4bytes( callb_desc->item[ndx].cb_item.routine );
swap4bytes( callb_desc->item[ndx].cb_item.rep_type );
#else
swap2bytes( callb_desc->item[ndx].cb_item.routine );
swap2bytes( callb_desc->item[ndx].cb_item.rep_type );
#endif
switch (callb_desc->item[ndx].cb_item.rep_type)
{
case MrmRtypeInteger:
case MrmRtypeBoolean:
swapbytes( callb_desc->item[ndx].cb_item.datum.ival );
break;
case MrmRtypeSingleFloat:
swapbytes( callb_desc->item[ndx].cb_item.datum.ival );
_MrmOSIEEEFloatToHost((float *)
&(callb_desc->item[ndx].cb_item.datum.ival));
case MrmRtypeNull:
break;
case MrmRtypeResource:
swapbytes( callb_desc->item[ndx].cb_item.datum.offset );
res_desc = (RGMResourceDesc *)
((char *)widget_rec + callb_desc->item[ndx].cb_item.datum.offset);
Urm__SwapRGMResourceDesc( res_desc );
/* flag this resource as needing further byte swapping */
res_desc->cvt_type |= MrmResourceUnswapped;
break;
default:
swapbytes( callb_desc->item[ndx].cb_item.datum.offset );
sprintf(err_msg, _MrmMMsg_0021,
callb_desc->item[ndx].cb_item.rep_type, ndx);
return Urm__UT_Error ("Urm__SwapRGMCallbackDesc",
err_msg, NULL, NULL, MrmFAILURE) ;
break;
}
}
return MrmSUCCESS;
}
/*
*++
*
* PROCEDURE DESCRIPTION:
*
*
* FORMAL PARAMETERS:
*
* buffer Record buffer to swap in place
*
* IMPLICIT INPUTS:
*
* IMPLICIT OUTPUTS:
*
* FUNCTION VALUE:
*
* MrmSUCCESS operation succeeded
* MrmFAILURE some other failure
*
* SIDE EFFECTS:
*
*--
*/
Cardinal
Urm__SwapRGMWidgetRecord(RGMWidgetRecordPtr widget_rec)
{
/*
* Local variables
*/
RGMArgListDescPtr arg_list; /* pointer to widget arglist */
RGMChildrenDescPtr child_list; /* pointer to the widgets children */
RGMResourceDescPtr res_desc; /* resource description literal */
RGMCallbackDescPtr callb_desc; /* pointer to a callback decriptor */
Cardinal ndx; /* loop index */
IDBridDesc *idb_rid_ptr;
void *offset; /* generic offset pointer */
char err_msg[300];
/* Swap the main part of the widget record */
swapbytes( widget_rec->size );
swapbytes( widget_rec->access );
swapbytes( widget_rec->lock );
swapbytes( widget_rec->type );
swapbytes( widget_rec->name_offs );
swapbytes( widget_rec->class_offs );
swapbytes( widget_rec->arglist_offs );
swapbytes( widget_rec->children_offs );
swapbytes( widget_rec->comment_offs );
swapbytes( widget_rec->creation_offs );
swapbytes( widget_rec->variety );
swapbytes( widget_rec->annex );
/* handle the argument list */
if (widget_rec->arglist_offs > 0)
{
arg_list = (RGMArgListDesc *)
((char *)widget_rec + widget_rec->arglist_offs);
swapbytes( arg_list->count );
swapbytes( arg_list->extra );
for ( ndx=0 ; ndx<arg_list->count ; ndx++ )
{
swapbytes( arg_list->args[ndx].tag_code );
swapbytes( arg_list->args[ndx].stg_or_relcode.tag_offs );
swapbytes( arg_list->args[ndx].arg_val.rep_type );
switch( arg_list->args[ndx].arg_val.rep_type )
{
case MrmRtypeInteger:
case MrmRtypeBoolean:
swapbytes( arg_list->args[ndx].arg_val.datum.ival );
break;
case MrmRtypeSingleFloat:
swapbytes( arg_list->args[ndx].arg_val.datum.ival );
_MrmOSIEEEFloatToHost((float *)
&(arg_list->args[ndx].arg_val.datum.ival));
default:
swapbytes( arg_list->args[ndx].arg_val.datum.offset );
break;
}
offset = ((char *)widget_rec+
arg_list->args[ndx].arg_val.datum.offset);
switch( arg_list->args[ndx].arg_val.rep_type )
{
/* these are immediate, do nothing special */
case MrmRtypeInteger:
case MrmRtypeBoolean:
case MrmRtypeSingleFloat:
break;
/* these are offsets into the file, handle them specially */
case MrmRtypeCallback:
callb_desc = (RGMCallbackDesc * )offset;
Urm__SwapRGMCallbackDesc( callb_desc, widget_rec );
break;
case MrmRtypeResource:
res_desc = (RGMResourceDesc *)offset;
Urm__SwapRGMResourceDesc( res_desc );
/* flag this resource as needing further byte swapping */
res_desc->cvt_type |= MrmResourceUnswapped;
break;
case MrmRtypeHorizontalInteger:
case MrmRtypeVerticalInteger:
case MrmRtypeHorizontalFloat:
case MrmRtypeVerticalFloat:
case MrmRtypeChar8:
case MrmRtypeChar8Vector:
case MrmRtypeCString:
case MrmRtypeCStringVector:
case MrmRtypeFloat:
case MrmRtypePixmapImage:
case MrmRtypePixmapDDIF:
case MrmRtypeNull:
case MrmRtypeAddrName:
case MrmRtypeIconImage:
case MrmRtypeFont:
case MrmRtypeFontList:
case MrmRtypeColor:
case MrmRtypeColorTable:
case MrmRtypeAny:
case MrmRtypeTransTable:
case MrmRtypeClassRecName:
case MrmRtypeIntegerVector:
case MrmRtypeXBitmapFile:
case MrmRtypeCountedVector:
case MrmRtypeKeysym:
case MrmRtypeWideCharacter:
case MrmRtypeFontSet:
sprintf(err_msg,_MrmMMsg_0022,
arg_list->args[ndx].arg_val.rep_type);
return Urm__UT_Error ("Urm__SwapRGMWidgetRecord",
err_msg, NULL, NULL, MrmFAILURE) ;
break;
}
}
}
/* handle the child list */
if (widget_rec->children_offs > 0)
{
child_list = (RGMChildrenDesc *)
((char *)widget_rec + widget_rec->children_offs);
swapbytes( child_list->count );
swapbytes( child_list->unused1 );
swapbytes( child_list->annex1 );
for ( ndx=0 ; ndx<child_list->count ; ndx++ )
{
swapbytes( child_list->child[ndx].annex1 );
if (child_list->child[ndx].type == URMrRID )
{
idb_rid_ptr = (IDBridDesc *)&(child_list->child[ndx].key.id);
#ifdef WORD64
swap4bytes( idb_rid_ptr->internal_id.map_rec );
swap4bytes( idb_rid_ptr->internal_id.res_index );
#else
swap2bytes( idb_rid_ptr->internal_id.map_rec );
swap2bytes( idb_rid_ptr->internal_id.res_index );
#endif
}
else
swapbytes( child_list->child[ndx].key.index_offs );
}
}
/* handle the creation callback, if any */
if (widget_rec->creation_offs > 0)
{
callb_desc = (RGMCallbackDesc * )
((char *)widget_rec + widget_rec->creation_offs);
Urm__SwapRGMCallbackDesc( callb_desc, widget_rec );
}
return MrmSUCCESS ;
}