/* 

 * 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 REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: UilLstMac.c /main/15 1997/03/12 15:21:48 dbl $"

#endif

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

*  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/*

**++

**  FACILITY:

**

**      User Interface Language Compiler (UIL)

**

**  ABSTRACT:

**

**      This module contain the routines for creating the machine listing.

**

**--

**/

/*

**

**  INCLUDE FILES

**

**/

#include <Mrm/MrmAppl.h>

#include <X11/Xmd.h>		/* For 64-bit architecture dependencies */

#ifdef DXM_V11

#include <DXm/DXmHelpB.h>

#endif

#include "UilDefI.h"

/*

**

**  DEFINE and MACRO DEFINITIONS

**

**/

/*	Holds offset info for machine code listing.	*/

typedef struct _off_info {

	unsigned short int	w_off_type;

	unsigned short int	w_off_offset;

	} off_info_type;

#define		k_name_off		0

#define		k_class_off		1

#define		k_arglist_off		2

#define		k_children_off		3

#define		k_comment_off		4

#define		k_creation_off		5

#define		k_callback_off		6

#define		k_resource_off		7

#define		k_float_off		8

#define		k_unknown_off		9

#define		k_resource_id_off	10

#define		k_child_off		11

#define		k_text_entry_off	12

#define		k_null_text_entry_off	13

#define         k_single_float_off      14 /* single float data type RAP */

#define		k_off_stack_size	300

static off_info_type	off_info_stack [k_off_stack_size];

static int		off_info_cnt = 0;

#define		off_stack_empty		(off_info_cnt == 0)

#define _Offset(type,base,field)    \

        ((unsigned int)(base + XtOffsetOf(type, field)))

#if defined(__STDC__)

#define _OffsetArray(type,base,field)    \

        ((unsigned int)(base + XtOffsetOf(type, field)))

#else

#define _OffsetArray(type,base,field)    \

        ((unsigned int)(base + XtOffsetOf(type, field[0])))

#endif

#define	_Pointer(base,offset) ((char *)(base)+(offset))

#define ASNHEADERLEN 3

#define CSLONGBIT    (unsigned char)(0x80)

#define ASNstrlen(a) (ASNHEADERLEN+ \

		      (((unsigned char)(a)[ASNHEADERLEN]&CSLONGBIT)? \

		       (((unsigned short)((a)[ASNHEADERLEN+1])<<8) | \

			(unsigned short)((a)[ASNHEADERLEN+2]))+3 : \

		       ((unsigned short)((a)[ASNHEADERLEN]))+1))

/*

**

**  EXTERNAL VARIABLE DECLARATIONS

**

**/

/*

**

**  GLOBAL VARIABLE DECLARATIONS

**

**/

/*

**

**  OWN VARIABLE DECLARATIONS

**

**/

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This function saves the machine code listing information for widgets.

**

**  FORMAL PARAMETERS:

**

**      widget_entry	Symbol node for this widget

**      az_context	context containing the URM output information.

**

**  IMPLICIT INPUTS:

**

**      none

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      the machine code is saved in the source record structure for

**	the widget.

**

**--

**/

void		save_widget_machine_code ( widget_entry, az_context )

sym_widget_entry_type	* widget_entry;

URMResourceContext	* az_context;

