/* 

 * 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

*/ 

/*   $TOG: Mrm.h /main/23 1999/05/25 16:55:58 mgreess $ */

/*                                                                      *

 * (c) Copyright 1996 Hewlett-Packard Company                           *

 * (c) Copyright 1996 International Business Machines Corp.             *

 * (c) Copyright 1996 Sun Microsystems, Inc.                            *

 * (c) Copyright 1996 Novell, Inc.                                      *

 * (c) Copyright 1989, 1990, 1996 Digital Equipment Corporation.	*

 * (c) Copyright 1996 FUJITSU LIMITED.					*

 * (c) Copyright 1996 Hitachi.						*

 */

#ifndef Mrm_H

#define Mrm_H

#define	urm_h	1

#include <Mrm/MrmPublic.h>

#include <Xm/Xm.h>			/* XmString definition and _NO_PROTO */

#include <Xm/XmosP.h>

/*

 * This is the internal file used throughout URM for literal and

 * struct definitions. It defines everything not found in public

 * files.

 */

#ifndef MIN

#define MIN(x,y)	((x) < (y) ? (x) : (y))

#endif

#ifndef MAX

#define MAX(x,y)	((x) > (y) ? (x) : (y))

#endif

#ifndef XmConst

#if defined(__STDC__) || !defined( NO_CONST )

#define XmConst const

#else

#define XmConst

#endif /* __STDC__ */

#endif /* XmConst */

/*

 * The following macro is used to round the size of memory allocation requests

 * up to eight bytes. This is done to help satisfy alignment

 * request for MIPS, CRAY, Alpah, HP9000 (for doubles) and similar machines.  

 */

#define _sl sizeof(long)

#define _slm (sizeof(long) - 1)

#define _FULLWORD(exp) (_sl * (((exp) + _slm) / _sl))	/* (4*(((exp)+3)/4)) */

/*

 *  Swap the byte order of 4- and 2- byte quantities.

 *  "tp +=" lines are needed on Cray (CARD32 is actually 64 bits).

 */

#define swap4bytes(l) {\

        CARD32 t = (CARD32) l;\

        char n, *tp = (char *) &t;\

	tp += sizeof(CARD32) - 4;\

	n = tp[0]; tp[0] = tp[3]; tp[3] = n;\

	n = tp[1]; tp[1] = tp[2]; tp[2] = n;\

        l = t;\

}

#define swap2bytes(s) {\

        CARD16 t = (CARD16) s;\

        char n, *tp = (char *) &t;\

	tp += sizeof(CARD16) - 2;\

	n = tp[0]; tp[0] = tp[1]; tp[1] = n;\

        s = t;\

}

#define swapbytes(v) {\

        if (sizeof(v) == 2) \

	  swap2bytes(v) \

	else if (sizeof(v) == 4) \

	  swap4bytes(v); \

}

#define swapdouble(d) {\

        double dt = (double) d;\

        unsigned m, *dp = (unsigned *) &dt;\

	swap4bytes( dp[0] );\

	swap4bytes( dp[1] );\

        m = dp[0]; dp[0] = dp[1]; dp[1] = m;\

	d = dt;\

}

/* 

 * When a resource record is referenced but not yet fetched, logical or

 * the convert type with this value as a flag.

 */

#define MrmResourceUnswapped (unsigned char)128

/*

 * URM-wide constants

 */

#define	URMversion		"URM 1.2"

#define URM1_1version		"URM 1.1"

/*

 * The indexes of the self-encoding compression tables in a UID file. They

 * intentionally include characters which are illegal in UIL identifiers.

 */

#define	UilMrmClassTableIndex		">ClassTable"

#define UilMrmResourceTableIndex	">ResourceTable"

/*

 * Resource classes and types

 */

#define	URMgNul		0

#define	URMgWidget	1

#define	URMgLiteral	2		/* types in MrmRtype... */

#define	URMgResourceSet	3		/* type in URMrs... */

/*			4		unused */

#define	URMgMessage	5

#define URMgMin		1		/* lowest legal group value */

#define	URMgMax		5		/* highest legal group value */

#define	URMgVecSize	URMgMax+1	/* To size any vectors */

