cde/osf/uil/UilLstMac.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /*
  24  *  @OSF_COPYRIGHT@
  25  *  COPYRIGHT NOTICE
  26  *  Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
  27  *  ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
  28  *  the full copyright text.
  29 */
  30 /*
  31  * HISTORY
  32 */
  33 #ifdef REV_INFO
  34 #ifndef lint
  35 static char rcsid[] = "$TOG: UilLstMac.c /main/15 1997/03/12 15:21:48 dbl $"
  36 #endif
  37 #endif
  38
  39 /*
  40 *  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
  41
  42 /*
  43 **++
  44 **  FACILITY:
  45 **
  46 **      User Interface Language Compiler (UIL)
  47 **
  48 **  ABSTRACT:
  49 **
  50 **      This module contain the routines for creating the machine listing.
  51 **
  52 **--
  53 **/
  54
  55
  56 /*
  57 **
  58 **  INCLUDE FILES
  59 **
  60 **/
  61
  62
  63
  64 #include <Mrm/MrmAppl.h>
  65 #include <X11/Xmd.h>            /* For 64-bit architecture dependencies */
  66
  67
  68 #ifdef DXM_V11
  69 #include <DXm/DXmHelpB.h>
  70 #endif
  71
  72 #include "UilDefI.h"
  73
  74
  75 /*
  76 **
  77 **  DEFINE and MACRO DEFINITIONS
  78 **
  79 **/
  80
  81 /*      Holds offset info for machine code listing.     */
  82
  83 typedef struct _off_info {
  84         unsigned short int      w_off_type;
  85         unsigned short int      w_off_offset;
  86         } off_info_type;
  87
  88 #define         k_name_off              0
  89 #define         k_class_off             1
  90 #define         k_arglist_off           2
  91 #define         k_children_off          3
  92 #define         k_comment_off           4
  93 #define         k_creation_off          5
  94 #define         k_callback_off          6
  95 #define         k_resource_off          7
  96 #define         k_float_off             8
  97 #define         k_unknown_off           9
  98 #define         k_resource_id_off       10
  99 #define         k_child_off             11
 100 #define         k_text_entry_off        12
 101 #define         k_null_text_entry_off   13
 102 #define         k_single_float_off      14 /* single float data type RAP */
 103
 104 #define         k_off_stack_size        300
 105
 106 static off_info_type    off_info_stack [k_off_stack_size];
 107
 108 static int              off_info_cnt = 0;
 109
 110
 111
 112
 113 #define         off_stack_empty         (off_info_cnt == 0)
 114
 115 #define _Offset(type,base,field)    \
 116         ((unsigned int)(base + XtOffsetOf(type, field)))
 117
 118 #if defined(__STDC__)
 119 #define _OffsetArray(type,base,field)    \
 120         ((unsigned int)(base + XtOffsetOf(type, field)))
 121 #else
 122 #define _OffsetArray(type,base,field)    \
 123         ((unsigned int)(base + XtOffsetOf(type, field[0])))
 124 #endif
 125 #define _Pointer(base,offset) ((char *)(base)+(offset))
 126
 127 #define ASNHEADERLEN 3
 128 #define CSLONGBIT    (unsigned char)(0x80)
 129 #define ASNstrlen(a) (ASNHEADERLEN+ \
 130                       (((unsigned char)(a)[ASNHEADERLEN]&CSLONGBIT)? \
 131                        (((unsigned short)((a)[ASNHEADERLEN+1])<<8) | \
 132                         (unsigned short)((a)[ASNHEADERLEN+2]))+3 : \
 133                        ((unsigned short)((a)[ASNHEADERLEN]))+1))
 134
 135 /*
 136 **
 137 **  EXTERNAL VARIABLE DECLARATIONS
 138 **
 139 **/
 140
 141
 142 /*
 143 **
 144 **  GLOBAL VARIABLE DECLARATIONS
 145 **
 146 **/
 147
 148
 149 /*
 150 **
 151 **  OWN VARIABLE DECLARATIONS
 152 **
 153 **/
 154
 155
 156 \f
 157 /*
 158 **++
 159 **  FUNCTIONAL DESCRIPTION:
 160 **
 161 **      This function saves the machine code listing information for widgets.
 162 **
 163 **  FORMAL PARAMETERS:
 164 **
 165 **      widget_entry    Symbol node for this widget
 166 **      az_context      context containing the URM output information.
 167 **
 168 **  IMPLICIT INPUTS:
 169 **
 170 **      none
 171 **
 172 **  IMPLICIT OUTPUTS:
 173 **
 174 **      none
 175 **
 176 **  FUNCTION VALUE:
 177 **
 178 **      void
 179 **
 180 **  SIDE EFFECTS:
 181 **
 182 **      the machine code is saved in the source record structure for
 183 **      the widget.
 184 **
 185 **--
 186 **/
 187
 188 void            save_widget_machine_code ( widget_entry, az_context )
 189
 190 sym_widget_entry_type   * widget_entry;
 191 URMResourceContext      * az_context;
 192
 193 {
 194
 195     RGMWidgetRecordPtr          w_rec;
 196     char                        buffer [132];
 197     unsigned short int          w_rec_size;
 198     src_source_record_type      * az_src_rec;
 199
 200 #define _WRPointer(w_rec,offset) ((char *)(w_rec)+(offset))
 201
 202 #define _WROffset(field)    (_Offset(RGMWidgetRecord,0,field))
 203
 204     az_src_rec = widget_entry->header.az_src_rec;
 205
 206     if (widget_entry->resource_id != 0 ) {
 207         sprintf (buffer, "Resource ID: %08X", widget_entry->resource_id);
 208         src_append_machine_code (
 209                 az_src_rec,
 210                 0,
 211                 0, 0,
 212                 buffer );
 213     } else if (widget_entry->obj_header.az_name != NULL) {
 214         sprintf (buffer, "Resource index: %s",
 215                  widget_entry->obj_header.az_name->c_text);
 216         src_append_machine_code (
 217                 az_src_rec,
 218                 0,
 219                 0, 0,
 220                 buffer );
 221     }
 222
 223     w_rec = (RGMWidgetRecordPtr) UrmRCBuffer (az_context);
 224
 225     src_append_machine_code (
 226                 az_src_rec,
 227                 _WROffset (validation),
 228                 sizeof (w_rec->validation), (char*)& w_rec->validation,
 229                 "widget record" );
 230
 231     sprintf (buffer, "size: %d", w_rec->size);
 232
 233     src_append_machine_code (
 234                 az_src_rec,
 235                 _WROffset (size),
 236                 sizeof (w_rec->size), (char*)& w_rec->size,
 237                 buffer );
 238
 239     w_rec_size = w_rec->size;
 240
 241     sprintf (buffer, "access: %s",
 242                         access_from_code (w_rec->access) );
 243
 244     src_append_machine_code (
 245                 az_src_rec,
 246                 _WROffset (access),
 247                 sizeof (w_rec->access), (char*)& w_rec->access,
 248                 buffer );
 249
 250     sprintf (buffer, "locked: ");
 251
 252     if (w_rec->lock) {
 253         strcat (buffer, "true");
 254     } else {
 255         strcat (buffer, "false");
 256     }
 257
 258     src_append_machine_code (
 259                 az_src_rec,
 260                 _WROffset (lock),
 261                 sizeof (w_rec->lock), (char*)& w_rec->lock,
 262                 buffer );
 263
 264     sprintf (buffer, "type: ");
 265
 266     strcat (buffer, class_name_from_code (w_rec->type));
 267
 268     src_append_machine_code (
 269                 az_src_rec,
 270                 _WROffset (type),
 271                 sizeof (w_rec->type), (char*)& w_rec->type,
 272                 buffer );
 273
 274     if (w_rec->name_offs == (MrmOffset) 0) {
 275         sprintf (buffer, "no name specified");
 276     } else {
 277         sprintf (buffer, "name: offset %X (hex)",
 278                  w_rec->name_offs);
 279         off_put (k_name_off, w_rec->name_offs);
 280     }
 281
 282     src_append_machine_code (
 283                 az_src_rec,
 284                 _WROffset (name_offs),
 285                 sizeof (w_rec->name_offs),
 286                 (char*)& w_rec->name_offs,
 287                 buffer );
 288
 289     if (w_rec->class_offs == (MrmOffset) 0) {
 290         sprintf (buffer, "class: builtin");
 291     } else {
 292         sprintf (buffer, "class: offset %X (hex)",
 293                  w_rec->class_offs);
 294         off_put (k_class_off, w_rec->class_offs);
 295     }
 296
 297     src_append_machine_code (
 298                 az_src_rec,
 299                 _WROffset (class_offs),
 300                 sizeof (w_rec->class_offs),
 301                 (char*)& w_rec->class_offs,
 302                 buffer );
 303
 304     if (w_rec->arglist_offs == (MrmOffset) 0) {
 305         sprintf (buffer, "no argument list");
 306     } else {
 307         sprintf (buffer, "argument list offset: %X (hex)", w_rec->arglist_offs);
 308         off_put (k_arglist_off, w_rec->arglist_offs);
 309     }
 310
 311     src_append_machine_code (
 312                 az_src_rec,
 313                 _WROffset (arglist_offs),
 314                 sizeof (w_rec->arglist_offs),
 315                 (char*)& w_rec->arglist_offs,
 316                 buffer );
 317
 318     if (w_rec->children_offs == (MrmOffset) 0) {
 319         sprintf (buffer, "no children");
 320     } else {
 321         sprintf (buffer, "children list offset: %X (hex)",
 322                  w_rec->children_offs);
 323         off_put (k_children_off, w_rec->children_offs);
 324     }
 325
 326     src_append_machine_code (
 327                 az_src_rec,
 328                 _WROffset (children_offs),
 329                 sizeof (w_rec->children_offs),
 330                 (char*)& w_rec->children_offs,
 331                 buffer );
 332
 333     if (w_rec->comment_offs == (MrmOffset) 0) {
 334         sprintf (buffer, "no comment specified");
 335     } else {
 336         sprintf (buffer, "comment: offset %X (hex)",
 337                  w_rec->comment_offs);
 338         off_put (k_comment_off, w_rec->comment_offs);
 339     }
 340
 341     src_append_machine_code (
 342                 az_src_rec,
 343                 _WROffset (comment_offs),
 344                 sizeof (w_rec->comment_offs),
 345                 (char*)& w_rec->comment_offs,
 346                 buffer );
 347
 348     if (w_rec->creation_offs == (MrmOffset) 0) {
 349         sprintf (buffer, "no creation callback");
 350     } else {
 351         sprintf (buffer, "creation callback offset: %X (hex)",
 352                  w_rec->creation_offs);
 353         off_put (k_creation_off, w_rec->creation_offs);
 354     }
 355
 356     src_append_machine_code (
 357                 az_src_rec,
 358                 _WROffset (creation_offs),
 359                 sizeof (w_rec->creation_offs),
 360                 (char*)& w_rec->creation_offs,
 361                 buffer );
 362
 363     unload_stack(( char *) w_rec, w_rec_size, az_src_rec );
 364
 365 }
 366 \f
 367 /*
 368 **++
 369 **  FUNCTIONAL DESCRIPTION:
 370 **
 371 **      This function unloads entries placed on a stack and outputs them
 372 **      into the listing.  The routine is used by both widgets and gadgets
 373 **      to output their argument, control, and callback lists.
 374 **
 375 **  FORMAL PARAMETERS:
 376 **
 377 **      rec         base of the record being annotated
 378 **      rec_sizr    size of the record being annotated
 379 **      az_src_rec  address of the source for record being annotated
 380 **
 381 **  IMPLICIT INPUTS:
 382 **
 383 **
 384 **  IMPLICIT OUTPUTS:
 385 **
 386 **
 387 **  SIDE EFFECTS:
 388 **
 389 **
 390 **--
 391 **/
 392 void    unload_stack( rec, rec_size, az_src_rec )
 393
 394 char                    *rec;
 395 int                     rec_size;
 396 src_source_record_type  *az_src_rec;
 397
 398 {
 399
 400     char                        buffer [132], * ptr;
 401     int                         child_index;
 402
 403     while ( ! off_stack_empty ) {
 404
 405         unsigned short          off_type, off_offset;
 406
 407         off_get (& off_type, & off_offset);
 408
 409         switch (off_type) {
 410
 411             case k_name_off :
 412             case k_class_off :
 413             case k_comment_off : {
 414
 415                 ptr = (char *) _Pointer(rec, off_offset);
 416                 src_append_machine_code (
 417                         az_src_rec, off_offset,
 418                         strlen (ptr) + 1, ptr, NULL );
 419                 break;
 420             }
 421
 422             case k_unknown_off : {
 423
 424                 unsigned short int      len;
 425
 426 /*      Write out everything up to the next offset or the end of the
 427         record. */
 428
 429                 if ( ! off_stack_empty ) {
 430                     unsigned short int  next_type, next_offset;
 431
 432                     off_get (& next_type, & next_offset);
 433                     off_put (next_type, next_offset);
 434                     len = next_offset - off_offset;
 435                 } else {
 436                     len = rec_size - off_offset;
 437                 }
 438
 439                 ptr = (char *) _Pointer(rec, off_offset);
 440                 src_append_machine_code (
 441                         az_src_rec, off_offset,
 442                         len, ptr, NULL );
 443                 break;
 444             }
 445
 446             case k_arglist_off : {
 447
 448                 RGMArgListDescPtr       argdesc;
 449                 RGMArgumentPtr          arg_ptr;
 450                 int                     j;
 451
 452                 argdesc = (RGMArgListDescPtr) _Pointer(rec, off_offset);
 453
 454                 sprintf (buffer, "argument count: %d", argdesc->count);
 455
 456                 src_append_machine_code (
 457                         az_src_rec,
 458                         _Offset (RGMArgListDesc, off_offset, count),
 459                         sizeof (argdesc->count),
 460                         (char*)& argdesc->count,
 461                         buffer );
 462
 463                 sprintf (buffer, "related argument count: %d", argdesc->extra);
 464
 465                 src_append_machine_code (
 466                         az_src_rec,
 467                         _Offset (RGMArgListDesc, off_offset, extra),
 468                         sizeof (argdesc->extra),
 469                         (char*)& argdesc->extra,
 470                         buffer );
 471
 472                 off_offset = _OffsetArray (RGMArgListDesc, off_offset, args);
 473
 474                 for (j = 0, arg_ptr = argdesc->args;
 475                      j < argdesc->count;
 476                      j++, arg_ptr++, off_offset += sizeof (RGMArgument)) {
 477
 478                     if (arg_ptr->tag_code != UilMrmUnknownCode )
 479                         {
 480                         sprintf (buffer,
 481                                  "(%d) arg type: %s",
 482                                  j,
 483                                  resource_name_from_code(arg_ptr->tag_code));
 484                         }
 485                     else
 486                         {
 487                         ptr = (char *)
 488                             _Pointer(rec,arg_ptr->stg_or_relcode.tag_offs);
 489                         sprintf (buffer,
 490                                  "(%d) arg type: %s (user defined)",
 491                                  j,
 492                                  ptr);
 493                         }
 494
 495                     src_append_machine_code (
 496                         az_src_rec,
 497                         _Offset (RGMArgument, off_offset, tag_code),
 498                         sizeof (arg_ptr->tag_code),
 499                         (char*)& arg_ptr->tag_code,
 500                         buffer );
 501
 502                     if (arg_ptr->stg_or_relcode.tag_offs == (MrmOffset) 0) {
 503                         sprintf (buffer, "(%d) no tag offset", j);
 504                     } else {
 505                         sprintf (buffer, "(%d) tag offset: %X (hex)",
 506                                         j, arg_ptr->stg_or_relcode.tag_offs);
 507                         off_put (k_name_off, arg_ptr->stg_or_relcode.tag_offs);
 508                     }
 509
 510                     src_append_machine_code (
 511                         az_src_rec,
 512                         _Offset (RGMArgument, off_offset, stg_or_relcode.tag_offs),
 513                         sizeof (arg_ptr->stg_or_relcode.tag_offs),
 514                         (char*)& arg_ptr->stg_or_relcode.tag_offs,
 515                         buffer );
 516
 517                     sprintf (buffer, "(%d) type: %s",
 518                         j, type_from_code (arg_ptr->arg_val.rep_type) );
 519
 520                     src_append_machine_code (
 521                         az_src_rec,
 522                         _Offset (RGMArgument, off_offset,
 523                                                         arg_val.rep_type),
 524                         sizeof (arg_ptr->arg_val.rep_type),
 525                         (char*)& arg_ptr->arg_val.rep_type,
 526                         buffer );
 527
 528                     sprintf (buffer, "(%d) ", j);
 529
 530                     format_arg_value (& arg_ptr->arg_val,
 531                                 & buffer [strlen (buffer)]);
 532
 533                     src_append_machine_code (
 534                         az_src_rec,
 535                         _Offset (RGMArgument, off_offset,
 536                                                         arg_val.datum),
 537                         sizeof (arg_ptr->arg_val.datum),
 538                         (char*)& arg_ptr->arg_val.datum,
 539                         buffer );
 540
 541                 }
 542
 543                 break;
 544             }
 545
 546             case k_float_off : {
 547
 548                 double  * dptr;
 549
 550                 dptr = (double *) _Pointer (rec, off_offset);
 551                 sprintf (buffer, "floating point value: %g", (* dptr));
 552                 src_append_machine_code (
 553                         az_src_rec,
 554                         off_offset,
 555                         sizeof (double), (char*)dptr, buffer );
 556                 break;
 557             }
 558
 559 /* single float data type RAP */
 560             case k_single_float_off :
 561               {
 562                 float *fptr;
 563
 564                 fptr = (float *) _Pointer(rec, off_offset);
 565                 sprintf(buffer, "Single float value: %g", (* fptr));
 566                 src_append_machine_code (
 567                                          az_src_rec,
 568                                          off_offset,
 569                                          sizeof (float), (char*)fptr, buffer);
 570                 break;
 571               }
 572
 573
 574             case k_creation_off :
 575             case k_callback_off : {
 576
 577                 RGMCallbackDescPtr      cb_desc_ptr;
 578                 RGMCallbackItemPtr      cb_item_ptr;
 579                 int                     j;
 580
 581                 cb_desc_ptr =
 582                         (RGMCallbackDescPtr) _Pointer (rec, off_offset);
 583
 584                 src_append_machine_code (
 585                         az_src_rec,
 586                         _Offset (RGMCallbackDesc, off_offset, validation),
 587                         sizeof (cb_desc_ptr->validation),
 588                         (char*)& cb_desc_ptr->validation,
 589                         "callback descriptor" );
 590
 591                 sprintf (buffer, "callback count: %d", cb_desc_ptr->count);
 592
 593                 src_append_machine_code (
 594                         az_src_rec,
 595                         _Offset (RGMCallbackDesc, off_offset, count),
 596                         sizeof (cb_desc_ptr->count),
 597                         (char*)& cb_desc_ptr->count,
 598                         buffer );
 599
 600                 off_offset =
 601                         _OffsetArray (RGMCallbackDesc, off_offset, item);
 602
 603                 for (j = 0, cb_item_ptr = cb_desc_ptr->item;
 604                      j < cb_desc_ptr->count;
 605                      j++, cb_item_ptr++,
 606                                 off_offset += sizeof (RGMCallbackItem)) {
 607
 608                     sprintf (buffer,
 609                                 "(%d) routine name offset: %X (hex)",
 610                                 j, cb_item_ptr->cb_item.routine);
 611
 612                     src_append_machine_code (
 613                         az_src_rec,
 614                         _Offset (RGMCallbackItem, off_offset,
 615                                  cb_item.routine),
 616 #ifndef WORD64
 617                         sizeof (cb_item_ptr->cb_item.routine),
 618                         (char*)& cb_item_ptr->cb_item.routine,
 619 #else /* 64-bit architecture */
 620                         4,
 621                         (char*)& cb_item_ptr->cb_item,
 622 #endif /* WORD64 */
 623                         buffer );
 624
 625                     off_put (k_name_off, cb_item_ptr->cb_item.routine);
 626
 627                     sprintf (buffer, "(%d) routine tag type: %s",
 628                         j, type_from_code (
 629                                 cb_item_ptr->cb_item.rep_type) );
 630
 631                     src_append_machine_code
 632                         (az_src_rec,
 633                          _Offset (RGMCallbackItem, off_offset,
 634                                   cb_item.rep_type),
 635 #ifndef WORD64
 636                          sizeof (cb_item_ptr->cb_item.rep_type),
 637                          (char*)& cb_item_ptr->cb_item.rep_type,
 638 #else /* 64-bit architecture */
 639                         4,
 640                         (char*)& cb_item_ptr->cb_item + 4,
 641 #endif /* WORD64 */
 642                          buffer );
 643
 644                     sprintf (buffer, "(%d) value: ", j);
 645                     src_append_machine_code
 646                         (az_src_rec,
 647                          _Offset (RGMCallbackItem, off_offset,
 648                                   cb_item.datum),
 649                          sizeof (cb_item_ptr->cb_item.datum),
 650                          (char*)& cb_item_ptr->cb_item.datum,
 651                          buffer );
 652
 653                 }       /* for */
 654
 655                 break;
 656             }
 657
 658             case k_resource_off : {
 659
 660                 RGMResourceDescPtr      r_desc_ptr;
 661
 662                 r_desc_ptr =
 663                         (RGMResourceDescPtr) _Pointer (rec, off_offset);
 664
 665                 sprintf (buffer, "resource descriptor, size: %d",
 666                          r_desc_ptr->size);
 667
 668                 src_append_machine_code (
 669                         az_src_rec,
 670                         _Offset (RGMResourceDesc, off_offset, size),
 671                         sizeof (r_desc_ptr->size),
 672                         (char*)& r_desc_ptr->size,
 673                         buffer );
 674
 675                 sprintf (buffer, "access: %s",
 676                                 access_from_code (r_desc_ptr->access) );
 677
 678                 src_append_machine_code (
 679                         az_src_rec,
 680                         _Offset (RGMResourceDesc, off_offset, access),
 681                         sizeof (r_desc_ptr->access),
 682                         (char*)& r_desc_ptr->access,
 683                         buffer );
 684
 685                 switch (r_desc_ptr->type) {
 686                     case URMrIndex:
 687                         sprintf (buffer, "index, offset: %X (hex)",
 688                                 _Offset (RGMResourceDesc, off_offset, key) );
 689
 690                         off_put (k_name_off,
 691                                 _Offset (RGMResourceDesc, off_offset, key) );
 692                         break;
 693
 694                     case URMrRID:
 695
 696                         sprintf (buffer, "resource ID, offset: %X (hex)",
 697                                 _Offset (RGMResourceDesc, off_offset, key) );
 698
 699                         off_put (k_resource_id_off,
 700                                 _Offset (RGMResourceDesc, off_offset, key) );
 701                         break;
 702
 703                     default:
 704                         sprintf (buffer, "unknown resource type");
 705                         break;
 706                 }
 707
 708                 src_append_machine_code (
 709                         az_src_rec,
 710                         _Offset (RGMResourceDesc, off_offset, type),
 711                         sizeof (r_desc_ptr->type),
 712                         (char*)& r_desc_ptr->type,
 713                         buffer );
 714
 715                 sprintf (buffer, "resource group: %s",
 716                          group_from_code (r_desc_ptr->res_group) );
 717
 718                 src_append_machine_code (
 719                         az_src_rec,
 720                         _Offset (RGMResourceDesc, off_offset, res_group),
 721                         sizeof (r_desc_ptr->res_group),
 722                         (char*)& r_desc_ptr->res_group,
 723                         buffer );
 724
 725                 sprintf (buffer, "resource type: %s",
 726                         (r_desc_ptr->res_group == URMgLiteral) ?
 727                                 type_from_code (r_desc_ptr->cvt_type) :
 728                                 class_name_from_code (r_desc_ptr->cvt_type) );
 729
 730                 src_append_machine_code (
 731                         az_src_rec,
 732                         _Offset (RGMResourceDesc, off_offset, cvt_type),
 733                         sizeof (r_desc_ptr->cvt_type),
 734                         (char*)& r_desc_ptr->cvt_type,
 735                         buffer );
 736
 737                 break;
 738             }
 739
 740             case k_resource_id_off : {
 741
 742                 sprintf (buffer, "resource id");
 743
 744                 src_append_machine_code (
 745                         az_src_rec,
 746                         off_offset,
 747                         sizeof (MrmResource_id),
 748                         (char *) _Pointer (rec, off_offset),
 749                         buffer );
 750
 751                 break;
 752             }
 753
 754             case k_children_off : {
 755
 756                 RGMChildrenDescPtr      c_desc_ptr;
 757                 int                     j;
 758
 759                 c_desc_ptr = (RGMChildrenDescPtr) _Pointer(rec, off_offset);
 760
 761                 sprintf (buffer, "Children count: %d",
 762                          c_desc_ptr->count);
 763
 764                 src_append_machine_code (
 765                         az_src_rec,
 766                         _Offset (RGMChildrenDesc, off_offset, count),
 767                         sizeof (c_desc_ptr->count),
 768                         (char*)& c_desc_ptr->count,
 769                         buffer );
 770
 771                 off_offset =
 772                         _OffsetArray (RGMChildrenDesc, off_offset, child);
 773
 774                 for (j = 0; j < c_desc_ptr->count;
 775                              j++, off_offset += sizeof (RGMChildDesc)) {
 776
 777                     off_put (k_child_off, off_offset);
 778                 }       /* for */
 779
 780                 child_index = 0;
 781
 782                 break;
 783             }
 784
 785             case k_child_off : {
 786
 787                 RGMChildDescPtr         c_ptr;
 788                 int                     j;
 789
 790                 c_ptr = (RGMChildDescPtr) _Pointer(rec, off_offset);
 791
 792                 j = child_index;
 793
 794                 child_index++;
 795
 796                 if (c_ptr->manage) {
 797                     sprintf (buffer, "(%d) managed", j);
 798                 } else {
 799                     sprintf (buffer, "(%d) unmanaged", j);
 800                 }
 801
 802                 src_append_machine_code (
 803                         az_src_rec,
 804                         _Offset (RGMChildDesc, off_offset, manage),
 805                         sizeof (c_ptr->manage),
 806                         (char*)& c_ptr->manage,
 807                         buffer );
 808
 809                 sprintf (buffer, "(%d) access: %s", j,
 810                                 access_from_code (c_ptr->access) );
 811
 812                 src_append_machine_code (
 813                         az_src_rec,
 814                         _Offset (RGMChildDesc, off_offset, access),
 815                         sizeof (c_ptr->access),
 816                         (char*)& c_ptr->access,
 817                         buffer );
 818
 819                 switch (c_ptr->type) {
 820                     case URMrIndex:
 821                         sprintf (buffer, "(%d) index, offset: %X (hex)",
 822                                 j, c_ptr->key.index_offs);
 823
 824                         src_append_machine_code (
 825                                 az_src_rec,
 826                                 _Offset (RGMChildDesc, off_offset, type),
 827                                 sizeof (c_ptr->type) + sizeof (c_ptr->key),
 828                                 (char*)& c_ptr->type,
 829                                 buffer );
 830
 831                         off_put (k_name_off, c_ptr->key.index_offs);
 832
 833                         break;
 834
 835                     case URMrRID:
 836                         sprintf (buffer,
 837                                 "(%d) resource ID, offset: %X (hex)",
 838                                 j, _Offset (RGMChildDesc, off_offset, key) );
 839
 840                         src_append_machine_code (
 841                                 az_src_rec,
 842                                 _Offset (RGMChildDesc, off_offset, type),
 843                                 sizeof (c_ptr->type),
 844                                 (char*)& c_ptr->type,
 845                                 buffer );
 846
 847                         off_put (k_resource_id_off,
 848                                 _Offset (RGMChildDesc, off_offset, key) );
 849                         break;
 850
 851                     default:
 852
 853                         sprintf (buffer, "(%d) unknown class", j);
 854
 855                         src_append_machine_code (
 856                                 az_src_rec,
 857                                 _Offset (RGMChildDesc, off_offset, type),
 858                                 sizeof (c_ptr->type),
 859                                 (char*)& c_ptr->type,
 860                                 buffer );
 861
 862                         break;
 863                 }
 864
 865                 break;
 866             }
 867
 868             default : {
 869
 870                 break;
 871             }
 872         }       /* switch       */
 873     }           /*  for         */
 874
 875     src_append_machine_code ( az_src_rec, 0, 0, 0, 0 );
 876
 877 }
 878 \f
 879 /*
 880 **++
 881 **  FUNCTIONAL DESCRIPTION:
 882 **
 883 **      This function saves the machine code listing information for values.
 884 **
 885 **  FORMAL PARAMETERS:
 886 **
 887 **      value_entry     Symbol node for this value
 888 **      az_context      context containing the URM output information.
 889 **
 890 **  IMPLICIT INPUTS:
 891 **
 892 **      none
 893 **
 894 **  IMPLICIT OUTPUTS:
 895 **
 896 **      none
 897 **
 898 **  FUNCTION VALUE:
 899 **
 900 **      void
 901 **
 902 **  SIDE EFFECTS:
 903 **
 904 **      the machine code is saved in the source record structure for this
 905 **      value.
 906 **
 907 **--
 908 **/
 909
 910 void            save_value_machine_code ( value_entry, az_context )
 911
 912 sym_value_entry_type    * value_entry;
 913 URMResourceContext      * az_context;
 914
 915 {
 916     src_source_record_type      * az_src_rec;
 917     char                        buffer [132], * rc_buffer;
 918     unsigned short int          rc_size;
 919
 920     az_src_rec = value_entry->header.az_src_rec;
 921
 922     if (value_entry->resource_id != 0) {
 923         sprintf (buffer, "Resource ID: %08X", value_entry->resource_id);
 924         src_append_machine_code (
 925                 az_src_rec,
 926                 0,
 927                 0, 0,
 928                 buffer );
 929     } else if (value_entry->obj_header.az_name != NULL) {
 930         sprintf (buffer, "Resource index: %s",
 931                  value_entry->obj_header.az_name->c_text);
 932         src_append_machine_code
 933             (az_src_rec,
 934              0,
 935              0, 0,
 936              buffer);
 937     }
 938
 939     sprintf (buffer, "size: %d, group: %s",
 940              UrmRCSize (az_context),
 941              group_from_code (UrmRCGroup (az_context)) );
 942     src_append_machine_code ( az_src_rec, 0, 0, 0, buffer );
 943
 944     sprintf (buffer, "type: %s, access: %s, locked: ",
 945              type_from_code (UrmRCType (az_context)),
 946              access_from_code (UrmRCAccess (az_context)) );
 947
 948     if (UrmRCLock (az_context)) {
 949         strcat (buffer, "true");
 950     } else {
 951         strcat (buffer, "false");
 952     }
 953
 954     src_append_machine_code ( az_src_rec, 0, 0, 0, buffer );
 955
 956     rc_buffer = UrmRCBuffer (az_context);
 957     rc_size = UrmRCSize (az_context);
 958
 959     /*
 960     **  Case on the type of literal.
 961     */
 962
 963     switch (value_entry->b_type)
 964         {
 965         case sym_k_bool_value:
 966
 967             if ( * (unsigned long *) rc_buffer )
 968                 sprintf (buffer, "value: true");
 969             else
 970                 sprintf (buffer, "value: false");
 971             src_append_machine_code (
 972                 az_src_rec, 0, rc_size, rc_buffer, buffer );
 973             break;
 974
 975         case sym_k_integer_value:
 976         case sym_k_horizontal_integer_value:
 977         case sym_k_vertical_integer_value:
 978
 979             sprintf (buffer, "value: %d",
 980                      (* (unsigned long *) rc_buffer) );
 981             src_append_machine_code (
 982                 az_src_rec, 0, rc_size, rc_buffer, buffer );
 983             break;
 984
 985         case sym_k_integer_table_value:
 986         case sym_k_rgb_value:  /* rgb data type RAP */
 987             {
 988             int index = 0;
 989             int offset = 0;
 990
 991             for (offset = 0; offset < (int)rc_size; offset += sizeof(int), index++)
 992                 {
 993                 sprintf (buffer, "value[%d]: %d",
 994                          index, ((unsigned long *) rc_buffer)[index] );
 995
 996                 src_append_machine_code
 997                     (az_src_rec, 0, sizeof(int),
 998                      (char*)&(((unsigned long *)rc_buffer)[index]), buffer );
 999                 }
1000             break;
1001             }
1002
1003         case sym_k_float_value:
1004         case sym_k_horizontal_float_value:
1005         case sym_k_vertical_float_value:
1006             sprintf (buffer, "value: %g",
1007                      (* (double *) rc_buffer) );
1008             src_append_machine_code (
1009                 az_src_rec, 0, rc_size, rc_buffer, buffer );
1010             break;
1011
1012         case sym_k_single_float_value:
1013             sprintf (buffer, "value: %g",
1014                      (* (float *) rc_buffer));
1015             src_append_machine_code
1016                 (az_src_rec, 0, rc_size, rc_buffer, buffer );
1017             break;
1018
1019         case sym_k_char_8_value:
1020         case sym_k_color_value:
1021         case sym_k_color_table_value:
1022         case sym_k_icon_value:
1023         case sym_k_font_value:
1024         case sym_k_fontset_value:
1025         case sym_k_font_table_value:
1026         case sym_k_reason_value:
1027         case sym_k_argument_value:
1028         case sym_k_identifier_value:
1029         case sym_k_compound_string_value:
1030         case sym_k_xbitmapfile_value:
1031         case sym_k_keysym_value:
1032             src_append_machine_code (
1033                 az_src_rec,
1034                 0,
1035                 rc_size, rc_buffer, 0 );
1036             break;
1037
1038         case sym_k_asciz_table_value:
1039         case sym_k_string_table_value: {
1040             RGMTextVectorPtr    tv_ptr;
1041             unsigned short      off_type, off_offset, off_cnt;
1042             int                 i;
1043
1044             off_offset = 0;
1045             tv_ptr = (RGMTextVectorPtr) rc_buffer;
1046             src_append_machine_code (
1047                         az_src_rec,
1048                         _Offset (RGMTextVector, off_offset, validation),
1049                         sizeof (tv_ptr->validation),
1050                         (char*)& tv_ptr->validation,
1051                         "text vector" );
1052
1053             sprintf (buffer, "count: %d", tv_ptr->count);
1054             src_append_machine_code (
1055                         az_src_rec,
1056                         _Offset (RGMTextVector, off_offset, count),
1057                         sizeof (tv_ptr->count), (char*)& tv_ptr->count,
1058                         buffer );
1059
1060             off_offset = _OffsetArray (RGMTextVector, off_offset, item);
1061             for (i = 0; i < tv_ptr->count;
1062                  i++, off_offset += sizeof (RGMTextEntry)) {
1063
1064                 off_put (k_text_entry_off, off_offset);
1065             }
1066
1067             off_put (k_null_text_entry_off, off_offset);
1068             off_cnt = 0;
1069             while ( ! off_stack_empty ) {
1070
1071                 RGMTextEntryPtr te_ptr;
1072                 off_get (& off_type, & off_offset);
1073                 switch (off_type) {
1074                     case k_name_off :
1075
1076                       {
1077                         char *stringPtr = (char *) _Pointer (rc_buffer,off_offset);
1078                         src_append_machine_code (az_src_rec, off_offset,
1079                                                  ASNstrlen( stringPtr ),
1080                                                  stringPtr, NULL );
1081                       }
1082                         break;
1083
1084                     case k_null_text_entry_off :
1085
1086                         src_append_machine_code (
1087                                 az_src_rec, off_offset,
1088                                 sizeof (RGMTextEntry),
1089                                 (char*)_Pointer (rc_buffer, off_offset),
1090                                 "end of text vector" );
1091
1092                         break;
1093
1094                     case k_text_entry_off :
1095
1096                         te_ptr = (RGMTextEntryPtr)
1097                                         _Pointer (rc_buffer, off_offset);
1098
1099                         sprintf (buffer, "(%d) type: %s, offset: %X (hex)",
1100                             off_cnt,
1101                             type_from_code (te_ptr->text_item.rep_type),
1102                             te_ptr->text_item.offset );
1103
1104                         src_append_machine_code (
1105                                 az_src_rec,
1106                                 _Offset (RGMTextEntry, off_offset,
1107                                                                 text_item),
1108                                 sizeof (te_ptr->text_item),
1109                                 (char*)& te_ptr->text_item,
1110                                 buffer );
1111
1112                         off_cnt++;
1113
1114                         off_put (k_name_off, te_ptr->text_item.offset);
1115
1116                         break;
1117
1118                     default:
1119
1120                         sprintf (buffer, "(%d) unknown text entry", i);
1121
1122                         src_append_machine_code (
1123                                 az_src_rec,
1124                                 off_offset,
1125                                 0, 0, buffer );
1126
1127                         break;
1128                     }
1129                 }
1130
1131             break;
1132         }
1133
1134         case sym_k_trans_table_value:
1135
1136             src_append_machine_code (
1137                 az_src_rec, 0, rc_size, rc_buffer, NULL );
1138
1139             break;
1140
1141         default: {
1142
1143             sprintf (buffer, "unknown value");
1144
1145             src_append_machine_code (
1146                 az_src_rec,
1147                 0,
1148                 0, 0, buffer );
1149
1150             break;
1151         }
1152     }
1153
1154     src_append_machine_code ( az_src_rec, 0, 0, 0, 0 );
1155
1156 }
1157 \f
1158 /*
1159 **++
1160 **  FUNCTIONAL DESCRIPTION:
1161 **
1162 **      This function saves the machine code listing information for modules.
1163 **
1164 **  FORMAL PARAMETERS:
1165 **
1166 **      az_src_rec      Source record for this machine code info.
1167 **      az_context      context containing the URM output information.
1168 **
1169 **  IMPLICIT INPUTS:
1170 **
1171 **      none
1172 **
1173 **  IMPLICIT OUTPUTS:
1174 **
1175 **      none
1176 **
1177 **  FUNCTION VALUE:
1178 **
1179 **      void
1180 **
1181 **  SIDE EFFECTS:
1182 **
1183 **      the machine code is saved in the source record structure
1184 **
1185 **--
1186 **/
1187
1188 void            save_module_machine_code ( az_src_rec, az_context )
1189
1190 src_source_record_type  * az_src_rec;
1191 URMResourceContext      * az_context;
1192
1193 {
1194
1195     RGMModuleDescPtr            m_rec;
1196     RGMTopmostDescPtr           t_rec;
1197     char                        buffer [132];
1198     unsigned short              off_offset;
1199     int                         i;
1200
1201     off_offset = 0;
1202
1203     m_rec = (RGMModuleDescPtr) UrmRCBuffer (az_context);
1204
1205     src_append_machine_code (
1206                 az_src_rec,
1207                 _Offset (RGMModuleDesc, off_offset, validation),
1208                 sizeof (m_rec->validation), (char*)& m_rec->validation,
1209                 "module record" );
1210
1211     sprintf (buffer, "topmost count: %d", m_rec->count);
1212
1213     src_append_machine_code (
1214                 az_src_rec,
1215                 _Offset (RGMModuleDesc, off_offset, count),
1216                 sizeof (m_rec->count), (char*)& m_rec->count,
1217                 buffer );
1218
1219     off_offset = _OffsetArray (RGMModuleDesc, off_offset, topmost);
1220
1221     for (i = 0, t_rec = m_rec->topmost;
1222          i < m_rec->count;
1223          i++, t_rec++, off_offset += sizeof (RGMTopmostDesc)) {
1224
1225         sprintf (buffer, "(%d) %s", i, t_rec->index);
1226
1227         src_append_machine_code (
1228                 az_src_rec,
1229                 _OffsetArray (RGMTopmostDesc, off_offset, index),
1230                 strlen(t_rec->index), t_rec->index,
1231                 buffer );
1232
1233     }   /* for */
1234
1235     src_append_machine_code ( az_src_rec, 0, 0, 0, 0 );
1236
1237 }
1238 \f
1239 /*
1240 **++
1241 **  FUNCTIONAL DESCRIPTION:
1242 **
1243 **      This function adds an offset entry to the offset stack for
1244 **      machine code.  The entry is inserted in the proper place in
1245 **      the stack depending on the offset value.
1246 **
1247 **  FORMAL PARAMETERS:
1248 **
1249 **      off_type        type of offset entry
1250 **      off_offset      offset value for this offset entry
1251 **
1252 **  IMPLICIT INPUTS:
1253 **
1254 **      off_info_cnt            number of offset stack entries
1255 **      off_info_stack  stack containing offset entries
1256 **
1257 **  IMPLICIT OUTPUTS:
1258 **
1259 **      off_info_cnt            number of offset stack entries
1260 **      off_info_stack  stack containing offset entries
1261 **
1262 **  FUNCTION VALUE:
1263 **
1264 **      void
1265 **
1266 **  SIDE EFFECTS:
1267 **
1268 **      the offset info is saved in the offset stack
1269 **
1270 **--
1271 **/
1272
1273 void    off_put
1274
1275         (unsigned short off_type, unsigned short off_offset)
1276
1277 {
1278     off_info_type       off_info, * off_info_ptr;
1279     int                 i;
1280
1281     if (off_info_cnt >= k_off_stack_size) {
1282         diag_issue_internal_error ("stack overflow in machine listing");
1283     }
1284
1285     off_info.w_off_type = off_type;
1286     off_info.w_off_offset = off_offset;
1287
1288     /*   Insert on the stack before the first entry with a lower offset
1289          value  */
1290
1291     for (i = 0, off_info_ptr = off_info_stack;
1292                          i < off_info_cnt; i++, off_info_ptr++) {
1293         if (off_info.w_off_offset > off_info_ptr->w_off_offset) {
1294             break;
1295         }
1296     }
1297
1298     _move ( & off_info_ptr [1], off_info_ptr,
1299             (off_info_cnt - i) * sizeof (off_info_type) );
1300
1301     (* off_info_ptr) = off_info;
1302     off_info_cnt++;
1303
1304 }
1305 \f
1306 /*
1307 **++
1308 **  FUNCTIONAL DESCRIPTION:
1309 **
1310 **      This function removes an offset entry to the offset stack for
1311 **      machine code.
1312 **
1313 **  FORMAL PARAMETERS:
1314 **
1315 **      off_type        address to receive the type of offset entry
1316 **      off_offset      address to receive the  offset value for this
1317 **                      offset entry
1318 **
1319 **  IMPLICIT INPUTS:
1320 **
1321 **      off_info_cnt            number of offset stack entries
1322 **      off_info_stack  stack containing offset entries
1323 **
1324 **  IMPLICIT OUTPUTS:
1325 **
1326 **      off_info_cnt            number of offset stack entries
1327 **      off_info_stack  stack containing offset entries
1328 **
1329 **  FUNCTION VALUE:
1330 **
1331 **      void
1332 **
1333 **  SIDE EFFECTS:
1334 **
1335 **      the offset info is retrieved from the offset stack
1336 **
1337 **--
1338 **/
1339
1340 void    off_get (off_type, off_offset)
1341
1342 unsigned short          * off_type;
1343 unsigned short          * off_offset;
1344
1345 {
1346     off_info_type       * off_info_ptr;
1347
1348     if (off_info_cnt <= 0) {
1349         diag_issue_internal_error ("stack underflow in machine listing");
1350     }
1351
1352     /*   Remove from the stack the entry with the lowest offset value   */
1353
1354     off_info_ptr = & off_info_stack [off_info_cnt - 1];
1355
1356     (* off_type) = off_info_ptr->w_off_type;
1357     (* off_offset) = off_info_ptr->w_off_offset;
1358
1359     off_info_cnt--;
1360
1361 }
1362 \f
1363 char * type_from_code
1364
1365         (MrmType type_code)
1366
1367 /*
1368  *++
1369  *
1370  *  PROCEDURE DESCRIPTION:
1371  *
1372  *      This procedure returns the string corresponding to a URM type code
1373  *
1374  *  FORMAL PARAMETERS:
1375  *
1376  *      type            type code from RGMrType...
1377  *
1378  *  IMPLICIT INPUTS:
1379  *
1380  *      none
1381  *
1382  *  IMPLICIT OUTPUTS:
1383  *
1384  *      none
1385  *
1386  *  FUNCTION VALUE:
1387  *
1388  *      The string corresponding to the type code
1389  *
1390  *  SIDE EFFECTS:
1391  *
1392  *      none
1393  *
1394  *--
1395  */
1396
1397 {
1398
1399     switch (type_code)
1400         {
1401         case MrmRtypeInteger:
1402             return uil_datatype_names[sym_k_integer_value];
1403         case MrmRtypeHorizontalInteger:
1404             return uil_datatype_names[sym_k_horizontal_integer_value];
1405         case MrmRtypeVerticalInteger:
1406             return uil_datatype_names[sym_k_vertical_integer_value];
1407         case MrmRtypeBoolean:
1408             return uil_datatype_names[sym_k_bool_value];
1409         case MrmRtypeChar8:
1410             return uil_datatype_names[sym_k_char_8_value];
1411         case MrmRtypeChar8Vector:
1412             return uil_datatype_names[sym_k_asciz_table_value];
1413         case MrmRtypeCString:
1414             return uil_datatype_names[sym_k_compound_string_value];
1415         case MrmRtypeCStringVector:
1416             return uil_datatype_names[sym_k_string_table_value];
1417         case MrmRtypeFloat:
1418             return uil_datatype_names[sym_k_float_value];
1419         case MrmRtypeHorizontalFloat:
1420             return uil_datatype_names[sym_k_horizontal_float_value];
1421         case MrmRtypeVerticalFloat:
1422             return uil_datatype_names[sym_k_vertical_float_value];
1423         case MrmRtypeSingleFloat: /* single float data type RAP */
1424             return uil_datatype_names[sym_k_single_float_value];
1425         case MrmRtypeCallback:
1426             return "callback";
1427         case MrmRtypePixmapImage:
1428             return "pixmap image";
1429         case MrmRtypePixmapDDIF:
1430             return "pixmap DDIF";
1431         case MrmRtypeResource:
1432             return "resource";
1433         case MrmRtypeAddrName:
1434             return "addr name";
1435         case MrmRtypeIconImage:
1436             return uil_datatype_names[sym_k_icon_value];
1437         case MrmRtypeFont:
1438             return uil_datatype_names[sym_k_font_value];
1439         case MrmRtypeFontSet:
1440             return uil_datatype_names[sym_k_fontset_value];
1441         case MrmRtypeFontList:
1442             return uil_datatype_names[sym_k_font_table_value];
1443         case MrmRtypeColor:
1444             return uil_datatype_names[sym_k_color_value];
1445         case MrmRtypeColorTable:
1446             return uil_datatype_names[sym_k_color_table_value];
1447         case MrmRtypeAny:
1448             return uil_datatype_names[sym_k_any_value];
1449         case MrmRtypeTransTable:
1450             return uil_datatype_names[sym_k_trans_table_value];
1451         case MrmRtypeClassRecName:
1452             return uil_datatype_names[sym_k_class_rec_name_value];
1453         case MrmRtypeIntegerVector:
1454             return uil_datatype_names[sym_k_integer_table_value];
1455         case MrmRtypeXBitmapFile:
1456             return uil_datatype_names[sym_k_xbitmapfile_value];
1457           case MrmRtypeKeysym:
1458             return uil_datatype_names[sym_k_keysym_value];
1459         default:
1460             return "unknown";
1461     }
1462
1463 }
1464 \f
1465 char * access_from_code
1466
1467         (MrmFlag access_code)
1468
1469 /*
1470  *++
1471  *
1472  *  PROCEDURE DESCRIPTION:
1473  *
1474  *      This procedure returns the string corresponding to a URM access code
1475  *
1476  *  FORMAL PARAMETERS:
1477  *
1478  *      access_code             access code
1479  *
1480  *  IMPLICIT INPUTS:
1481  *
1482  *      none
1483  *
1484  *  IMPLICIT OUTPUTS:
1485  *
1486  *      none
1487  *
1488  *  FUNCTION VALUE:
1489  *
1490  *      The string corresponding to the access code
1491  *
1492  *  SIDE EFFECTS:
1493  *
1494  *      none
1495  *
1496  *--
1497  */
1498
1499 {
1500
1501     switch (access_code) {
1502         case URMaPublic:        return "public";
1503         case URMaPrivate:       return "private";
1504         default:                return "unknown";
1505     }
1506
1507 }
1508 \f
1509 char * group_from_code
1510
1511         (MrmGroup group_code)
1512
1513 /*
1514  *++
1515  *
1516  *  PROCEDURE DESCRIPTION:
1517  *
1518  *      This procedure returns the string corresponding to a URM group code
1519  *
1520  *  FORMAL PARAMETERS:
1521  *
1522  *      group_code              group code
1523  *
1524  *  IMPLICIT INPUTS:
1525  *
1526  *      none
1527  *
1528  *  IMPLICIT OUTPUTS:
1529  *
1530  *      none
1531  *
1532  *  FUNCTION VALUE:
1533  *
1534  *      The string corresponding to the group code
1535  *
1536  *  SIDE EFFECTS:
1537  *
1538  *      none
1539  *
1540  *--
1541  */
1542
1543 {
1544
1545     switch (group_code) {
1546         case URMgWidget:        return "widget";
1547         case URMgLiteral:       return "literal";
1548         case URMgResourceSet:   return "resource set";
1549         default:                return "unknown";
1550     }
1551
1552 }
1553 \f
1554
1555 void format_arg_value (argval_ptr, buffer)
1556
1557 RGMArgValuePtr          argval_ptr;
1558 char                    * buffer;
1559
1560 /*
1561  *++
1562  *
1563  *  FUNCTION PROTOTYPE
1564  *
1565  *  PROCEDURE DESCRIPTION:
1566  *
1567  *      This routine formats a value descriptor into the buffer.
1568  *
1569  *  FORMAL PARAMETERS:
1570  *
1571  *      argval_ptr      pointer to the argument value descriptor
1572  *      buffer          buffer to receive the formatted value
1573  *
1574  *  IMPLICIT INPUTS:
1575  *
1576  *
1577  *  IMPLICIT OUTPUTS:
1578  *
1579  *
1580  *  FUNCTION VALUE:
1581  *
1582  *  SIDE EFFECTS:
1583  *
1584  *
1585  *--
1586  */
1587
1588 {
1589
1590     switch ( argval_ptr->rep_type ) {
1591
1592         case MrmRtypeInteger:
1593         case MrmRtypeHorizontalInteger:
1594         case MrmRtypeVerticalInteger:
1595             sprintf (buffer, "value: %d", argval_ptr->datum.ival);
1596             break;
1597
1598         case MrmRtypeBoolean:
1599             if (argval_ptr->datum.ival) {
1600                 sprintf (buffer, "value: true");
1601             } else {
1602                 sprintf (buffer, "value: false");
1603             }
1604             break;
1605
1606         case MrmRtypeChar8:
1607         case MrmRtypeCStringVector:
1608         case MrmRtypePixmapImage:
1609         case MrmRtypePixmapDDIF:
1610         case MrmRtypeCString:
1611         case MrmRtypeAddrName:
1612         case MrmRtypeKeysym:
1613             sprintf (buffer, "offset: %X (hex)", argval_ptr->datum.offset);
1614             off_put (k_unknown_off, argval_ptr->datum.offset);
1615             break;
1616
1617         case MrmRtypeFloat:
1618         case MrmRtypeHorizontalFloat:
1619         case MrmRtypeVerticalFloat:
1620             sprintf (buffer, "offset: %X (hex)", argval_ptr->datum.offset);
1621             off_put (k_float_off, argval_ptr->datum.offset);
1622             break;
1623
1624           case MrmRtypeSingleFloat: /* single float data type RAP */
1625             sprintf (buffer, "offset: %X (hex)", argval_ptr->datum.offset);
1626             off_put (k_single_float_off, argval_ptr->datum.offset);
1627             break;
1628
1629         case MrmRtypeCallback:
1630             sprintf (buffer, "offset: %X (hex)", argval_ptr->datum.offset);
1631             off_put (k_callback_off, argval_ptr->datum.offset);
1632             break;
1633
1634         case MrmRtypeResource:
1635             sprintf (buffer, "offset: %X (hex)", argval_ptr->datum.offset);
1636             off_put (k_resource_off, argval_ptr->datum.offset);
1637             break;
1638
1639         default:
1640             sprintf (buffer, "value unknown");
1641             break;
1642     }
1643
1644 }
1645
1646 \f
1647 char * class_name_from_code
1648
1649         (MrmCode class)
1650
1651 /*
1652  *++
1653  *
1654  *  PROCEDURE DESCRIPTION:
1655  *
1656  *      This procedure returns the string corresponding to a URM class code
1657  *
1658  *  FORMAL PARAMETERS:
1659  *
1660  *      class           class code from URMwc...
1661  *
1662  *  IMPLICIT INPUTS:
1663  *
1664  *      none
1665  *
1666  *  IMPLICIT OUTPUTS:
1667  *
1668  *      none
1669  *
1670  *  FUNCTION VALUE:
1671  *
1672  *      The string corresponding to the class code
1673  *
1674  *  SIDE EFFECTS:
1675  *
1676  *      none
1677  *
1678  *--
1679  */
1680
1681 {
1682
1683 int             sym_code;
1684
1685
1686 /*
1687  * Find the sym_k code for the class, then return its name
1688  */
1689 for ( sym_code=sym_k_error_object+1;
1690       sym_code<=uil_max_object;
1691       sym_code++ )
1692     if ( uil_widget_compr[sym_code] == class )
1693         return uil_widget_names[sym_code];
1694 return "unknown";
1695
1696 }
1697
1698 \f
1699 char * resource_name_from_code
1700
1701         (MrmCode resource)
1702
1703 /*
1704  *++
1705  *
1706  *  PROCEDURE DESCRIPTION:
1707  *
1708  *      This procedure returns the string corresponding to a compression code
1709  *
1710  *  FORMAL PARAMETERS:
1711  *
1712  *      resource        compression code for argument or reason
1713  *
1714  *  IMPLICIT INPUTS:
1715  *
1716  *      none
1717  *
1718  *  IMPLICIT OUTPUTS:
1719  *
1720  *      none
1721  *
1722  *  FUNCTION VALUE:
1723  *
1724  *      The string corresponding to the resource code
1725  *
1726  *  SIDE EFFECTS:
1727  *
1728  *      none
1729  *
1730  *--
1731  */
1732
1733 {
1734
1735 int             sym_code;
1736
1737
1738 /*
1739  * Find the sym_k code for the resource, then return its name
1740  */
1741 for ( sym_code=0 ; sym_code<=uil_max_arg ; sym_code++ )
1742     if ( uil_arg_compr[sym_code] == resource )
1743         return uil_argument_names[sym_code];
1744 for ( sym_code=0 ; sym_code<=uil_max_reason ; sym_code++ )
1745     if ( uil_reas_compr[sym_code] == resource )
1746         return uil_reason_names[sym_code];
1747 for ( sym_code=0 ; sym_code<=uil_max_child ; sym_code++ )
1748     if ( uil_child_compr[sym_code] == resource )
1749         return uil_child_names[sym_code];
1750 return "unknown";
1751
1752 }
1753