{

    RGMWidgetRecordPtr		w_rec;

    char			buffer [132];

    unsigned short int		w_rec_size;

    src_source_record_type	* az_src_rec;

#define	_WRPointer(w_rec,offset) ((char *)(w_rec)+(offset))

#define _WROffset(field)    (_Offset(RGMWidgetRecord,0,field))

    az_src_rec = widget_entry->header.az_src_rec;

    if (widget_entry->resource_id != 0 ) {

	sprintf (buffer, "Resource ID: %08lX", widget_entry->resource_id);

	src_append_machine_code (

		az_src_rec,

		0,

		0, 0,

		buffer );

    } else if (widget_entry->obj_header.az_name != NULL) {

	sprintf (buffer, "Resource index: %s",

		 widget_entry->obj_header.az_name->c_text);

	src_append_machine_code (

		az_src_rec,

		0,

		0, 0,

		buffer );

    }

    w_rec = (RGMWidgetRecordPtr) UrmRCBuffer (az_context);

    src_append_machine_code (

		az_src_rec,

		_WROffset (validation),

		sizeof (w_rec->validation), (char*)& w_rec->validation,

		"widget record" );

    sprintf (buffer, "size: %d", w_rec->size);

    src_append_machine_code (

		az_src_rec,

		_WROffset (size),

		sizeof (w_rec->size), (char*)& w_rec->size,

		buffer );

    w_rec_size = w_rec->size;

    sprintf (buffer, "access: %s",

			access_from_code (w_rec->access) );

    src_append_machine_code (

		az_src_rec,

		_WROffset (access),

		sizeof (w_rec->access), (char*)& w_rec->access,

		buffer );

    sprintf (buffer, "locked: ");

    if (w_rec->lock) {

	strcat (buffer, "true");

    } else {

	strcat (buffer, "false");

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (lock),

		sizeof (w_rec->lock), (char*)& w_rec->lock,

		buffer );

    sprintf (buffer, "type: ");

    strcat (buffer, class_name_from_code (w_rec->type));

    src_append_machine_code (

		az_src_rec,

		_WROffset (type),

		sizeof (w_rec->type), (char*)& w_rec->type,

		buffer );

    if (w_rec->name_offs == (MrmOffset) 0) {

	sprintf (buffer, "no name specified");

    } else {

	sprintf (buffer, "name: offset %X (hex)",

		 w_rec->name_offs);

	off_put (k_name_off, w_rec->name_offs);

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (name_offs),

		sizeof (w_rec->name_offs),

		(char*)& w_rec->name_offs,

		buffer );

    if (w_rec->class_offs == (MrmOffset) 0) {

	sprintf (buffer, "class: builtin");

    } else {

	sprintf (buffer, "class: offset %X (hex)",

		 w_rec->class_offs);

	off_put (k_class_off, w_rec->class_offs);

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (class_offs),

		sizeof (w_rec->class_offs),

		(char*)& w_rec->class_offs,

		buffer );

    if (w_rec->arglist_offs == (MrmOffset) 0) {

	sprintf (buffer, "no argument list");

    } else {

	sprintf (buffer, "argument list offset: %X (hex)", w_rec->arglist_offs);

	off_put (k_arglist_off, w_rec->arglist_offs);

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (arglist_offs),

		sizeof (w_rec->arglist_offs),

		(char*)& w_rec->arglist_offs,

		buffer );

    if (w_rec->children_offs == (MrmOffset) 0) {

	sprintf (buffer, "no children");

    } else {

	sprintf (buffer, "children list offset: %X (hex)",

		 w_rec->children_offs);

	off_put (k_children_off, w_rec->children_offs);

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (children_offs),

		sizeof (w_rec->children_offs),

		(char*)& w_rec->children_offs,

		buffer );

    if (w_rec->comment_offs == (MrmOffset) 0) {

	sprintf (buffer, "no comment specified");

    } else {

	sprintf (buffer, "comment: offset %X (hex)",

		 w_rec->comment_offs);

	off_put (k_comment_off, w_rec->comment_offs);

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (comment_offs),

		sizeof (w_rec->comment_offs),

		(char*)& w_rec->comment_offs,

		buffer );

    if (w_rec->creation_offs == (MrmOffset) 0) {

	sprintf (buffer, "no creation callback");

    } else {

	sprintf (buffer, "creation callback offset: %X (hex)",

		 w_rec->creation_offs);

	off_put (k_creation_off, w_rec->creation_offs);

    }

    src_append_machine_code (

		az_src_rec,

		_WROffset (creation_offs),

		sizeof (w_rec->creation_offs),

		(char*)& w_rec->creation_offs,

		buffer );

    unload_stack(( char *) w_rec, w_rec_size, az_src_rec );

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This function unloads entries placed on a stack and outputs them

**	into the listing.  The routine is used by both widgets and gadgets

**	to output their argument, control, and callback lists.

**

**  FORMAL PARAMETERS:

**

**      rec	    base of the record being annotated

**      rec_sizr    size of the record being annotated

**      az_src_rec  address of the source for record being annotated

**

**  IMPLICIT INPUTS:

**

**

**  IMPLICIT OUTPUTS:

**

**

**  SIDE EFFECTS:

**

**

**--

**/

void	unload_stack( rec, rec_size, az_src_rec )

char			*rec;

int			rec_size;

src_source_record_type	*az_src_rec;

{

    char			buffer [132], * ptr;

    int				child_index;

    while ( ! off_stack_empty ) {

	unsigned short		off_type, off_offset;

	off_get (& off_type, & off_offset);

	switch (off_type) {

	    case k_name_off :

	    case k_class_off :

	    case k_comment_off : {

		ptr = (char *) _Pointer(rec, off_offset);

		src_append_machine_code (

			az_src_rec, off_offset,

			strlen (ptr) + 1, ptr, NULL );

		break;

	    }

	    case k_unknown_off : {

		unsigned short int	len;

/*	Write out everything up to the next offset or the end of the

	record.	*/

		if ( ! off_stack_empty ) {

		    unsigned short int	next_type, next_offset;

		    off_get (& next_type, & next_offset);

		    off_put (next_type, next_offset);

		    len = next_offset - off_offset;

		} else {

		    len = rec_size - off_offset;

		}

		ptr = (char *) _Pointer(rec, off_offset);

		src_append_machine_code (

			az_src_rec, off_offset,

			len, ptr, NULL );

		break;

	    }

	    case k_arglist_off : {

		RGMArgListDescPtr	argdesc;

		RGMArgumentPtr		arg_ptr;

		int			j;

		argdesc = (RGMArgListDescPtr) _Pointer(rec, off_offset);

		sprintf (buffer, "argument count: %d", argdesc->count);

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMArgListDesc, off_offset, count),

			sizeof (argdesc->count),

			(char*)& argdesc->count,

			buffer );

		sprintf (buffer, "related argument count: %d", argdesc->extra);

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMArgListDesc, off_offset, extra),

			sizeof (argdesc->extra),

			(char*)& argdesc->extra,

			buffer );

		off_offset = _OffsetArray (RGMArgListDesc, off_offset, args);

		for (j = 0, arg_ptr = argdesc->args;

		     j < argdesc->count;

		     j++, arg_ptr++, off_offset += sizeof (RGMArgument)) {

		    if (arg_ptr->tag_code != UilMrmUnknownCode )

			{

			sprintf (buffer,

				 "(%d) arg type: %s",

				 j,

				 resource_name_from_code(arg_ptr->tag_code));

			}

		    else

			{

			ptr = (char *)

			    _Pointer(rec,arg_ptr->stg_or_relcode.tag_offs);

			sprintf (buffer,

				 "(%d) arg type: %s (user defined)",

				 j,

				 ptr);

			}

		    src_append_machine_code (

			az_src_rec,

			_Offset (RGMArgument, off_offset, tag_code),

			sizeof (arg_ptr->tag_code),

			(char*)& arg_ptr->tag_code,

			buffer );

		    if (arg_ptr->stg_or_relcode.tag_offs == (MrmOffset) 0) {

			sprintf (buffer, "(%d) no tag offset", j);

		    } else {

			sprintf (buffer, "(%d) tag offset: %X (hex)",

					j, arg_ptr->stg_or_relcode.tag_offs);

			off_put (k_name_off, arg_ptr->stg_or_relcode.tag_offs);

		    }

		    src_append_machine_code (

			az_src_rec,

			_Offset (RGMArgument, off_offset, stg_or_relcode.tag_offs),

			sizeof (arg_ptr->stg_or_relcode.tag_offs),

			(char*)& arg_ptr->stg_or_relcode.tag_offs,

			buffer );

		    sprintf (buffer, "(%d) type: %s",

			j, type_from_code (arg_ptr->arg_val.rep_type) );

		    src_append_machine_code (

			az_src_rec,

			_Offset (RGMArgument, off_offset,

							arg_val.rep_type),

			sizeof (arg_ptr->arg_val.rep_type),

			(char*)& arg_ptr->arg_val.rep_type,

			buffer );

		    sprintf (buffer, "(%d) ", j);

		    format_arg_value (& arg_ptr->arg_val,

				& buffer [strlen (buffer)]);

		    src_append_machine_code (

			az_src_rec,

			_Offset (RGMArgument, off_offset,

							arg_val.datum),

			sizeof (arg_ptr->arg_val.datum),

			(char*)& arg_ptr->arg_val.datum,

			buffer );

		}

		break;

	    }

	    case k_float_off : {

		double	* dptr;

		dptr = (double *) _Pointer (rec, off_offset);

		sprintf (buffer, "floating point value: %g", (* dptr));

		src_append_machine_code (

			az_src_rec,

			off_offset,

			sizeof (double), (char*)dptr, buffer );

		break;

	    }