/*

 * The null resource type

 */

#define	URMtNul		0

/*

 * Access types

 */

#define	URMaPublic	1

#define	URMaPrivate	2

/*

 * Index types. Immediate is included for the convenience of the UIL compiler

 */

#define	URMrIndex	1

#define	URMrRID		2

#define	URMrImmediate	3

/*

 * Maximum number of characters in an index

 */

#define	URMMaxIndexLen	31

#define	URMMaxIndexLen1	(URMMaxIndexLen + 1)	/* to size vectors */

/*

 * File open access types

 */

#define	URMReadAccess	1

#define	URMWriteAccess	2

/*

 * Standard date string length

 */

#define	URMhsDate		29		/* any date string */

/*

 * Types of resource sets.

 */

#define	URMrsInterfaceModule	1	/* Interface module */

/*

 * Values for the manage flag in memory only -- the manage field in RGMChildDesc

 * is just a Boolean.

 */

typedef enum {

MrmManageUnmanage,

MrmManageManage,

MrmManageDefault

} MrmManageFlag;

/*

 * Urm typedefs

 */

/*

 * The maximum number of arguments allowed in an arglist or children in

 * a child list. A number intended to catch gross errors.

 */

#define	RGMListSizeMax		32767

/*

 * URM pointer list

 *

 * The following structure is inspired by resource contexts, but is used

 * to store lists of pointers. Its supporting routines automatically manage

 * space in the same the context routines do. Since this is used only

 * internally, no validation is provided.

 */

typedef struct {

	int		num_slots ;	/* number of available pointer slots */

	int		num_ptrs ;	/* number of slots actually used */

	XtPointer	*ptr_vec ;	/* pointer slot vector */

} URMPointerList, *URMPointerListPtr ;

/*

 * Accessors for the list or a pointer in the list

 */

#define	UrmPlistPtrList(list) ((list)->ptr_vec)

#define	UrmPlistNum(list) ((list)->num_ptrs)

#define	UrmPlistPtrN(list,ndx) ((list)->ptr_vec[ndx])

/*

 * URM Resource context

 *

 * The following context structure is provided by URM to cover all memory

 * management of in-memory resources. This mechanism provides:

 *	o improved memory management efficiency through buffer re-use

 *	o collection of resource attributes in one place

 *	o support for non-standard allocation routines

 */

#define	URMResourceContextValid	232570204

typedef struct {

	unsigned	validation ;	/* validation code =

					   URMResourceContextValid */

	char		*data_buffer ;	/* pointer to data buffer in memory */

	MrmSize		buffer_size ;	/* number of bytes in buffer */

	MrmSize		resource_size ;	/* number of bytes used by resource */

	MrmGroup	group ;		/* resource group */

	MrmType		type ;		/* resource type */

	MrmCode		access ;	/* URMaPrivate or URMaPublic */

	MrmCode		lock ;		/* resource locking code */

	char		*((*alloc_func) ()) ;	/* memory allocation func */

	void		(*free_func) () ;	/* deallocation func */

	MrmFlag		byte_swapped ;	/* resource is byte_swapped */

} URMResourceContext, *URMResourceContextPtr ;

/*

 * Validation macro, returns TRUE/FALSE

 */

#define	UrmRCValid(context) ((context)->validation==URMResourceContextValid)

/*

 * The following are accessor macros for a resource context

 */

#define	UrmRCBuffer(context)	((context)->data_buffer)

#define UrmRCBufSize(context)	((context)->buffer_size)

#define UrmRCSize(context)	((context)->resource_size)

#define UrmRCGroup(context)	((context)->group)

#define UrmRCType(context)	((context)->type)

#define UrmRCAccess(context)	((context)->access)

#define UrmRCLock(context)	((context)->lock)

#define UrmRCByteSwap(context)	((context)->byte_swapped)

/*

 * The following are modifiers for a resource context

 */

#define	UrmRCSetBuffer(context,bufadr)    {(context)->data_buffer=(bufadr);}

#define	UrmRCSetSize(context,sizval)      {(context)->resource_size=(sizval);}

#define UrmRCSetGroup(context,grpval)     {(context)->group=(grpval);}

