cde/osf/uil/UilLstMac.c

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