/* single float data type RAP */

	    case k_single_float_off :

	      {

		float *fptr;

		fptr = (float *) _Pointer(rec, off_offset);

		sprintf(buffer, "Single float value: %g", (* fptr));

		src_append_machine_code (

					 az_src_rec,

					 off_offset,

					 sizeof (float), (char*)fptr, buffer);

		break;

	      }

	    case k_creation_off :

	    case k_callback_off : {

		RGMCallbackDescPtr	cb_desc_ptr;

		RGMCallbackItemPtr	cb_item_ptr;

		int			j;

		cb_desc_ptr =

			(RGMCallbackDescPtr) _Pointer (rec, off_offset);

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMCallbackDesc, off_offset, validation),

			sizeof (cb_desc_ptr->validation),

			(char*)& cb_desc_ptr->validation,

			"callback descriptor" );

		sprintf (buffer, "callback count: %d", cb_desc_ptr->count);

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMCallbackDesc, off_offset, count),

			sizeof (cb_desc_ptr->count),

			(char*)& cb_desc_ptr->count,

			buffer );

		off_offset =

			_OffsetArray (RGMCallbackDesc, off_offset, item);

		for (j = 0, cb_item_ptr = cb_desc_ptr->item;

		     j < cb_desc_ptr->count;

		     j++, cb_item_ptr++,

				off_offset += sizeof (RGMCallbackItem)) {

		    sprintf (buffer,

				"(%d) routine name offset: %X (hex)",

				j, cb_item_ptr->cb_item.routine);

		    src_append_machine_code (

			az_src_rec,

			_Offset (RGMCallbackItem, off_offset,

				 cb_item.routine),

#ifndef WORD64

			sizeof (cb_item_ptr->cb_item.routine),

			(char*)& cb_item_ptr->cb_item.routine,

#else /* 64-bit architecture */

			4,

			(char*)& cb_item_ptr->cb_item,

#endif /* WORD64 */

			buffer );

		    off_put (k_name_off, cb_item_ptr->cb_item.routine);

		    sprintf (buffer, "(%d) routine tag type: %s",

			j, type_from_code (

				cb_item_ptr->cb_item.rep_type) );

		    src_append_machine_code

			(az_src_rec,

			 _Offset (RGMCallbackItem, off_offset,

				  cb_item.rep_type),

#ifndef WORD64

			 sizeof (cb_item_ptr->cb_item.rep_type),

			 (char*)& cb_item_ptr->cb_item.rep_type,

#else /* 64-bit architecture */

			4,

			(char*)& cb_item_ptr->cb_item + 4,

#endif /* WORD64 */

			 buffer );

		    sprintf (buffer, "(%d) value: ", j);

		    src_append_machine_code

			(az_src_rec,

			 _Offset (RGMCallbackItem, off_offset,

				  cb_item.datum),

			 sizeof (cb_item_ptr->cb_item.datum),

			 (char*)& cb_item_ptr->cb_item.datum,

			 buffer );

		}	/* for */

		break;

	    }

	    case k_resource_off : {

		RGMResourceDescPtr	r_desc_ptr;

		r_desc_ptr =

			(RGMResourceDescPtr) _Pointer (rec, off_offset);

		sprintf (buffer, "resource descriptor, size: %d",

			 r_desc_ptr->size);

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMResourceDesc, off_offset, size),

			sizeof (r_desc_ptr->size),

			(char*)& r_desc_ptr->size,

			buffer );

		sprintf (buffer, "access: %s",

				access_from_code (r_desc_ptr->access) );

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMResourceDesc, off_offset, access),

			sizeof (r_desc_ptr->access),

			(char*)& r_desc_ptr->access,

			buffer );

		switch (r_desc_ptr->type) {

		    case URMrIndex:

			sprintf (buffer, "index, offset: %X (hex)",

				_Offset (RGMResourceDesc, off_offset, key) );

			off_put (k_name_off,

				_Offset (RGMResourceDesc, off_offset, key) );

			break;

		    case URMrRID:

			sprintf (buffer, "resource ID, offset: %X (hex)",

				_Offset (RGMResourceDesc, off_offset, key) );

			off_put (k_resource_id_off,

				_Offset (RGMResourceDesc, off_offset, key) );

			break;

		    default:

			sprintf (buffer, "unknown resource type");

			break;

		}

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMResourceDesc, off_offset, type),

			sizeof (r_desc_ptr->type),

			(char*)& r_desc_ptr->type,

			buffer );

		sprintf (buffer, "resource group: %s",

			 group_from_code (r_desc_ptr->res_group) );

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMResourceDesc, off_offset, res_group),

			sizeof (r_desc_ptr->res_group),

			(char*)& r_desc_ptr->res_group,

			buffer );

		sprintf (buffer, "resource type: %s",

			(r_desc_ptr->res_group == URMgLiteral) ? 

				type_from_code (r_desc_ptr->cvt_type) :

				class_name_from_code (r_desc_ptr->cvt_type) );

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMResourceDesc, off_offset, cvt_type),

			sizeof (r_desc_ptr->cvt_type),

			(char*)& r_desc_ptr->cvt_type,

			buffer );

		break;

	    }

	    case k_resource_id_off : {

		sprintf (buffer, "resource id");

		src_append_machine_code (

			az_src_rec,

			off_offset,

			sizeof (MrmResource_id),

			(char *) _Pointer (rec, off_offset),

			buffer );

		break;

	    }

	    case k_children_off : {

		RGMChildrenDescPtr	c_desc_ptr;

		int			j;

		c_desc_ptr = (RGMChildrenDescPtr) _Pointer(rec, off_offset);

		sprintf (buffer, "Children count: %d",

			 c_desc_ptr->count);

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMChildrenDesc, off_offset, count),

			sizeof (c_desc_ptr->count),

			(char*)& c_desc_ptr->count,

			buffer );

		off_offset =

			_OffsetArray (RGMChildrenDesc, off_offset, child);

		for (j = 0; j < c_desc_ptr->count;

			     j++, off_offset += sizeof (RGMChildDesc)) {

		    off_put (k_child_off, off_offset);

		}	/* for */

		child_index = 0;

		break;

	    }

	    case k_child_off : {

		RGMChildDescPtr		c_ptr;

		int			j;

		c_ptr = (RGMChildDescPtr) _Pointer(rec, off_offset);

		j = child_index;

		child_index++;

		if (c_ptr->manage) {

		    sprintf (buffer, "(%d) managed", j);

		} else {

		    sprintf (buffer, "(%d) unmanaged", j);

		}

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMChildDesc, off_offset, manage),

			sizeof (c_ptr->manage),

			(char*)& c_ptr->manage,

			buffer );

		sprintf (buffer, "(%d) access: %s", j,

				access_from_code (c_ptr->access) );

		src_append_machine_code (

			az_src_rec,

			_Offset (RGMChildDesc, off_offset, access),

			sizeof (c_ptr->access),

			(char*)& c_ptr->access,

			buffer );

		switch (c_ptr->type) {

		    case URMrIndex:

			sprintf (buffer, "(%d) index, offset: %X (hex)",

				j, c_ptr->key.index_offs);

			src_append_machine_code (

				az_src_rec,

				_Offset (RGMChildDesc, off_offset, type),

				sizeof (c_ptr->type) + sizeof (c_ptr->key),

				(char*)& c_ptr->type,

				buffer );

			off_put (k_name_off, c_ptr->key.index_offs);

			break;

		    case URMrRID:

			sprintf (buffer,

				"(%d) resource ID, offset: %X (hex)",

				j, _Offset (RGMChildDesc, off_offset, key) );

			src_append_machine_code (

				az_src_rec,

				_Offset (RGMChildDesc, off_offset, type),

				sizeof (c_ptr->type),

				(char*)& c_ptr->type,

				buffer );

			off_put (k_resource_id_off,

				_Offset (RGMChildDesc, off_offset, key) );

			break;

		    default:

			sprintf (buffer, "(%d) unknown class", j);

			src_append_machine_code (

				az_src_rec,

				_Offset (RGMChildDesc, off_offset, type),

				sizeof (c_ptr->type),

				(char*)& c_ptr->type,

				buffer );

			break;

		}

		break;

	    }

	    default : {

		break;

	    }

        }	/* switch	*/

    }		/*  for		*/

    src_append_machine_code ( az_src_rec, 0, 0, 0, 0 );

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**