#define UrmRCSetType(context,typval)      {(context)->type=(typval);}

#define UrmRCSetAccess(context,accval) 	  {(context)->access=(accval);}

#define UrmRCSetLock(context,lckval)	  {(context)->lock=(lckval);}

#define UrmRCSetByteSwap(context,swapval) {(context)->byte_swapped=(swapval);}

/*

 * Error reporting states

 */

#define	URMRCErrorDefault	1	/* default - report on line */

#define	URMRCErrorSave		2	/* save error, don't report */

/*

 * Error reporting destinations

 */

#define	URMErrOutMemory	1	/* Save error messages in memory, no print */

#define	URMErrOutStdout	2	/* print error messages to stdout */

/*

 * IDB definitions in common use. The principal one is IDBFile; others

 * are included to make that definition valid.

 */

/*

 * Record type definitions - IDBrt...

 */

#define	IDBrtMin		1

#define	IDBrtHeader		1

#define	IDBrtIndexLeaf		2

#define	IDBrtIndexNode		3

#define	IDBrtRIDMap		4

#define	IDBrtData		5

#define	IDBrtMax		5

#define	IDBrtVecSize		6

/*

 * Sizes of fixed-length strings in the file header. Definitions are

 * provided for both the number of characters in the string and the

 * constant which gives the string length including the terminating nul.

 * IDBhs...

 */

#define	IDBhsVersion		9		/* Any version string */

#define	IDBhsVersion1		(IDBhsVersion + 1)

#define	IDBhsCreator		29		/* Creator id */

#define	IDBhsCreator1		(IDBhsCreator + 1)

#define	IDBhsDate		URMhsDate	/* Any date string */

#define	IDBhsDate1		(IDBhsDate + 1)

#define	IDBhsModule		29		/* Module id */

#define	IDBhsModule1		(IDBhsModule + 1)

/*

 * Record number. 65k should be enough...

 */

typedef short int       IDBRecordNumber ;

/*

 * A resource ID consists of the resource map index and the ID index

 * in the given resource map.

 */

typedef short int       IDBResourceIndex ;

typedef union {

	unsigned		external_id ;	/* Looks like a fullword */

        struct {

	    IDBRecordNumber	map_rec B32 ;    /* resource map record */

	    IDBResourceIndex	res_index B32 ;  /* resource index into map */

        }       internal_id ;     		/* 2 fields internally */

} IDBridDesc ;

/*

 * A resource ID passed by value in a fullword.

 */

typedef unsigned        IDBResource ;		/* a declaration for RIDs

						   passed by value */

/*

 * Class descriptor.

 *

 * This descriptor contains the information URM requires about a toolkit

 * class.

 */

#define	URMWCIClassDescValid	39963371

#define	UrmWCIClassDescValid(classdesc)	\

    ((classdesc)->validation==URMWCIClassDescValid)

typedef struct _WCIClassDesc {

	unsigned	validation ;	/* URMWCIClassDescValid */

	struct _WCIClassDesc *next_desc ;

					/* next descriptor in chain */

	String		creator_name ;	/* create routine name. This is also

					   the accessor key for non-toolkit

					   widget classes. */

	Widget		(*creator) () ;	/* low-level create routine. This is

					   also the class identifier (name)

					   used to match user classes. */

	WidgetClass	class_record ;	/* Pointer to toolkit class record */

	void		(*cleanup) () ;

					/* low-level destructor routine.

					   Used to clean up after creation

					   routines that leave dangling

					   memory (i.e. XmRendition,

					   XmRenderTable) */

} WCIClassDesc, *WCIClassDescPtr ;

/*

 * Table used to uncompress compression codes in a self-encoding UID file.

 * Table entries can be overlaid with function pointers for tables which

 * encode convenience functions.

 *

 * The table is accessed by the compression code. Code 0 is unused by

 * convention, and code 1 is unused because it is the marker for an

 * unknown (user defined) entry, which is specified by an explicit string.

 * Thus the valid entries begin at 2 (UilMrmMinValidCode). Any code

 * < UilMrmMinValidCode or > num_entries is invalid.

 * 

 * When stored in a UID file, a table is a block of memory with the

 * following properties:

 *	o The table is allocated with enough space for all the decompression

 *	  pointers required.

 *	o The table is followed by the strings in the table. They are allocated

 *	  in a heap built from contiguous memory following table itself.

 */

