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