#define UidCompressionTableValid	317938336

#define	UilMrmUnknownCode		1

#define UilMrmMinValidCode		2

#define	UilMrmReservedCodeCount		2

typedef union

    {

    MrmOffset		stoffset;		/* offset of string in

						   heap (in file) */

    char		*cstring;		/* compressed string as

						 a memory pointer */

    WCIClassDescPtr	cldesc;			/* class descriptor for

						   class table */

    } UidCTableEntry;

typedef struct

    {

    unsigned		validation;		/* validation code =

						   UIDCompressionTableValid */

    MrmCount		num_entries;		/* number of table entries */

    UidCTableEntry	entry[1];		/* first entry */

    } UidCompressionTable, *UidCompressionTablePtr;

/*

 * Hash table entry

 */

#define k_hash_table_size	(127)

typedef struct _URMHashTableEntry

{

    char		*az_value;	/* value associated with this name */

    struct _URMHashTableEntry

			*az_next_entry;	/* next entry on hash chain */

    char		c_text[1];	/* text of the name */

} URMHashTableEntry, *URMHashTableEntryPtr;

/*

 * Low level file information.

 *

 * This structure is pointed to in the IDBOpenFile structure and blindly

 * passed to the low level routines.

 */

typedef struct {

	unsigned	rab;		/* Record Access Block	*/

	int		file_desc;	/* File Descriptor */

	char		*name;		/* The file name		*/

} IDBLowLevelFile, *IDBLowLevelFilePtr;

/*

 * IDB open file information

 *

 * The following is the information retained by IDB for an open file.

 * Much of this information matches that found in the file header,

 * and is the source of for that info when the header is updated.

 */

#define	IDBOpenFileValid	421642674

typedef struct {

	unsigned	validation ;		/* validation code =

						   IDBOpenFileValid */

	int		get_count ;		/* # get operations on file */

	int		put_count ;		/* # put operations on file */

	MrmCode		access ;		/* URMReadAccess or

						   URMWriteAccess */

	IDBLowLevelFilePtr lowlevel_id ;	/* open file id returned

						   by low-level routines */

	IDBRecordNumber	index_root ;		/* index root pointer */

	MrmCount	num_indexed ;		/* # entries in index */

	MrmCount	num_RID ;		/* # RID entries in file */

	IDBridDesc	next_RID ;		/* next available RID */

	IDBRecordNumber	last_record ;		/* last record used in file */

	IDBRecordNumber	last_data_record ;	/* last data record in file.

						   NULL if no records yet */

	MrmCount	group_counts[URMgVecSize] ;

						/* vector of record counts

						   by resource group */

	MrmCount	rt_counts[IDBrtVecSize] ;

						/* vector of record counts by

						   record type (statistics) */

	unsigned long	timer ;			/* for statistics */

	char		db_version[IDBhsVersion1] ;

						/* database version */

	char		creator[IDBhsCreator1] ; /* creator id */

	char		creator_version[IDBhsVersion1] ;

						/* creator version */

	char		creation_date[IDBhsDate1] ;

						/* creation date */

	char		module[IDBhsModule1] ;	/* module id */

	char		module_version[IDBhsVersion1] ;

						/* module version */

	UidCompressionTablePtr

			class_ctable;		/* compression table for

						   class info */

	UidCompressionTablePtr

			resource_ctable;	/* compression table for

						   resource info */

	int		user1 ;			/* for caller use */

	int		user2 ;			/* for caller use */

	MrmFlag         byte_swapped ;          /* indicates uid file created on

	  					   opposite-endian machine */

	MrmFlag		in_memory ;		/* for memory mapped files */

	unsigned char 	*uid_buffer ;		/* pointer to memory buffer */

} IDBOpenFile, *IDBFile ;

/*

 * Open hierarchy struct

 *

 * The following structure represents an open hierarchy. A hierarchy

 * is principally a list of open IDB files in search order. As an aid to

 * efficient searching, a list of files by resource group is also kept.

 * Each entry in the list is the subset of the files in the hierarchy

 * which contains resources in the corresponding group.

 */

#define	MrmHIERARCHY_VALID	102214835

typedef struct MrmHierarchyDescStruct {

	unsigned	validation ;		/* MrmHIERARCHY_VALID */

	MrmCount	num_file ;		/* number of files open */

	IDBFile		*file_list ;		/* list of open files */

	MrmCount	grp_num[URMgVecSize] ;	/* vector of file counts by

						   resource group */

	IDBFile		*grp_ids[URMgVecSize] ;	/* vectors of file ids by

						   resource group */

	URMHashTableEntryPtr

			*name_registry;		/* to register names */

} MrmHierarchyDesc;

/*

 * Validation macro

 */

#define	MrmHierarchyValid(hierarchy)		\

    ((hierarchy)->validation==MrmHIERARCHY_VALID)

/*

 * RGM widget record typedefs

 */

/*

 * RGM Widget record. All offset are relative to the beginning of the record

 */

#define	URMWidgetRecordValid	373946338

/* Variety codes. */

#define UilMrmWidgetVariety	0

#define UilMrmAutoChildVariety	1

typedef struct {

	unsigned		validation;	/* validation code =

					   URMWidgetRecordValid */

	MrmSize		size;		/* Total number of bytes for record */

	MrmCode		access;		/* URMaPublic or URMaPrivate */

	MrmCode		lock;		/* locking code */

	MrmType		type;		/* widget type, equates to class

					   for toolkit widgets.  (Unknown or

					   a uid-based compression code). */

	MrmOffset	name_offs;	/* Offset of widget name. Locates a

					   String. Empty string is illegal */

	MrmOffset	class_offs;	/* Offset of class name. The class name

					   is required for application-defined

					   widgets. */

	MrmOffset	arglist_offs; 	/* Offset of arglist descriptor.

					   Locates a RGMArgListDesc struct */

	MrmOffset	children_offs;	/* Offset of children descriptor.

					   Locates a RGMChildrenDesc struct */

	MrmOffset	comment_offs; 	/* Offset of comment string for

					   this widget. (URM extension) */

	MrmOffset	creation_offs;	/* Offset of RGMCallnackDesc struct

					   specifying URM creation callback

					   for this widget */

	unsigned long		variety;/* Regular widget or auto child. */

	unsigned long		annex; 	/* annex allows compatible growth */

} RGMWidgetRecord, *RGMWidgetRecordPtr ;

/*

 * Size of the header part of the record

 */

#define	RGMWidgetRecordHdrSize	sizeof(RGMWidgetRecord)

/*

 * Macro to access the widget record in a context

 */

#define	UrmWRWidgetRec(context)	\

	((RGMWidgetRecordPtr) UrmRCBuffer(context))

/*

 * All validation, accessor, and setting macros access a widget record in

 * a context. They all take a pointer to the widget record, which is

 * the context buffer CAST to RGMWidgetRecordptr.

 */

#define	UrmWRValid(widgetrec)	\

    ((widgetrec)->validation==URMWidgetRecordValid)

/*

 * Accessor macros for the widget record header

 */

#define UrmWRPSize(context)		(UrmWRWidgetRec(context)->size)

#define	UrmWRPAccess(context)		(UrmWRWidgetRec(context)->access)

#define	UrmWRPLock(context)		(UrmWRWidgetRec(context)->lock)

#define	UrmWRPType(context)		(UrmWRWidgetRec(context)->type)

/*

 * value descriptor. This consists of a representation type, followed

 * by a union of either an immediate value or an offset, depending

 * on the representation type.

 */

typedef struct {

	MrmType		rep_type;	/* representation type from

					   RGMrType... */

	union {

	  int		ival;		/* integer, boolean, compressed */

	  MrmOffset	offset ;	/* offset for all others */

	} datum ;			/* immediate value or offset */

} RGMArgValue, *RGMArgValuePtr ;

/*

 * RGM widget record argument descriptor

 */

typedef struct {

	MrmCode		tag_code;	/* Either the compressed code for

					   the argument tag from URMc...,

					   or UilMrmUnknownCode to indicate no

					   known string. If UilMrmUnknownCode, then

					   the offset is in tag_off */

	union

	    {

	    MrmOffset	tag_offs;	/* offset to tag string if needed */

	    MrmCode	related_code;	/* related argument code for case

					   where tag_code is valid and a

					   related argument is to be set */

	    } stg_or_relcode;

	RGMArgValue	arg_val ;	/* argument value */

} RGMArgument, *RGMArgumentPtr ;

/*

 * RGM widget record arglist descriptor

 */

typedef struct {

	MrmCount	count;		/* number of arguments in list */

	MrmCount	extra;		/* # extra runtime args needed */

	unsigned long	annex1 ;	/* annex allows compatible growth */

	RGMArgument	args[1] ;	/* first of the argument descriptors */

} RGMArgListDesc, *RGMArgListDescPtr ;

/*

 * RGM widget record text vector item (text vector literal)

 *

 * The following represents vectors of either ASCIZ or compound strings.

 * each member of the vector is type-tagged so that mixed vectors are possible.

 * This descriptor is a union so that a vector of these items can be over-

 * written to become an in-memory list of pointers. This avoids some

 * allocation problems at widget instantiation. Char8 items are String,

 * CString items are XmString.

 *

 * Offsets are interpreted as follows:

 *	text vector as immediate in widget record - offset from beginning

 *		of record buffer.

 *	text vector as UID literal - offset from beginning of resource buffer

 */

typedef union {

	  XtPointer	pointer ;	/* for use as memory pointer */

	  struct {

	      MrmType	rep_type B32;	/* MrmRtypeChar8 or MrmRtypeCString */

	      MrmOffset	offset B32;	/* offset of item in record */

	  } text_item ;			/* for use as item type & offset */

} RGMTextEntry, *RGMTextEntryPtr ;

/*

 * The text Vector. This is designed to allow the vector of text entries

 * to be over-written into an in-memory vector of pointers. Thus this list

 * has one extra entry to provide a terminating null.

 */

#define	URMTextVectorValid	34966592

typedef struct {

	unsigned	validation;	/* URMTextVectorValid */

	MrmCount	count;		/* Number of text items in vector */

	RGMTextEntry	item[1] ;	/* first text item in a vector of

					   n = .count+1 items. item[.count]

					   always = NULL */

} RGMTextVector, *RGMTextVectorPtr ;

/*

 * The integer Vector. This is designed to allow the vector of integers

 * to be over-written into an in-memory vector of pointers. 

 */

#define	URMIntegerVectorValid	34966593

typedef struct {

	unsigned	validation;	/* URMIntegerVectorValid */

	MrmCount	count;		/* Number of integer items in vector */

	int		item[1] ;	/* first integer item in a vector   */

					/* of n = .count+1 items.	    */

} RGMIntegerVector, *RGMIntegerVectorPtr ;

/*

 * RGM widget record callback item

 *

 * A callback item is the offset of a routine name (which must be a

 * non-imported string), and the routine tag value, which is encoded

 * as a value. The tag value can evaluate to almost anything, including

 * an imported value.

 *

 * This structure is intended to be over-written with memory pointers

 * and thus function as an arglist value.

 */

typedef union 

{

  int		ival;		/* integer, boolean, compressed */

  MrmOffset	offset;		/* offset for all others */

} RGMdatum;			/* immediate value, offset, widget */

typedef union {

  struct {

    XtCallbackRec	callback ;	/* item as Xt callback */

    MrmFlag		resolved; 	/* Item resolved to XtCallbackRec */

    String		wname;		/* Name of widget reference */

  } 	runtime;

  struct {

    MrmOffset		routine B32;	/* offset to routine name string */

					/* duplicate RGMArgValue, avoiding

					   union alignment hassles */

    MrmType		rep_type B32;	/* from RGMrType... */

    RGMdatum		datum ;		/* immediate value, offset, widget */

  } 	cb_item ;			/* callback item in record */

} RGMCallbackItem, *RGMCallbackItemPtr ;

/*

 * RGM widget record callback argument descriptor. This list has

 * count + 1 entries so that this structure may be overwritten

 */

#define	URMCallbackDescriptorValid	107397480

typedef struct {

        unsigned	validation;		/* URMCallbackDescriptorValid */

	MrmCount	count;			/* Number of callback items */

	MrmCount	annex;		  	/* annex allows growth */

	MrmCount	unres_ref_count;	/* # of unresolved widget refs 

	                                           in the RGMCallbackItems */

	RGMCallbackItem item[1] ;		/* First callback item in a list

	                                           of n = .count+1 items */

} RGMCallbackDesc, *RGMCallbackDescPtr ;

/*

 * We need to have the 1.1 versions of RGMCallbackItem and RGMCallbackDesc

 * so that backwards compatibility can be maintained between 1.1 and 1.2.

 */

typedef union {

	XtCallbackRec	runtime ;	/* item as Xt callback */

	struct {

	  MrmOffset	routine ;	/* offset to routine name string */

					/* duplicate RGMArgValue, avoiding

					   union alignment hassles */

	  MrmType	rep_type ;	/* from RGMrType... */

	  RGMdatum	 datum ;	/* immediate value or offset */

	} cb_item ;			/* callback item in record */

} OldRGMCallbackItem, *OldRGMCallbackItemPtr ;

typedef struct {

	unsigned	validation ;	/* URMCallbackDescriptorValid */

	MrmCount	count ;		/* Number of callback items */

	unsigned long	annex1 ;	/* annex allows compatible growth */

	OldRGMCallbackItem  item[1] ;	/* First callback item in a list

					   of n = .count+1 items */

} OldRGMCallbackDesc, *OldRGMCallbackDescPtr ;

/* BEGIN OSF Fix CR 4859 */

/*

 * Wide character uid form

 *

 * The following represents a multi-byte string which needs to be converted

 * to a wide-character string when it is retrieved.

 * The structure contains a byte count followed by the bytes.

 */

typedef union {

    XtPointer	pointer;			  /* for use as memory pointer */

    struct {

      MrmCount	count;				  /* # of bytes */

      char bytes[1];				  /* vector of bytes */

    } wchar_item;

} RGMWCharEntry, *RGMWCharEntryPtr;

/* END OSF Fix CR 4859 */

/*

 * Font literal

 *

 * The following represents a MrmRtypeFont literal. Since it contains two

 * strings, the same offset mechanism is used to store both, and this

 * is a fixed-length data structure.

 * data structure.

 */

typedef struct {

    union

	{

	/*XmStringCharset*/char* 	charset; /* character set (resolved) */

	MrmOffset	cs_offs;	/* character set in buffer */

	} cset;

    union

	{

	String		font;		/* string naming font */

	MrmOffset	font_offs;	/* font name in buffer */

	} font;

    MrmCode		type;

} RGMFontItem, *RGMFontItemPtr ;

/*

 * A font list, which is a vector of font items. The font items are

 * treated as a heap store following the fixed length list (similar

 * to text vectors). Font lists in widget records have offsets from

 * the beginning of the record; font list literals in a UID file have

 * offsets from the beginning of the list itself (just like text

 * vectors). Font items in a font list are a union of a pointer and

 * an offset, so that (as in text vectors) they can be converted in

 * place to an in-memory pointer list.

 */

#define URMFontListValid	74149235

typedef struct {

	unsigned		validation;	/* URMFontListValid */

	MrmCount		count;		/* # of font items in list */

	RGMFontItem		item[1] ;	/* vector of RGMFontItems */

} RGMFontList, *RGMFontListPtr ;

/*

 * We need to have the 1.1 versions of RGMFontItem and RGMFontList

 * so that backwards compatibility can be maintained between 1.1 and 1.2.

 */

typedef struct {

    union

	{

	/*XmStringCharset*/char*	charset;	/* character set (resolved) */

	MrmOffset	cs_offs;	/* character set in buffer */

	} cset;

    union

	{

	String		font;		/* string naming font */

	MrmOffset	font_offs;	/* font name in buffer */

	} font;

} OldRGMFontItem, *OldRGMFontItemPtr ;