1 /******************************************************************************
2 * DESCRIPTION: Dinotrace source: signal handling, sarching, etc
3 *
4 * This file is part of Dinotrace.
5 *
6 * Author: Wilson Snyder <wsnyder@wsnyder.org>
7 *
8 * Code available from: http://www.veripool.org/dinotrace
9 *
10 ******************************************************************************
11 *
12 * Some of the code in this file was originally developed for Digital
13 * Semiconductor, a division of Digital Equipment Corporation. They
14 * gratefuly have agreed to share it, and thus the base version has been
15 * released to the public with the following provisions:
16 *
17 *
18 * This software is provided 'AS IS'.
19 *
20 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THE INFORMATION
21 * (INCLUDING ANY SOFTWARE) PROVIDED, INCLUDING ALL IMPLIED WARRANTIES OF
22 * MERCHANTABILITY AND FITNESS FOR ANY PARTICULAR PURPOSE, AND
23 * NON-INFRINGEMENT. DIGITAL NEITHER WARRANTS NOR REPRESENTS THAT THE USE
24 * OF ANY SOURCE, OR ANY DERIVATIVE WORK THEREOF, WILL BE UNINTERRUPTED OR
25 * ERROR FREE. In no event shall DIGITAL be liable for any damages
26 * whatsoever, and in particular DIGITAL shall not be liable for special,
27 * indirect, consequential, or incidental damages, or damages for lost
28 * profits, loss of revenue, or loss of use, arising out of or related to
29 * any use of this software or the information contained in it, whether
30 * such damages arise in contract, tort, negligence, under statute, in
31 * equity, at law or otherwise. This Software is made available solely for
32 * use by end users for information and non-commercial or personal use
33 * only. Any reproduction for sale of this Software is expressly
34 * prohibited. Any rights not expressly granted herein are reserved.
35 *
36 ******************************************************************************
37 *
38 * Changes made over the basic version are covered by the GNU public licence.
39 *
40 * Dinotrace is free software; you can redistribute it and/or modify
41 * it under the terms of the GNU General Public License as published by
42 * the Free Software Foundation; either version 3, or (at your option)
43 * any later version.
44 *
45 * Dinotrace is distributed in the hope that it will be useful,
46 * but WITHOUT ANY WARRANTY; without even the implied warranty of
47 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
48 * GNU General Public License for more details.
49 *
50 * You should have received a copy of the GNU General Public License
51 * along with Dinotrace; see the file COPYING. If not, write to
52 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
53 * Boston, MA 02111-1307, USA.
54 *
55 *****************************************************************************/
56
57 #include "dinotrace.h"
58
59 #include <assert.h>
60
61 #include <Xm/Form.h>
62 #include <Xm/PushB.h>
63 #include <Xm/ToggleB.h>
64 #include <Xm/SelectioB.h>
65 #include <Xm/Text.h>
66 #include <Xm/List.h>
67 #include <Xm/BulletinB.h>
68 #include <Xm/Label.h>
69 #include <Xm/Separator.h>
70 #include <Xm/Form.h>
71
72 #include "functions.h"
73
74 /**********************************************************************/
75
76 extern void sig_sel_ok_cb(Widget w, Trace_t *trace, XmAnyCallbackStruct *cb);
77 extern void sig_sel_apply_cb(Widget w, Trace_t *trace, XmAnyCallbackStruct *cb);
78 extern void sig_add_sel_cb(Widget w, Trace_t *trace, XmSelectionBoxCallbackStruct *cb);
79 extern void sig_sel_add_all_cb(Widget w, Trace_t *trace, XmAnyCallbackStruct *cb);
80 extern void sig_sel_add_list_cb(Widget w, Trace_t *trace, XmListCallbackStruct *cb);
81 extern void sig_sel_del_all_cb(Widget w, Trace_t *trace, XmAnyCallbackStruct *cb);
82 extern void sig_sel_del_list_cb(Widget w, Trace_t *trace, XmListCallbackStruct *cb);
83 extern void sig_sel_pattern_cb (Widget, Trace_t*, XmAnyCallbackStruct*);
84 extern void sig_sel_del_const_cb(Widget, Trace_t*, XmAnyCallbackStruct*);
85 extern void sig_sel_del_const_xz_cb(Widget, Trace_t*, XmAnyCallbackStruct*);
86 extern void sig_sel_sort_cb(Widget, Trace_t*, XmAnyCallbackStruct*);
87 extern void sig_sel_sort_base_cb(Widget, Trace_t*, XmAnyCallbackStruct*);
88
89
90 /****************************** UTILITIES ******************************/
91
sig_free(Trace_t * trace,Signal_t * sig_ptr,Boolean_t select,Boolean_t recursive)92 void sig_free (
93 /* Free a signal structure, and unlink all traces of it */
94 Trace_t *trace,
95 Signal_t *sig_ptr, /* Pointer to signal to be deleted */
96 Boolean_t select, /* True = selectively pick trace's signals from the list */
97 Boolean_t recursive) /* True = recursively do the entire list */
98 {
99 Signal_t *del_sig_ptr;
100 Trace_t *trace_ptr;
101
102 /* loop and free signal data and each signal structure */
103 while (sig_ptr) {
104 if (!select || sig_ptr->trace == trace) {
105 /* Check head pointers, Including deleted */
106 for (trace_ptr = global->deleted_trace_head; trace_ptr; trace_ptr = trace_ptr->next_trace) {
107 if ( sig_ptr == trace_ptr->dispsig )
108 trace_ptr->dispsig = sig_ptr->forward;
109 if ( sig_ptr == trace_ptr->firstsig )
110 trace_ptr->firstsig = sig_ptr->forward;
111 if ( sig_ptr == trace_ptr->lastsig )
112 trace_ptr->lastsig = sig_ptr->backward;
113 }
114
115 /* free the signal data */
116 del_sig_ptr = sig_ptr;
117
118 if (sig_ptr->forward)
119 ((Signal_t *)(sig_ptr->forward))->backward = sig_ptr->backward;
120 if (sig_ptr->backward)
121 ((Signal_t *)(sig_ptr->backward))->forward = sig_ptr->forward;
122 sig_ptr = sig_ptr->forward;
123
124 /* free the signal structure */
125 if (del_sig_ptr->copyof == NULL) {
126 DFree (del_sig_ptr->bptr);
127 DFree (del_sig_ptr->signame);
128 DFree (del_sig_ptr->xsigname);
129 DFree (del_sig_ptr->note);
130 }
131 DFree (del_sig_ptr);
132 }
133 else {
134 sig_ptr = sig_ptr->forward;
135 }
136 if (!recursive) sig_ptr=NULL;
137 }
138 }
139
140
sig_remove_from_queue(Trace_t * trace,Signal_t * sig_ptr)141 static void sig_remove_from_queue (
142 Trace_t *trace,
143 Signal_t *sig_ptr) /* Signal to remove */
144 /* Removes the signal from the current and any other ques that it is in */
145 {
146 Signal_t *next_sig_ptr, *prev_sig_ptr;
147
148 if (DTPRINT_ENTRY) printf ("In sig_remove_from_queue - trace=%p sig %p\n",trace,sig_ptr);
149
150 /* redirect the forward pointer */
151 prev_sig_ptr = sig_ptr->backward;
152 if (prev_sig_ptr) {
153 prev_sig_ptr->forward = sig_ptr->forward;
154 }
155
156 /* if not the last signal redirect the backward pointer */
157 next_sig_ptr = sig_ptr->forward;
158 if ( next_sig_ptr != NULL ) {
159 next_sig_ptr->backward = sig_ptr->backward;
160 }
161
162 /* if the signal is the first screen signal, change it */
163 if ( sig_ptr == trace->dispsig ) {
164 trace->dispsig = sig_ptr->forward;
165 }
166 /* if the signal is the first signal, change it */
167 if ( sig_ptr == trace->firstsig ) {
168 trace->firstsig = sig_ptr->forward;
169 }
170 /* if the signal is the last signal, change it */
171 if ( sig_ptr == trace->lastsig ) {
172 trace->lastsig = sig_ptr->backward;
173 }
174
175 trace->numsig--;
176 }
177
178 #define ADD_LAST ((Signal_t *)(-1))
sig_add_to_queue(Trace_t * trace,Signal_t * sig_ptr,Signal_t * loc_sig_ptr)179 static void sig_add_to_queue (
180 Trace_t *trace,
181 Signal_t *sig_ptr, /* Signal to add */
182 Signal_t *loc_sig_ptr) /* Pointer to signal ahead of one to add, NULL=1st, ADD_LAST=last */
183 {
184 Signal_t *next_sig_ptr, *prev_sig_ptr;
185
186 if (DTPRINT_ENTRY) printf ("In sig_add_to_queue - trace=%p loc=%p%s\n",trace,
187 loc_sig_ptr, loc_sig_ptr==ADD_LAST?"=last":"");
188
189 if (sig_ptr==loc_sig_ptr) {
190 loc_sig_ptr = loc_sig_ptr->forward;
191 }
192
193 /*printf ("iPrev %d next %d sig %d top %d\n", prev_sig_ptr, next_sig_ptr, sig_ptr, *top_pptr);*/
194
195 /* Insert into first position? */
196 if (loc_sig_ptr == NULL) {
197 next_sig_ptr = trace->firstsig;
198 prev_sig_ptr = NULL;
199 }
200 else if (loc_sig_ptr == ADD_LAST) {
201 next_sig_ptr = NULL;
202 prev_sig_ptr = trace->lastsig;
203 }
204 else {
205 next_sig_ptr = loc_sig_ptr->forward;
206 prev_sig_ptr = loc_sig_ptr;
207 }
208
209 sig_ptr->forward = next_sig_ptr;
210 sig_ptr->backward = prev_sig_ptr;
211 trace->numsig++;
212 /* restore signal next in list */
213 if (next_sig_ptr) {
214 next_sig_ptr->backward = sig_ptr;
215 }
216
217 /* restore signal earlier in list */
218 if (prev_sig_ptr) {
219 prev_sig_ptr->forward = sig_ptr;
220 }
221
222 if (!prev_sig_ptr) trace->firstsig = sig_ptr;
223 if (!next_sig_ptr) trace->lastsig = sig_ptr;
224
225 /* if the signal is the first screen signal, change it */
226 if ( next_sig_ptr && ( next_sig_ptr == trace->dispsig )) {
227 trace->dispsig = sig_ptr;
228 }
229 /* if no display sig, but is regular first sig, make the display sig */
230 if ( trace->firstsig && !trace->dispsig) {
231 trace->dispsig = trace->firstsig;
232 }
233 }
234
sig_replicate(Trace_t * trace,Signal_t * sig_ptr)235 Signal_t *sig_replicate (
236 Trace_t *trace,
237 Signal_t *sig_ptr) /* Signal to remove */
238 /* Makes a duplicate copy of the signal */
239 {
240 Signal_t *new_sig_ptr;
241
242 if (DTPRINT_ENTRY) printf ("In sig_replicate - trace=%p\n",trace);
243
244 /* Create new structure */
245 new_sig_ptr = XtNew (Signal_t);
246
247 /* Copy data */
248 memcpy (new_sig_ptr, sig_ptr, sizeof (Signal_t));
249
250 /* Erase new links */
251 new_sig_ptr->forward = NULL;
252 new_sig_ptr->backward = NULL;
253 if (sig_ptr->copyof)
254 new_sig_ptr->copyof = sig_ptr->copyof;
255 else new_sig_ptr->copyof = sig_ptr;
256 new_sig_ptr->file_copy = FALSE;
257
258 return (new_sig_ptr);
259 }
260
261 /* Returns basename of signal */
sig_basename(const Trace_t * trace,const Signal_t * sig_ptr)262 char *sig_basename (
263 const Trace_t *trace,
264 const Signal_t *sig_ptr)
265 {
266 char *basename;
267 /* First is the basename with hierarchy and bus bits stripped */
268 basename = strrchr ((sig_ptr->signame_buspos ?
269 sig_ptr->signame_buspos : sig_ptr->signame),
270 trace->dfile.hierarchy_separator);
271 if (!basename || basename[0]=='\0') basename = sig_ptr->signame;
272 else basename++;
273 return (basename);
274 }
275
276 /* Returns Signal or NULL if not found, starting at specified signal */
sig_find_signame_start(Signal_t * start_sig_ptr,const char * signame)277 static Signal_t* sig_find_signame_start (
278 Signal_t* start_sig_ptr,
279 const char* signame)
280 {
281 Signal_t* sig_ptr;
282 for (sig_ptr = start_sig_ptr; sig_ptr; sig_ptr = sig_ptr->forward) {
283 if (!strcmp (sig_ptr->signame, signame)) return (sig_ptr);
284 }
285 return (NULL);
286 }
287
288 /* Returns Signal or NULL if not found, starting at specified signal
289 going backwards */
sig_find_signame_start_backward(Signal_t * start_sig_ptr,const char * signame)290 static Signal_t* sig_find_signame_start_backward (
291 Signal_t* start_sig_ptr,
292 const char* signame)
293 {
294 Signal_t* sig_ptr;
295 for (sig_ptr = start_sig_ptr; sig_ptr; sig_ptr = sig_ptr->backward) {
296 if (!strcmp (sig_ptr->signame, signame)) return (sig_ptr);
297 }
298 return (NULL);
299 }
300
301 /* Returns Signal or NULL if not found */
sig_find_signame(const Trace_t * trace,const char * signame)302 Signal_t* sig_find_signame (
303 const Trace_t* trace,
304 const char* signame)
305 {
306 return sig_find_signame_start(trace->firstsig, signame);
307 }
308
309 /* Returns Signal or NULL if not found */
sig_wildmat_signame(const Trace_t * trace,const char * signame)310 Signal_t *sig_wildmat_signame (
311 const Trace_t *trace,
312 const char *signame)
313 {
314 Signal_t *sig_ptr;
315
316 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
317 if (wildmat (sig_ptr->signame, signame)) {
318 return (sig_ptr);
319 }
320 }
321 return (NULL);
322 }
323
sig_wildmat_clear(void)324 void sig_wildmat_clear (void)
325 {
326 SignalList_t *siglst_ptr;
327
328 /* Erase existing selections */
329 while (global->select_head) {
330 siglst_ptr = global->select_head;
331 global->select_head = global->select_head->forward;
332 DFree (siglst_ptr);
333 }
334
335 }
336
sig_wildmat_add(Trace_t * trace,Signal_t * sig_ptr)337 void sig_wildmat_add (Trace_t *trace, Signal_t *sig_ptr)
338 {
339 SignalList_t *siglst_ptr;
340
341 /* printf ("Selected: %s\n", sig_ptr->signame); */
342 siglst_ptr = XtNew (SignalList_t);
343 siglst_ptr->trace = trace;
344 siglst_ptr->signal = sig_ptr;
345 siglst_ptr->forward = global->select_head;
346 global->select_head = siglst_ptr;
347 }
348
sig_wildmat_select(Trace_t * trace,const char * pattern)349 void sig_wildmat_select (
350 /* Create list of selected signals */
351 Trace_t *trace, /* NULL= do all traces */
352 const char *pattern)
353 {
354 Signal_t *sig_ptr;
355 Boolean_t trace_list;
356
357 trace_list = (trace == NULL);
358
359 sig_wildmat_clear();
360
361 /*printf ("Pattern: %s\n", pattern);*/
362 if (trace_list) trace = global->deleted_trace_head;
363 for (; trace; trace = (trace_list ? trace->next_trace : NULL)) {
364 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
365 if (wildmat (sig_ptr->signame, pattern)) {
366 /*printf (" Selected: %s\n", sig_ptr->signame);*/
367 sig_wildmat_add (trace, sig_ptr);
368 }
369 }
370 }
371 }
372
sig_wildmat_select_color(Trace_t * trace,int color)373 void sig_wildmat_select_color (
374 /* Create list of signals that are not highlighed */
375 Trace_t *trace,
376 int color)
377 {
378 Signal_t *sig_ptr;
379
380 sig_wildmat_clear();
381
382 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
383 if (sig_ptr->color == color) {
384 sig_wildmat_add (trace, sig_ptr);
385 }
386 }
387 }
388
sig_move(Trace_t * old_trace,Signal_t * sig_ptr,Trace_t * new_trace,Signal_t * after_sig_ptr)389 void sig_move (
390 Trace_t *old_trace,
391 Signal_t *sig_ptr, /* Signal to move */
392 Trace_t *new_trace,
393 Signal_t *after_sig_ptr) /* Signal to place after or ADD_LAST */
394 {
395
396 if (sig_ptr) {
397 sig_remove_from_queue (old_trace, sig_ptr);
398 sig_ptr->deleted = FALSE;
399 sig_add_to_queue (new_trace, sig_ptr, after_sig_ptr);
400 }
401
402 #if 0
403 printf ("Adding %s\n", sig_ptr->signame);
404
405 printf ("Post\n");
406 debug_integrity_check_cb (NULL, NULL, NULL);
407 printf ("Done\n");
408 #endif
409 }
410
sig_delete(Trace_t * trace,Signal_t * sig_ptr,Boolean_t preserve,Signal_t * after_sig_ptr)411 static void sig_delete (
412 Trace_t *trace,
413 Signal_t *sig_ptr, /* Signal to remove */
414 Boolean_t preserve, /* TRUE if should preserve deletion on rereading */
415 Signal_t *after_sig_ptr) /* Signal to place after or ADD_LAST */
416 /* Delete the given signal */
417 {
418 if (sig_ptr) {
419 sig_move (trace, sig_ptr, global->deleted_trace_head, after_sig_ptr);
420 sig_ptr->deleted = TRUE;
421 sig_ptr->deleted_preserve = preserve;
422 }
423 }
424
sig_copy(Trace_t * old_trace,Signal_t * sig_ptr,Trace_t * new_trace,Signal_t * after_sig_ptr)425 void sig_copy (
426 Trace_t *old_trace,
427 Signal_t *sig_ptr, /* Signal to move */
428 Trace_t *new_trace,
429 Signal_t *after_sig_ptr) /* Signal to place after or ADD_LAST */
430 {
431 Signal_t *new_sig_ptr;
432
433 if (sig_ptr) {
434 if (sig_ptr->deleted) {
435 sig_move (old_trace, sig_ptr, new_trace, after_sig_ptr);
436 }
437 else {
438 new_sig_ptr = sig_replicate (old_trace, sig_ptr);
439 sig_ptr->deleted = FALSE;
440 sig_add_to_queue (new_trace, new_sig_ptr, after_sig_ptr);
441 }
442 }
443 }
444
sig_update_search()445 void sig_update_search ()
446 {
447 Trace_t *trace;
448 Signal_t *sig_ptr;
449 register int i;
450
451 if (DTPRINT_ENTRY) printf ("In sig_update_search\n");
452
453 /* Search every trace for the signals, including deleted */
454 for (trace = global->deleted_trace_head; trace; trace = trace->next_trace) {
455 /* See what signals match the search and highlight as appropriate */
456 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
457 if (sig_ptr->color && sig_ptr->search) {
458 sig_ptr->color = sig_ptr->search = 0;
459 }
460 for (i=0; i<MAX_SRCH; i++) {
461 if (!sig_ptr->color &&
462 global->sig_srch[i].color &&
463 wildmat (sig_ptr->signame, global->sig_srch[i].string)) {
464 sig_ptr->search = i+1;
465 sig_ptr->color = global->sig_srch[i].color;
466 }
467 }
468 }
469 }
470 }
471
472 #if 0 /* Unused */
473 static Boolean_t sig_is_same (
474 const Signal_t *siga_ptr,
475 const Signal_t *sigb_ptr)
476 {
477 Value_t *captr;
478 Value_t *cbptr;
479
480 printf ("Check %s %s\n", siga_ptr->signame, sigb_ptr->signame);
481 /* Is there a transition? */
482 for (captr = siga_ptr->bptr,
483 cbptr = sigb_ptr->bptr;
484 CPTR_TIME(captr) != EOT
485 && CPTR_TIME(cbptr) != EOT;
486 captr = CPTR_NEXT(captr),
487 cbptr = CPTR_NEXT(cbptr)) {
488 if (CPTR_TIME(cbptr) != CPTR_TIME(captr)
489 || !val_equal (captr, cbptr)) {
490 return (FALSE);
491 }
492 }
493
494 if (CPTR_TIME(cbptr) != CPTR_TIME(captr)) return (FALSE);
495 return (TRUE);
496 }
497
498 static void sig_count (
499 const Trace_t *trace)
500 {
501 Signal_t *sig_ptr;
502 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
503 Value_t *cptr;
504 int cnt = 0;
505 for (cptr = sig_ptr->bptr ; CPTR_TIME(cptr) != EOT; cptr = CPTR_NEXT(cptr)) {
506 cnt ++;
507 }
508 }
509 }
510 #endif
511
sig_is_constant(const Trace_t * trace,const Signal_t * sig_ptr,Boolean_t ignorexz)512 static Boolean_t sig_is_constant (
513 const Trace_t *trace,
514 const Signal_t *sig_ptr,
515 Boolean_t ignorexz) /* TRUE = ignore xz */
516 {
517 Boolean_t changes;
518 Value_t *cptr;
519 Value_t old_value;
520 Boolean_t old_got_value;
521
522 /* Is there a transition? */
523 changes=FALSE;
524 old_got_value = FALSE;
525 if (!sig_ptr || !sig_ptr->bptr) abort();
526 for (cptr = sig_ptr->bptr ; CPTR_TIME(cptr) != EOT; cptr = CPTR_NEXT(cptr)) {
527 if (CPTR_TIME(cptr) == trace->end_time) {
528 break;
529 }
530
531 if (ignorexz & ((cptr->siglw.stbits.state == STATE_U)
532 | (cptr->siglw.stbits.state == STATE_Z))) {
533 continue;
534 }
535
536 if (!old_got_value) {
537 val_copy (&old_value, cptr);
538 old_got_value = TRUE;
539 continue;
540 }
541
542 if (!val_equal (cptr, &old_value)) {
543 changes = TRUE;
544 break;
545 }
546 }
547 return (!changes);
548 }
549
sig_print_names(Trace_t * trace)550 void sig_print_names (
551 Trace_t *trace)
552 {
553 Signal_t *sig_ptr, *back_sig_ptr;
554
555 if (DTPRINT_ENTRY) printf ("In print_sig_names\n");
556
557 printf (" Number of signals = %d\n", trace->numsig);
558
559 /* loop thru each signal */
560 back_sig_ptr = NULL;
561 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
562 printf (" Sig '%s' ty=%d index=%d-%d, btyp=%x bpos=%d bcode=%d bits=%d copy=%s\n",
563 sig_ptr->signame, sig_ptr->type,
564 sig_ptr->msb_index ,sig_ptr->lsb_index,
565 sig_ptr->file_type.flags, sig_ptr->file_pos, sig_ptr->file_code, sig_ptr->bits,
566 (sig_ptr->copyof?"Y":"N")
567 );
568 if (sig_ptr->backward != back_sig_ptr) {
569 printf (" %%E, Backward link is to '%p' not '%p'\n", sig_ptr->backward, back_sig_ptr);
570 }
571 back_sig_ptr = sig_ptr;
572 }
573
574 /* Don't do a integrity check here, as sometimes all links aren't ready! */
575 /* signalstates_dump (trace); */
576 }
577
578 /****************************** CONFIG FUNCTIONS ******************************/
579
580
sig_highlight_selected(int color)581 void sig_highlight_selected (
582 int color)
583 {
584 Signal_t *sig_ptr;
585 SignalList_t *siglst_ptr;
586
587 if (DTPRINT_ENTRY) printf ("In sig_highlight_selected\n");
588
589 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
590 sig_ptr = siglst_ptr->signal;
591 /* Change the color */
592 sig_ptr->color = color;
593 sig_ptr->search = 0;
594 if (sig_ptr->copyof) {
595 sig_ptr->copyof->color = color;
596 sig_ptr->copyof->search = 0;
597 }
598 }
599
600 draw_all_needed ();
601 }
602
sig_radix_selected(Radix_t * radix_ptr)603 void sig_radix_selected (
604 Radix_t *radix_ptr)
605 {
606 Signal_t *sig_ptr;
607 SignalList_t *siglst_ptr;
608
609 if (DTPRINT_ENTRY) printf ("In sig_radix_selected\n");
610
611 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
612 sig_ptr = siglst_ptr->signal;
613 /* Change the color */
614 sig_ptr->radix = radix_ptr;
615 }
616
617 draw_all_needed ();
618 }
619
sig_waveform_selected(Waveform_t waveform)620 void sig_waveform_selected (
621 Waveform_t waveform)
622 {
623 Signal_t *sig_ptr;
624 SignalList_t *siglst_ptr;
625
626 if (DTPRINT_ENTRY) printf ("In sig_waveform_selected\n");
627
628 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
629 sig_ptr = siglst_ptr->signal;
630 sig_ptr->waveform = waveform;
631 }
632
633 draw_all_needed ();
634 }
635
sig_move_selected(Trace_t * new_trace,const char * after_pattern)636 void sig_move_selected (
637 /* also used for adding deleted signals */
638 Trace_t *new_trace,
639 const char *after_pattern)
640 {
641 Trace_t *old_trace;
642 Signal_t *sig_ptr, *after_sig_ptr;
643 SignalList_t *siglst_ptr;
644
645 if (DTPRINT_ENTRY) printf ("In sig_move_selected aft='%s'\n", after_pattern);
646
647 after_sig_ptr = sig_wildmat_signame (new_trace, after_pattern);
648 if (! after_sig_ptr) after_sig_ptr = ADD_LAST;
649
650 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
651 sig_ptr = siglst_ptr->signal;
652 old_trace = siglst_ptr->trace;
653 /* Move it */
654 sig_move (old_trace, sig_ptr, new_trace, after_sig_ptr);
655 }
656
657 draw_needupd_sig_start ();
658 draw_all_needed ();
659 }
660
661
sig_rename_selected(const char * new_name)662 void sig_rename_selected (
663 /* also used for adding deleted signals */
664 const char *new_name)
665 {
666 Signal_t *sig_ptr;
667 SignalList_t *siglst_ptr;
668
669 if (DTPRINT_ENTRY) printf ("In sig_rename_selected new='%s'\n", new_name);
670
671 siglst_ptr = global->select_head;
672 if (siglst_ptr) {
673 sig_ptr = siglst_ptr->signal;
674 strcpy (sig_ptr->signame, new_name);
675 sig_ptr->xsigname = XmStringCreateSimple (sig_ptr->signame);
676 }
677
678 draw_needupd_sig_start ();
679 draw_all_needed ();
680 }
681
682
sig_copy_selected(Trace_t * new_trace,const char * after_pattern)683 void sig_copy_selected (
684 Trace_t *new_trace,
685 const char *after_pattern)
686 {
687 Trace_t *old_trace;
688 Signal_t *sig_ptr, *after_sig_ptr;
689 SignalList_t *siglst_ptr;
690
691 if (DTPRINT_ENTRY) printf ("In sig_copy_pattern - aft='%s'\n", after_pattern);
692
693 after_sig_ptr = sig_wildmat_signame (new_trace, after_pattern);
694 if (! after_sig_ptr) after_sig_ptr = ADD_LAST;
695
696 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
697 sig_ptr = siglst_ptr->signal;
698 old_trace = siglst_ptr->trace;
699 sig_copy (old_trace, sig_ptr, new_trace, after_sig_ptr);
700 }
701
702 draw_needupd_sig_start ();
703 draw_all_needed ();
704 }
705
706
sig_delete_selected(Boolean_t constant_flag,Boolean_t ignorexz)707 void sig_delete_selected (
708 Boolean_t constant_flag, /* FALSE = only delete constants */
709 Boolean_t ignorexz) /* TRUE = if deleting constants, ignore xz */
710 {
711 Trace_t *trace;
712 Signal_t *sig_ptr;
713 SignalList_t *siglst_ptr;
714
715
716 if (DTPRINT_ENTRY) printf ("In sig_delete_selected %d %d\n", constant_flag, ignorexz);
717
718 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
719 sig_ptr = siglst_ptr->signal;
720 trace = siglst_ptr->trace;
721 if (!sig_ptr || !sig_ptr->bptr) abort();
722 if (sig_ptr==NULL) abort();
723 if ( constant_flag || sig_is_constant (trace, sig_ptr, ignorexz)) {
724 sig_delete (trace, sig_ptr, constant_flag, ADD_LAST );
725 }
726 }
727
728 draw_needupd_sig_start ();
729 draw_all_needed ();
730 }
731
732
sig_note(Signal_t * sig_ptr,const char * note)733 void sig_note (
734 Signal_t* sig_ptr,
735 const char *note)
736 {
737 sig_ptr->note = strdup (note);
738 /*draw_all_needed (); not visible, so don't bother*/
739 }
740
sig_note_selected(const char * note)741 void sig_note_selected (
742 const char *note)
743 {
744 Signal_t *sig_ptr;
745 SignalList_t *siglst_ptr;
746
747 if (DTPRINT_ENTRY) printf ("In sig_note_selected\n");
748
749 for (siglst_ptr = global->select_head; siglst_ptr; siglst_ptr = siglst_ptr->forward) {
750 sig_ptr = siglst_ptr->signal;
751 sig_note (sig_ptr,note);
752 }
753 /*draw_all_needed (); not visible, so don't bother*/
754 }
755
756
sig_goto_pattern(Trace_t * trace,const char * pattern)757 void sig_goto_pattern (
758 Trace_t *trace,
759 const char *pattern)
760 {
761 Signal_t *sig_ptr;
762 uint_t numprt;
763 int inc;
764 Boolean_t on_screen, found;
765
766 if (DTPRINT_ENTRY) printf ("In sig_goto_pattern - trace=%p pat='%s'\n",trace, pattern);
767
768 for (trace = global->trace_head; trace; trace = trace->next_trace) {
769 /* Is this signal already on the screen? */
770 on_screen = FALSE;
771 for (sig_ptr = trace->dispsig, numprt = 0; sig_ptr && numprt<trace->numsigvis;
772 sig_ptr = sig_ptr->forward, numprt++) {
773 if (wildmat (sig_ptr->signame, pattern)) {
774 on_screen = TRUE;
775 break;
776 }
777 }
778
779 if (!on_screen) {
780 /* Align starting signal to search position */
781 found = FALSE;
782 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
783 if (wildmat (sig_ptr->signame, pattern)) {
784 trace->dispsig = sig_ptr;
785 found = TRUE;
786 break;
787 }
788 }
789
790 if (found) {
791 /* Rescroll found signal to the center of the screen */
792 inc = (-trace->numsigvis) / 2;
793 while ( (inc < 0) && trace->dispsig && trace->dispsig->backward ) {
794 trace->dispsig = trace->dispsig->backward;
795 inc++;
796 }
797 }
798 vscroll_new (trace,0); /* Realign time */
799 }
800 }
801 draw_all_needed ();
802 }
803
804
805 /****************************** EXAMINE ******************************/
806
sig_examine_string(const Trace_t * trace,const Signal_t * sig_ptr)807 char *sig_examine_string (
808 /* Return string with examine information in it */
809 const Trace_t *trace,
810 const Signal_t *sig_ptr)
811 {
812 static char strg[2000];
813 char strg2[2000];
814
815 if (DTPRINT_ENTRY) printf ("val_examine_popup_sig_string\n");
816
817 strcpy (strg, sig_ptr->signame);
818
819 sprintf (strg2, "\nRadix: %s\n", sig_ptr->radix->name);
820 strcat (strg, strg2);
821 if (sig_ptr->note) {
822 strcat (strg, sig_ptr->note);
823 strcat (strg, "\n");
824 }
825
826 /* Debugging information */
827 if (DTDEBUG) {
828 if (sig_ptr->copyof) {
829 sprintf (strg2, "\nCopy-of %s\n",
830 sig_ptr->copyof->signame);
831 strcat (strg, strg2);
832 }
833 sprintf (strg2, "\nType %d Blocks %ld\n",
834 sig_ptr->type, sig_ptr->blocks);
835 strcat (strg, strg2);
836 sprintf (strg2, "Bits %d Index %d - %d\n",
837 sig_ptr->bits, sig_ptr->msb_index, sig_ptr->lsb_index);
838 strcat (strg, strg2);
839 sprintf (strg2, "File_type %x File_Pos %d-%d Mask %08x\n",
840 sig_ptr->file_type.flags, sig_ptr->file_pos, sig_ptr->file_end_pos, sig_ptr->pos_mask);
841 strcat (strg, strg2);
842 sprintf (strg2, "Value_mask %08x %08x %08x %08x\n",
843 sig_ptr->value_mask[3], sig_ptr->value_mask[2], sig_ptr->value_mask[1], sig_ptr->value_mask[0]);
844 strcat (strg, strg2);
845 }
846 return (strg);
847 }
848
849 /****************************** MENU OPTIONS ******************************/
850
sig_add_cb(Widget w)851 void sig_add_cb (
852 Widget w)
853 {
854 Trace_t *trace = widget_to_trace(w);
855 Signal_t *sig_ptr;
856 Widget list_wid;
857
858 if (DTPRINT_ENTRY) printf ("In sig_add_cb - trace=%p\n",trace);
859
860 if (!trace->signal.add) {
861 XtSetArg (arglist[0], XmNdefaultPosition, TRUE);
862 XtSetArg (arglist[1], XmNwidth, 200);
863 XtSetArg (arglist[2], XmNheight, 150);
864 XtSetArg (arglist[3], XmNdialogTitle, XmStringCreateSimple ("Signal Select"));
865 XtSetArg (arglist[4], XmNlistVisibleItemCount, 5);
866 XtSetArg (arglist[5], XmNlistLabelString, XmStringCreateSimple ("Select Signal than Location"));
867 trace->signal.add = XmCreateSelectionDialog (trace->work,"",arglist,6);
868 /* DAddCallback (trace->signal.add, XmNsingleCallback, sig_add_sel_cb, trace); */
869 DAddCallback (trace->signal.add, XmNokCallback, sig_add_sel_cb, trace);
870 DAddCallback (trace->signal.add, XmNapplyCallback, sig_add_sel_cb, trace);
871 DAddCallback (trace->signal.add, XmNcancelCallback, sig_cancel_cb, trace);
872 XtUnmanageChild ( XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_HELP_BUTTON));
873 XtUnmanageChild ( XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_APPLY_BUTTON));
874 XtUnmanageChild ( XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_PROMPT_LABEL));
875 XtUnmanageChild ( XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_VALUE_TEXT));
876 }
877 else {
878 XtUnmanageChild (trace->signal.add);
879 }
880
881 /* loop thru signals on deleted queue and add to list */
882 list_wid = XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_LIST);
883 XmListDeleteAllItems (list_wid);
884 for (sig_ptr = global->deleted_trace_head->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
885 XmListAddItem (list_wid, sig_ptr->xsigname, 0);
886 }
887
888 /* if there are signals deleted make OK button active */
889 XtSetArg (arglist[0], XmNsensitive, (global->deleted_trace_head->firstsig != NULL)?TRUE:FALSE);
890 XtSetValues (XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_OK_BUTTON), arglist, 1);
891
892 /* manage the popup on the screen */
893 DManageChild (trace->signal.add, trace, MC_NOKEYS);
894 }
895
sig_add_sel_cb(Widget w,Trace_t * trace,XmSelectionBoxCallbackStruct * cb)896 void sig_add_sel_cb (
897 Widget w,
898 Trace_t *trace,
899 XmSelectionBoxCallbackStruct *cb)
900 {
901 Signal_t *sig_ptr;
902
903 if (DTPRINT_ENTRY) printf ("In sig_add_sel_cb - trace=%p\n",trace);
904
905 if ( global->deleted_trace_head->firstsig == NULL ) return;
906
907 /* save the deleted signal selected number */
908 for (sig_ptr = global->deleted_trace_head->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
909 if (XmStringCompare (cb->value, sig_ptr->xsigname)) break;
910 }
911
912 /* remove any previous events */
913 remove_all_events (trace);
914
915 if (sig_ptr && XmStringCompare (cb->value, sig_ptr->xsigname)) {
916 global->selected_sig = sig_ptr;
917 /* process all subsequent button presses as signal adds */
918 set_cursor (DC_SIG_ADD);
919 add_event (ButtonPressMask, sig_add_ev);
920
921 /* unmanage the popup on the screen - we'll pop it back later */
922 XtUnmanageChild (trace->signal.add);
923 }
924 else {
925 global->selected_sig = NULL;
926 }
927 }
928
sig_cancel_cb(Widget w)929 void sig_cancel_cb (
930 Widget w)
931 {
932 Widget list_wid;
933 Trace_t *trace = widget_to_trace(w);
934 if (DTPRINT_ENTRY) printf ("In sig_cancel_cb - trace=%p\n",trace);
935
936 /* remove any previous events */
937 remove_all_events (trace);
938
939 /* unmanage the popup on the screen */
940 XtUnmanageChild (trace->signal.add);
941
942 /* cleanup list in case the trace gets reloaded */
943 list_wid = XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_LIST);
944 XmListDeleteAllItems (list_wid);
945 }
946
sig_mov_cb(Widget w)947 void sig_mov_cb (
948 Widget w)
949 {
950 Trace_t *trace = widget_to_trace(w);
951 if (DTPRINT_ENTRY) printf ("In sig_mov_cb - trace=%p\n",trace);
952
953 /* guarantee next button press selects a signal to be moved */
954 global->selected_sig = NULL;
955
956 /* process all subsequent button presses as signal moves */
957 remove_all_events (trace);
958 add_event (ButtonPressMask, sig_move_ev);
959 set_cursor (DC_SIG_MOVE_1);
960 }
961
sig_copy_cb(Widget w)962 void sig_copy_cb (
963 Widget w)
964 {
965 Trace_t *trace = widget_to_trace(w);
966 if (DTPRINT_ENTRY) printf ("In sig_copy_cb - trace=%p\n",trace);
967
968 /* guarantee next button press selects a signal to be moved */
969 global->selected_sig = NULL;
970
971 /* process all subsequent button presses as signal moves */
972 remove_all_events (trace);
973 add_event (ButtonPressMask, sig_copy_ev);
974 set_cursor (DC_SIG_COPY_1);
975 }
976
sig_del_cb(Widget w)977 void sig_del_cb (
978 Widget w)
979 {
980 Trace_t *trace = widget_to_trace(w);
981 if (DTPRINT_ENTRY) printf ("In sig_del_cb - trace=%p\n",trace);
982
983 /* process all subsequent button presses as signal deletions */
984 remove_all_events (trace);
985 set_cursor (DC_SIG_DELETE);
986 add_event (ButtonPressMask, sig_delete_ev);
987 }
988
sig_radix_cb(Widget w)989 void sig_radix_cb (
990 Widget w)
991 {
992 Trace_t *trace = widget_to_trace(w);
993 int radixnum = submenu_to_color (trace, w, 0, trace->menu.sig_radix_pds);
994 if (DTPRINT_ENTRY) printf ("In sig_radix_cb - trace=%p radixnum=%d\n",trace, radixnum);
995
996 /* Grab color number from the menu button pointer */
997 global->selected_radix = global->radixs[radixnum];
998
999 /* process all subsequent button presses as signal deletions */
1000 remove_all_events (trace);
1001 set_cursor (DC_SIG_RADIX);
1002 add_event (ButtonPressMask, sig_radix_ev);
1003 }
1004
sig_waveform_cb(Widget w)1005 void sig_waveform_cb (
1006 Widget w)
1007 {
1008 Trace_t *trace = widget_to_trace(w);
1009 int subnum = submenu_to_color (trace, w, 0, trace->menu.sig_waveform_pds);
1010
1011 if (DTPRINT_ENTRY) printf ("In sig_waveform_digital_cb - trace=%p sub=%d\n",trace, subnum);
1012 global->selected_waveform = (Waveform_t)subnum;
1013
1014 /* process all subsequent button presses as signal deletions */
1015 remove_all_events (trace);
1016 set_cursor (DC_SIG_RADIX);
1017 add_event (ButtonPressMask, sig_waveform_ev);
1018 }
1019
sig_highlight_internal(Widget w,ColorNum_t overrideColor)1020 static void sig_highlight_internal (
1021 Widget w,
1022 ColorNum_t overrideColor)
1023 {
1024 Trace_t *trace = widget_to_trace(w);
1025 if (DTPRINT_ENTRY) printf ("In sig_highlight_cb - trace=%p\n",trace);
1026
1027 /* Grab color number from the menu button pointer */
1028 global->highlight_color = submenu_to_color (trace, w, overrideColor, trace->menu.sig_highlight_pds);
1029
1030 /* process all subsequent button presses as signal deletions */
1031 remove_all_events (trace);
1032 set_cursor (DC_SIG_HIGHLIGHT);
1033 add_event (ButtonPressMask, sig_highlight_ev);
1034 }
1035
sig_highlight_cb(Widget w)1036 void sig_highlight_cb (
1037 Widget w)
1038 {
1039 sig_highlight_internal(w,0);
1040 }
1041
sig_highlight_current_cb(Widget w)1042 void sig_highlight_current_cb (
1043 Widget w)
1044 {
1045 sig_highlight_internal(w,COLOR_CURRENT);
1046 }
1047
sig_highlight_next_cb(Widget w)1048 void sig_highlight_next_cb (
1049 Widget w)
1050 {
1051 sig_highlight_internal(w,COLOR_NEXT);
1052 }
1053
sig_highlight_clear_cb(Widget w)1054 void sig_highlight_clear_cb (
1055 Widget w)
1056 {
1057 Trace_t *trace = widget_to_trace(w);
1058 if (DTPRINT_ENTRY) printf ("In sig_highlight_clear_cb - trace=%p\n",trace);
1059
1060 sig_wildmat_select (NULL, "*");
1061 sig_highlight_selected (0);
1062 }
1063
sig_highlight_keep_cb(Widget w)1064 void sig_highlight_keep_cb (
1065 Widget w)
1066 {
1067 Trace_t *trace = widget_to_trace(w);
1068 if (DTPRINT_ENTRY) printf ("In sig_highlight_keep_cb - trace=%p\n",trace);
1069
1070 sig_wildmat_select_color (trace, 0);
1071 sig_delete_selected (TRUE, TRUE);
1072 }
1073
sig_note_cb(Widget w)1074 void sig_note_cb (
1075 Widget w)
1076 {
1077 Trace_t *trace = widget_to_trace(w);
1078 if (DTPRINT_ENTRY) printf ("In sig_note_cb %p\n",trace);
1079
1080 /* process all subsequent button presses as signal deletions */
1081 remove_all_events (trace);
1082 set_cursor (DC_SIG_NOTE);
1083 add_event (ButtonPressMask, sig_note_ev);
1084 }
1085
sig_search_cb(Widget w)1086 void sig_search_cb (
1087 Widget w)
1088 {
1089 Trace_t *trace = widget_to_trace(w);
1090 int i;
1091 Widget above;
1092
1093 if (DTPRINT_ENTRY) printf ("In sig_search_cb - trace=%p\n",trace);
1094
1095 if (!trace->signal.dialog) {
1096 XtSetArg (arglist[0], XmNdefaultPosition, TRUE);
1097 XtSetArg (arglist[1], XmNdialogTitle, XmStringCreateSimple ("Signal Search Requester") );
1098 XtSetArg (arglist[2], XmNverticalSpacing, 0);
1099 XtSetArg (arglist[3], XmNhorizontalSpacing, 10);
1100 trace->signal.dialog = XmCreateFormDialog (trace->work,"search",arglist,4);
1101
1102 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Color"));
1103 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_FORM );
1104 XtSetArg (arglist[2], XmNtopAttachment, XmATTACH_FORM );
1105 XtSetArg (arglist[3], XmNtopOffset, 10);
1106 trace->signal.label1 = XmCreateLabel (trace->signal.dialog,"label1",arglist,4);
1107 DManageChild (trace->signal.label1, trace, MC_NOKEYS);
1108
1109 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Sig"));
1110 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_FORM );
1111 XtSetArg (arglist[2], XmNtopAttachment, XmATTACH_WIDGET );
1112 XtSetArg (arglist[3], XmNtopWidget, dmanage_last);
1113 trace->signal.label4 = XmCreateLabel (trace->signal.dialog,"label4",arglist,4);
1114 DManageChild (trace->signal.label4, trace, MC_NOKEYS);
1115
1116 XtSetArg (arglist[0], XmNlabelString,
1117 XmStringCreateSimple ("Search value, *? are wildcards" ));
1118 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1119 XtSetArg (arglist[2], XmNleftWidget, trace->signal.label4 );
1120 XtSetArg (arglist[3], XmNtopAttachment, XmATTACH_WIDGET );
1121 XtSetArg (arglist[4], XmNtopWidget, trace->signal.label1);
1122 XtSetArg (arglist[5], XmNverticalSpacing, 0);
1123 trace->signal.label3 = XmCreateLabel (trace->signal.dialog,"label3",arglist,6);
1124 DManageChild (trace->signal.label3, trace, MC_NOKEYS);
1125
1126 above = trace->signal.label3;
1127
1128 for (i=0; i<MAX_SRCH; i++) {
1129 /* enable button */
1130 XtSetArg (arglist[0], XmNleftAttachment, XmATTACH_FORM );
1131 XtSetArg (arglist[1], XmNtopAttachment, XmATTACH_WIDGET );
1132 XtSetArg (arglist[2], XmNtopWidget, above);
1133 XtSetArg (arglist[3], XmNselectColor, trace->xcolornums[i+1]);
1134 XtSetArg (arglist[4], XmNlabelString, XmStringCreateSimple (" ")); /* Else openmotif makes small button*/
1135 trace->signal.enable[i] = XmCreateToggleButton (trace->signal.dialog,"togglen",arglist,5);
1136 DManageChild (trace->signal.enable[i], trace, MC_NOKEYS);
1137
1138 /* create the file name text widget */
1139 XtSetArg (arglist[0], XmNrows, 1);
1140 XtSetArg (arglist[1], XmNcolumns, 30);
1141 XtSetArg (arglist[2], XmNleftAttachment, XmATTACH_WIDGET );
1142 XtSetArg (arglist[3], XmNleftWidget, trace->signal.enable[i]);
1143 XtSetArg (arglist[4], XmNtopAttachment, XmATTACH_WIDGET );
1144 XtSetArg (arglist[5], XmNtopWidget, above);
1145 XtSetArg (arglist[6], XmNresizeHeight, FALSE);
1146 XtSetArg (arglist[7], XmNeditMode, XmSINGLE_LINE_EDIT);
1147 XtSetArg (arglist[8], XmNrightAttachment, XmATTACH_FORM );
1148 trace->signal.text[i] = XmCreateText (trace->signal.dialog,"textn",arglist,9);
1149 DAddCallback (trace->signal.text[i], XmNactivateCallback, sig_search_ok_cb, trace);
1150 DManageChild (trace->signal.text[i], trace, MC_NOKEYS);
1151
1152 above = trace->signal.text[i];
1153 }
1154
1155 /* Ok/apply/cancel */
1156 ok_apply_cancel (&trace->signal.okapply, trace->signal.dialog,
1157 dmanage_last,
1158 (XtCallbackProc)sig_search_ok_cb, trace,
1159 (XtCallbackProc)sig_search_apply_cb, trace,
1160 NULL, NULL,
1161 (XtCallbackProc)unmanage_cb, (Trace_t*)trace->signal.dialog);
1162 }
1163
1164 /* Copy settings to local area to allow cancel to work */
1165 for (i=0; i<MAX_SRCH; i++) {
1166 /* Update with current search enables */
1167 XtSetArg (arglist[0], XmNset, (global->sig_srch[i].color != 0));
1168 XtSetValues (trace->signal.enable[i], arglist, 1);
1169
1170 /* Update with current search values */
1171 XmTextSetString (trace->signal.text[i], global->sig_srch[i].string);
1172 }
1173
1174 /* manage the popup on the screen */
1175 DManageChild (trace->signal.dialog, trace, MC_NOKEYS);
1176 }
1177
sig_search_ok_cb(Widget w,Trace_t * trace,XmSelectionBoxCallbackStruct * cb)1178 void sig_search_ok_cb (
1179 Widget w,
1180 Trace_t *trace,
1181 XmSelectionBoxCallbackStruct *cb)
1182 {
1183 char *strg;
1184 int i;
1185
1186 if (DTPRINT_ENTRY) printf ("In sig_search_ok_cb - trace=%p\n",trace);
1187
1188 for (i=0; i<MAX_SRCH; i++) {
1189 /* Update with current search enables */
1190 if (XmToggleButtonGetState (trace->signal.enable[i]))
1191 global->sig_srch[i].color = i+1;
1192 else global->sig_srch[i].color = 0;
1193
1194 /* Update with current search values */
1195 strg = XmTextGetString (trace->signal.text[i]);
1196 strcpy (global->sig_srch[i].string, strg);
1197 }
1198
1199 XtUnmanageChild (trace->signal.dialog);
1200
1201 draw_needupd_sig_search ();
1202 draw_needupd_sig_start ();
1203 draw_all_needed ();
1204 }
1205
sig_search_apply_cb(Widget w,Trace_t * trace,XmSelectionBoxCallbackStruct * cb)1206 void sig_search_apply_cb (
1207 Widget w,
1208 Trace_t *trace,
1209 XmSelectionBoxCallbackStruct *cb)
1210 {
1211 if (DTPRINT_ENTRY) printf ("In sig_search_apply_cb - trace=%p\n",trace);
1212
1213 sig_search_ok_cb (w,trace,cb);
1214 sig_search_cb (trace->main);
1215 }
1216
1217 /****************************** EVENTS ******************************/
1218
sig_add_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1219 void sig_add_ev (
1220 Widget w,
1221 Trace_t *trace,
1222 XButtonPressedEvent *ev)
1223 {
1224 Signal_t *sig_ptr;
1225
1226 if (DTPRINT_ENTRY) printf ("In sig_add_ev - trace=%p\n",trace);
1227 if (ev->type != ButtonPress || ev->button!=1) return;
1228
1229 /* return if there is no file */
1230 if (!trace->loaded || global->selected_sig==NULL)
1231 return;
1232
1233 /* make sure button has been clicked in in valid location of screen */
1234 sig_ptr = posy_to_signal (trace, ev->y);
1235 /* Null signal is OK */
1236
1237 /* get previous signal */
1238 if (sig_ptr) sig_ptr = sig_ptr->backward;
1239
1240 /* remove signal from list box */
1241 XmListDeleteItem (XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_LIST),
1242 global->selected_sig->xsigname );
1243 if (global->deleted_trace_head->firstsig == NULL) {
1244 XtSetArg (arglist[0], XmNsensitive, FALSE);
1245 XtSetValues (XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_OK_BUTTON), arglist, 1);
1246 }
1247
1248 sig_move (global->deleted_trace_head, global->selected_sig, trace, sig_ptr);
1249
1250 /* remove any previous events */
1251 remove_all_events (trace);
1252
1253 /* pop window back to top of stack */
1254 XtUnmanageChild ( trace->signal.add );
1255 DManageChild ( trace->signal.add , trace, MC_NOKEYS);
1256
1257 draw_needupd_sig_start ();
1258 draw_all_needed ();
1259 }
1260
sig_move_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1261 void sig_move_ev (
1262 Widget w,
1263 Trace_t *trace,
1264 XButtonPressedEvent *ev)
1265 {
1266 Signal_t *sig_ptr;
1267
1268 if (DTPRINT_ENTRY) printf ("In sig_move_ev - trace=%p\n",trace);
1269 if (ev->type != ButtonPress || ev->button!=1) return;
1270
1271 /* return if there is no file */
1272 if ( !trace->loaded )
1273 return;
1274
1275 /* return if there is less than 2 signals to move */
1276 if ( trace->numsig < 2 )
1277 return;
1278
1279 /* make sure button has been clicked in in valid location of screen */
1280 sig_ptr = posy_to_signal (trace, ev->y);
1281 if (!sig_ptr) return;
1282
1283 if ( global->selected_sig == NULL ) {
1284 /* next call will perform the move */
1285 global->selected_sig = sig_ptr;
1286 global->selected_trace = trace;
1287 set_cursor (DC_SIG_MOVE_2);
1288 }
1289 else {
1290 /* get previous signal */
1291 if (sig_ptr) sig_ptr = sig_ptr->backward;
1292
1293 /* if not the same signal perform the move */
1294 if ( sig_ptr != global->selected_sig ) {
1295 sig_move (global->selected_trace, global->selected_sig, trace, sig_ptr);
1296 }
1297
1298 /* guarantee that next button press will select signal */
1299 global->selected_sig = NULL;
1300 set_cursor (DC_SIG_MOVE_1);
1301 }
1302
1303 draw_needupd_sig_start ();
1304 draw_all_needed ();
1305 }
1306
sig_copy_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1307 void sig_copy_ev (
1308 Widget w,
1309 Trace_t *trace,
1310 XButtonPressedEvent *ev)
1311 {
1312 Signal_t *sig_ptr;
1313
1314 if (DTPRINT_ENTRY) printf ("In sig_copy_ev - trace=%p\n",trace);
1315 if (ev->type != ButtonPress || ev->button!=1) return;
1316
1317 /* make sure button has been clicked in in valid location of screen */
1318 sig_ptr = posy_to_signal (trace, ev->y);
1319 if (!sig_ptr) return;
1320
1321 if ( global->selected_sig == NULL ) {
1322 /* next call will perform the copy */
1323 global->selected_sig = sig_ptr;
1324 global->selected_trace = trace;
1325 set_cursor (DC_SIG_COPY_2);
1326 }
1327 else {
1328 /* get previous signal */
1329 if (sig_ptr) sig_ptr = sig_ptr->backward;
1330
1331 /* if not the same signal perform the move */
1332 if ( sig_ptr != global->selected_sig ) {
1333 sig_copy (global->selected_trace, global->selected_sig, trace, sig_ptr);
1334 }
1335
1336 /* guarantee that next button press will select signal */
1337 global->selected_sig = NULL;
1338 set_cursor (DC_SIG_COPY_1);
1339 }
1340
1341 draw_needupd_sig_start ();
1342 draw_all_needed ();
1343 }
1344
sig_delete_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1345 void sig_delete_ev (
1346 Widget w,
1347 Trace_t *trace,
1348 XButtonPressedEvent *ev)
1349 {
1350 Signal_t *sig_ptr;
1351
1352 if (DTPRINT_ENTRY) printf ("In sig_delete_ev - trace=%p\n",trace);
1353 if (ev->type != ButtonPress || ev->button!=1) return;
1354
1355 /* return if there is no file */
1356 if ( !trace->loaded )
1357 return;
1358
1359 /* return if there are no signals to delete */
1360 if ( trace->numsig == 0 )
1361 return;
1362
1363 /* find the signal */
1364 sig_ptr = posy_to_signal (trace, ev->y);
1365 if (!sig_ptr) return;
1366
1367 /* remove the signal from the queue */
1368 sig_delete (trace, sig_ptr, TRUE, ADD_LAST);
1369
1370 /* add signame to list box */
1371 if ( trace->signal.add != NULL ) {
1372 XmListAddItem (XmSelectionBoxGetChild (trace->signal.add, XmDIALOG_LIST),
1373 sig_ptr->xsigname, 0 );
1374 }
1375
1376 draw_needupd_sig_start ();
1377 draw_all_needed ();
1378 }
1379
1380
sig_highlight_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1381 void sig_highlight_ev (
1382 Widget w,
1383 Trace_t *trace,
1384 XButtonPressedEvent *ev)
1385 {
1386 Signal_t *sig_ptr;
1387
1388 if (DTPRINT_ENTRY) printf ("In sig_highlight_ev - trace=%p\n",trace);
1389 if (ev->type != ButtonPress || ev->button!=1) return;
1390
1391 sig_ptr = posy_to_signal (trace, ev->y);
1392 if (!sig_ptr) return;
1393
1394 /* Change the color */
1395 sig_ptr->color = global->highlight_color;
1396 sig_ptr->search = 0;
1397 if (sig_ptr->copyof) {
1398 sig_ptr->copyof->color = global->highlight_color;
1399 sig_ptr->copyof->search = 0;
1400 }
1401
1402 draw_all_needed ();
1403 }
1404
1405
sig_radix_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1406 void sig_radix_ev (
1407 Widget w,
1408 Trace_t *trace,
1409 XButtonPressedEvent *ev)
1410 {
1411 Signal_t *sig_ptr;
1412
1413 if (DTPRINT_ENTRY) printf ("In sig_radix_ev - trace=%p\n",trace);
1414 if (ev->type != ButtonPress || ev->button!=1) return;
1415
1416 sig_ptr = posy_to_signal (trace, ev->y);
1417 if (!sig_ptr) return;
1418
1419 /* Change the radix */
1420 sig_ptr->radix = global->selected_radix;
1421
1422 draw_all_needed ();
1423 }
1424
sig_waveform_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1425 void sig_waveform_ev (
1426 Widget w,
1427 Trace_t *trace,
1428 XButtonPressedEvent *ev)
1429 {
1430 Signal_t *sig_ptr;
1431
1432 if (DTPRINT_ENTRY) printf ("In sig_waveform_ev - trace=%p\n",trace);
1433 if (ev->type != ButtonPress || ev->button!=1) return;
1434
1435 sig_ptr = posy_to_signal (trace, ev->y);
1436 if (!sig_ptr) return;
1437
1438 /* Change the radix */
1439 sig_ptr->waveform = global->selected_waveform;
1440
1441 draw_all_needed ();
1442 }
1443
sig_note_ev(Widget w,Trace_t * trace,XButtonPressedEvent * ev)1444 void sig_note_ev (
1445 Widget w,
1446 Trace_t *trace,
1447 XButtonPressedEvent *ev)
1448 {
1449 Signal_t *sig_ptr;
1450
1451 if (DTPRINT_ENTRY) printf ("In sig_note_ev - trace=%p\n",trace);
1452 if (ev->type != ButtonPress || ev->button!=1) return;
1453
1454 sig_ptr = posy_to_signal (trace, ev->y);
1455 if (!sig_ptr) return;
1456
1457 /* Get the note */
1458 global->selected_sig = sig_ptr;
1459 win_note(trace, "Note for ",sig_ptr->signame, sig_ptr->note, FALSE);
1460 }
1461
1462 /****************************** SELECT OPTIONS ******************************/
1463
sig_select_cb(Widget w)1464 void sig_select_cb (
1465 Widget w)
1466 {
1467 Trace_t *trace = widget_to_trace(w);
1468 if (DTPRINT_ENTRY) printf ("In sig_select_cb - trace=%p\n",trace);
1469
1470 /* return if there is no file */
1471 if (!trace->loaded) return;
1472
1473 if (!trace->select.dialog) {
1474 trace->select.del_strings=NULL;
1475 trace->select.add_strings=NULL;
1476 trace->select.del_signals=NULL;
1477 trace->select.add_signals=NULL;
1478
1479 XtSetArg (arglist[0], XmNdefaultPosition, TRUE);
1480 XtSetArg (arglist[1], XmNdialogTitle, XmStringCreateSimple ("Select Signal Requester") );
1481 XtSetArg (arglist[2], XmNheight, 400);
1482 XtSetArg (arglist[3], XmNverticalSpacing, 5);
1483 XtSetArg (arglist[4], XmNhorizontalSpacing, 10);
1484 XtSetArg (arglist[5], XmNresizable, FALSE);
1485 trace->select.dialog = XmCreateFormDialog (trace->work,"select",arglist,6);
1486
1487 /*** BUTTONS ***/
1488
1489 /* Create OK button */
1490 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple (" OK ") );
1491 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_FORM );
1492 XtSetArg (arglist[2], XmNbottomAttachment, XmATTACH_FORM );
1493 trace->select.okapply.ok = XmCreatePushButton (trace->select.dialog,"ok",arglist,3);
1494 DAddCallback (trace->select.okapply.ok, XmNactivateCallback, sig_sel_ok_cb, trace);
1495 DManageChild (trace->select.okapply.ok, trace, MC_NOKEYS);
1496
1497 /* Create apply button */
1498 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Apply") );
1499 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_POSITION );
1500 XtSetArg (arglist[2], XmNleftPosition, 45);
1501 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_FORM );
1502 trace->select.okapply.apply = XmCreatePushButton (trace->select.dialog,"apply",arglist,4);
1503 DAddCallback (trace->select.okapply.apply, XmNactivateCallback, sig_sel_apply_cb, trace);
1504 DManageChild (trace->select.okapply.apply, trace, MC_NOKEYS);
1505
1506 /* cancel button is broken */
1507
1508 /* Create Separator */
1509 XtSetArg (arglist[0], XmNleftAttachment, XmATTACH_FORM );
1510 XtSetArg (arglist[1], XmNrightAttachment, XmATTACH_FORM );
1511 XtSetArg (arglist[2], XmNbottomAttachment, XmATTACH_WIDGET );
1512 XtSetArg (arglist[3], XmNbottomWidget, trace->select.okapply.ok );
1513 XtSetArg (arglist[4], XmNbottomOffset, 10);
1514 trace->select.okapply.sep = XmCreateSeparator (trace->select.dialog, "sep",arglist,5);
1515 DManageChild (trace->select.okapply.sep, trace, MC_NOKEYS);
1516
1517 /*** Add (deleted list) section ***/
1518 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Add Signal Pattern"));
1519 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_FORM );
1520 XtSetArg (arglist[2], XmNtopAttachment, XmATTACH_FORM );
1521 trace->select.label2 = XmCreateLabel (trace->select.dialog,"label2",arglist,3);
1522 DManageChild (trace->select.label2, trace, MC_NOKEYS);
1523
1524 XtSetArg (arglist[0], XmNrows, 1);
1525 XtSetArg (arglist[1], XmNcolumns, 30);
1526 XtSetArg (arglist[2], XmNresizeHeight, FALSE);
1527 XtSetArg (arglist[3], XmNeditMode, XmSINGLE_LINE_EDIT);
1528 XtSetArg (arglist[4], XmNleftAttachment, XmATTACH_FORM );
1529 XtSetArg (arglist[5], XmNtopAttachment, XmATTACH_WIDGET );
1530 XtSetArg (arglist[6], XmNtopWidget, trace->select.label2);
1531 XtSetArg (arglist[7], XmNrightAttachment, XmATTACH_POSITION );
1532 XtSetArg (arglist[8], XmNrightPosition, 50);
1533 XtSetArg (arglist[9], XmNvalue, "*");
1534 trace->select.add_pat = XmCreateText (trace->select.dialog,"dpat",arglist,10);
1535 DAddCallback (trace->select.add_pat, XmNactivateCallback, sig_sel_pattern_cb, trace);
1536 DManageChild (trace->select.add_pat, trace, MC_NOKEYS);
1537
1538 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Add All") );
1539 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_FORM );
1540 XtSetArg (arglist[2], XmNbottomAttachment, XmATTACH_WIDGET );
1541 XtSetArg (arglist[3], XmNbottomWidget, trace->select.okapply.sep);
1542 trace->select.add_all = XmCreatePushButton (trace->select.dialog,"aall",arglist,4);
1543 XtRemoveAllCallbacks (trace->select.add_all, XmNactivateCallback);
1544 DAddCallback (trace->select.add_all, XmNactivateCallback, sig_sel_add_all_cb, trace);
1545 DManageChild (trace->select.add_all, trace, MC_NOKEYS);
1546
1547 XtSetArg (arglist[0], XmNlabelString, string_create_with_cr ("Select a signal to add it\nto the displayed signals."));
1548 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_FORM );
1549 XtSetArg (arglist[2], XmNtopAttachment, XmATTACH_WIDGET );
1550 XtSetArg (arglist[3], XmNtopWidget, trace->select.add_pat);
1551 trace->select.label1 = XmCreateLabel (trace->select.dialog,"label1",arglist,4);
1552 DManageChild (trace->select.label1, trace, MC_NOKEYS);
1553
1554 XtSetArg (arglist[0], XmNleftAttachment, XmATTACH_FORM );
1555 XtSetArg (arglist[1], XmNtopAttachment, XmATTACH_WIDGET );
1556 XtSetArg (arglist[2], XmNtopWidget, trace->select.label1);
1557 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_WIDGET );
1558 XtSetArg (arglist[4], XmNbottomWidget, trace->select.add_all);
1559 XtSetArg (arglist[5], XmNrightAttachment, XmATTACH_POSITION );
1560 XtSetArg (arglist[6], XmNrightPosition, 50);
1561 trace->select.add_sigs_form = XmCreateForm (trace->select.dialog, "add_sigs_form", arglist, 7);
1562 DManageChild (trace->select.add_sigs_form, trace, MC_NOKEYS);
1563
1564 /* This is under its own form to prevent child attachment errors */
1565 XtSetArg (arglist[0], XmNlistVisibleItemCount, 5);
1566 XtSetArg (arglist[1], XmNlistSizePolicy, XmCONSTANT);
1567 XtSetArg (arglist[2], XmNselectionPolicy, XmEXTENDED_SELECT);
1568 XtSetArg (arglist[3], XmNitems, 0);
1569 XtSetArg (arglist[4], XmNrightAttachment, XmATTACH_FORM );
1570 XtSetArg (arglist[5], XmNleftAttachment, XmATTACH_FORM );
1571 XtSetArg (arglist[6], XmNtopAttachment, XmATTACH_FORM );
1572 XtSetArg (arglist[7], XmNbottomAttachment, XmATTACH_FORM );
1573 trace->select.add_sigs = XmCreateScrolledList (trace->select.add_sigs_form,"add_sigs",arglist,8);
1574 DAddCallback (trace->select.add_sigs, XmNextendedSelectionCallback, sig_sel_add_list_cb, trace);
1575 DManageChild (trace->select.add_sigs, trace, MC_NOKEYS);
1576
1577 /*** Delete (existing list) section ***/
1578 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Delete Signal Pattern"));
1579 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1580 XtSetArg (arglist[2], XmNleftWidget, trace->select.add_sigs_form);
1581 XtSetArg (arglist[3], XmNtopAttachment, XmATTACH_FORM );
1582 trace->select.label4 = XmCreateLabel (trace->select.dialog,"label4",arglist,4);
1583 DManageChild (trace->select.label4, trace, MC_NOKEYS);
1584
1585 XtSetArg (arglist[0], XmNrows, 1);
1586 XtSetArg (arglist[1], XmNcolumns, 30);
1587 XtSetArg (arglist[1], XmNvalue, "*");
1588 XtSetArg (arglist[2], XmNresizeHeight, FALSE);
1589 XtSetArg (arglist[3], XmNeditMode, XmSINGLE_LINE_EDIT);
1590 XtSetArg (arglist[4], XmNleftAttachment, XmATTACH_WIDGET );
1591 XtSetArg (arglist[5], XmNleftWidget, trace->select.add_sigs_form);
1592 XtSetArg (arglist[6], XmNtopAttachment, XmATTACH_WIDGET );
1593 XtSetArg (arglist[7], XmNtopWidget, trace->select.label2);
1594 XtSetArg (arglist[8], XmNrightAttachment, XmATTACH_FORM );
1595 trace->select.delete_pat = XmCreateText (trace->select.dialog,"apat",arglist,9);
1596 DAddCallback (trace->select.delete_pat, XmNactivateCallback, sig_sel_pattern_cb, trace);
1597 DManageChild (trace->select.delete_pat, trace, MC_NOKEYS);
1598
1599 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Sort Wholename") );
1600 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1601 XtSetArg (arglist[2], XmNleftWidget, trace->select.add_sigs_form);
1602 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_WIDGET );
1603 XtSetArg (arglist[4], XmNbottomWidget, trace->select.okapply.sep);
1604 trace->select.sort_full = XmCreatePushButton (trace->select.dialog,"dcon",arglist,5);
1605 XtRemoveAllCallbacks (trace->select.sort_full, XmNactivateCallback);
1606 DAddCallback (trace->select.sort_full, XmNactivateCallback, sig_sel_sort_cb, trace);
1607 DManageChild (trace->select.sort_full, trace, MC_NOKEYS);
1608
1609 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Sort Basename") );
1610 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1611 XtSetArg (arglist[2], XmNleftWidget, trace->select.sort_full);
1612 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_WIDGET );
1613 XtSetArg (arglist[4], XmNbottomWidget, trace->select.okapply.sep);
1614 trace->select.sort_nopath = XmCreatePushButton (trace->select.dialog,"dconxz",arglist,5);
1615 XtRemoveAllCallbacks (trace->select.sort_nopath, XmNactivateCallback);
1616 DAddCallback (trace->select.sort_nopath, XmNactivateCallback, sig_sel_sort_base_cb, trace);
1617 DManageChild (trace->select.sort_nopath, trace, MC_NOKEYS);
1618
1619 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Delete Constants") );
1620 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1621 XtSetArg (arglist[2], XmNleftWidget, trace->select.add_sigs_form);
1622 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_WIDGET );
1623 XtSetArg (arglist[4], XmNbottomWidget, trace->select.sort_full);
1624 trace->select.delete_const = XmCreatePushButton (trace->select.dialog,"dcon",arglist,5);
1625 XtRemoveAllCallbacks (trace->select.delete_const, XmNactivateCallback);
1626 DAddCallback (trace->select.delete_const, XmNactivateCallback, sig_sel_del_const_cb, trace);
1627 DManageChild (trace->select.delete_const, trace, MC_NOKEYS);
1628
1629 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Delete Const or X/Z") );
1630 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1631 XtSetArg (arglist[2], XmNleftWidget, trace->select.delete_const);
1632 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_WIDGET );
1633 XtSetArg (arglist[4], XmNbottomWidget, trace->select.sort_full);
1634 trace->select.delete_const_xz = XmCreatePushButton (trace->select.dialog,"dconxz",arglist,5);
1635 XtRemoveAllCallbacks (trace->select.delete_const_xz, XmNactivateCallback);
1636 DAddCallback (trace->select.delete_const_xz, XmNactivateCallback, sig_sel_del_const_xz_cb, trace);
1637 DManageChild (trace->select.delete_const_xz, trace, MC_NOKEYS);
1638
1639 XtSetArg (arglist[0], XmNlabelString, XmStringCreateSimple ("Delete All") );
1640 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1641 XtSetArg (arglist[2], XmNleftWidget, trace->select.add_sigs_form);
1642 XtSetArg (arglist[3], XmNbottomAttachment, XmATTACH_WIDGET );
1643 XtSetArg (arglist[4], XmNbottomWidget, trace->select.delete_const);
1644 trace->select.delete_all = XmCreatePushButton (trace->select.dialog,"dall",arglist,5);
1645 XtRemoveAllCallbacks (trace->select.delete_all, XmNactivateCallback);
1646 DAddCallback (trace->select.delete_all, XmNactivateCallback, sig_sel_del_all_cb, trace);
1647 DManageChild (trace->select.delete_all, trace, MC_NOKEYS);
1648
1649 XtSetArg (arglist[0], XmNlabelString, string_create_with_cr ("Select a signal to delete it\nfrom the displayed signals."));
1650 XtSetArg (arglist[1], XmNleftAttachment, XmATTACH_WIDGET );
1651 XtSetArg (arglist[2], XmNleftWidget, trace->select.add_sigs_form);
1652 XtSetArg (arglist[3], XmNtopAttachment, XmATTACH_WIDGET );
1653 XtSetArg (arglist[4], XmNtopWidget, trace->select.delete_pat);
1654 trace->select.label3 = XmCreateLabel (trace->select.dialog,"label3",arglist,5);
1655 DManageChild (trace->select.label3, trace, MC_NOKEYS);
1656
1657 XtSetArg (arglist[0], XmNrightAttachment, XmATTACH_FORM );
1658 XtSetArg (arglist[1], XmNlistVisibleItemCount, 5);
1659 XtSetArg (arglist[2], XmNtopAttachment, XmATTACH_WIDGET );
1660 XtSetArg (arglist[3], XmNtopWidget, trace->select.label3);
1661 XtSetArg (arglist[4], XmNbottomAttachment, XmATTACH_WIDGET );
1662 XtSetArg (arglist[5], XmNbottomWidget, trace->select.delete_all);
1663 XtSetArg (arglist[6], XmNleftAttachment, XmATTACH_WIDGET );
1664 XtSetArg (arglist[7], XmNleftWidget, trace->select.add_sigs_form);
1665 XtSetArg (arglist[8], XmNlistSizePolicy, XmCONSTANT);
1666 XtSetArg (arglist[9], XmNselectionPolicy, XmEXTENDED_SELECT);
1667 XtSetArg (arglist[10], XmNitems, 0);
1668 trace->select.delete_sigs = XmCreateScrolledList (trace->select.dialog,"",arglist,11);
1669 DAddCallback (trace->select.delete_sigs, XmNextendedSelectionCallback, sig_sel_del_list_cb, trace);
1670 DManageChild (trace->select.delete_sigs, trace, MC_NOKEYS);
1671 }
1672
1673 /* manage the popup on the screen */
1674 DManageChild (trace->select.dialog, trace, MC_NOKEYS);
1675
1676 /* update patterns - leave under the "manage" or toolkit will complain */
1677 sig_sel_pattern_cb (NULL, trace, NULL);
1678 }
1679
sig_sel_update_pattern(Widget w,Signal_t * head_sig_ptr,char * pattern,XmString ** xs_list,Signal_t *** xs_sigs,uint_t * xs_size)1680 static void sig_sel_update_pattern (
1681 Widget w, /* List widget to update */
1682 Signal_t *head_sig_ptr, /* Head signal in the list */
1683 char *pattern, /* Pattern to match to the list */
1684 XmString **xs_list, /* Static storage for string list */
1685 Signal_t ***xs_sigs, /* Static storage for signal list */
1686 uint_t *xs_size)
1687 {
1688 Signal_t *sig_ptr;
1689 uint_t sel_count;
1690
1691 /* loop thru signals on deleted queue and add to list */
1692 sel_count = 0;
1693 for (sig_ptr = head_sig_ptr; sig_ptr; sig_ptr = sig_ptr->forward) {
1694 if (wildmat (sig_ptr->signame, pattern)) {
1695 sel_count++;
1696 }
1697 }
1698 sel_count++; /* Space for null termination */
1699
1700 /* Make sure that we have somewhere to store the signals */
1701 if (! *xs_list) {
1702 *xs_list = (XmString *)XtMalloc (sel_count * sizeof (XmString));
1703 *xs_sigs = (Signal_t **)XtMalloc (sel_count * sizeof (Signal_t *));
1704 *xs_size = sel_count;
1705 }
1706 else if (*xs_size < sel_count) {
1707 *xs_list = (XmString *)XtRealloc ((char*)*xs_list, sel_count * sizeof (XmString));
1708 *xs_sigs = (Signal_t **)XtRealloc ((char*)*xs_sigs, sel_count * sizeof (Signal_t *));
1709 *xs_size = sel_count;
1710 }
1711
1712 /* go through the list again and make the array */
1713 sel_count = 0;
1714 for (sig_ptr = head_sig_ptr; sig_ptr; sig_ptr = sig_ptr->forward) {
1715 if ((pattern[0] == '*' && pattern[1] == '\0')
1716 || wildmat (sig_ptr->signame, pattern)) {
1717 (*xs_list)[sel_count] = sig_ptr->xsigname;
1718 (*xs_sigs)[sel_count] = sig_ptr;
1719 sel_count++;
1720 }
1721 }
1722 /* Mark list end */
1723 (*xs_list)[sel_count] = NULL;
1724 (*xs_sigs)[sel_count] = NULL;
1725
1726 /* update the widget */
1727 XtSetArg (arglist[0], XmNitemCount, sel_count);
1728 XtSetArg (arglist[1], XmNitems, *xs_list);
1729 XtSetValues (w, arglist, 2);
1730 }
1731
sig_sel_pattern_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1732 void sig_sel_pattern_cb (
1733 Widget w,
1734 Trace_t *trace,
1735 XmAnyCallbackStruct *cb)
1736 /* Called by creation or call back - create the list of signals with a possibly new pattern */
1737 {
1738 char *pattern;
1739 int prev_cursor;
1740
1741 /* This may take a while */
1742 prev_cursor = last_set_cursor ();
1743 set_cursor (DC_BUSY);
1744
1745 /* loop thru signals on deleted queue and add to list */
1746 pattern = XmTextGetString (trace->select.add_pat);
1747 sig_sel_update_pattern (trace->select.add_sigs, global->deleted_trace_head->firstsig, pattern,
1748 &(trace->select.add_strings), &(trace->select.add_signals),
1749 &(trace->select.add_size));
1750
1751 /* loop thru signals on displayed queue and add to list */
1752 pattern = XmTextGetString (trace->select.delete_pat);
1753 sig_sel_update_pattern (trace->select.delete_sigs, trace->firstsig, pattern,
1754 &(trace->select.del_strings), &(trace->select.del_signals),
1755 &(trace->select.del_size));
1756
1757 set_cursor (prev_cursor);
1758 }
1759
sig_sel_ok_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1760 void sig_sel_ok_cb (
1761 Widget w,
1762 Trace_t *trace,
1763 XmAnyCallbackStruct *cb)
1764 {
1765 draw_needupd_sig_start ();
1766 draw_all_needed ();
1767 }
1768
sig_sel_apply_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1769 void sig_sel_apply_cb (
1770 Widget w,
1771 Trace_t *trace,
1772 XmAnyCallbackStruct *cb)
1773 {
1774 if (DTPRINT_ENTRY) printf ("In sig_sel_apply_cb - trace=%p\n",trace);
1775
1776 sig_sel_ok_cb (w,trace,cb);
1777 sig_select_cb (trace->main);
1778 }
1779
sig_sel_add_all_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1780 void sig_sel_add_all_cb (
1781 Widget w,
1782 Trace_t *trace,
1783 XmAnyCallbackStruct *cb)
1784 {
1785 Signal_t *sig_ptr;
1786 int i;
1787
1788 if (DTPRINT_ENTRY) printf ("In sig_sel_add_all_cb - trace=%p\n",trace);
1789
1790 /* loop thru signals on deleted queue and add to list */
1791 for (i=0; 1; i++) {
1792 sig_ptr = (trace->select.add_signals)[i];
1793 if (!sig_ptr) break;
1794
1795 /* Add it */
1796 sig_move (global->deleted_trace_head, sig_ptr, trace, ADD_LAST);
1797 }
1798 sig_sel_pattern_cb (NULL, trace, NULL);
1799 }
1800
sig_sel_del_all_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1801 void sig_sel_del_all_cb (
1802 Widget w,
1803 Trace_t *trace,
1804 XmAnyCallbackStruct *cb)
1805 {
1806 Signal_t *sig_ptr;
1807 int i;
1808
1809 if (DTPRINT_ENTRY) printf ("In sig_sel_del_all_cb - trace=%p\n",trace);
1810
1811 /* loop thru signals on deleted queue and add to list */
1812 for (i=0; 1; i++) {
1813 sig_ptr = (trace->select.del_signals)[i];
1814 if (!sig_ptr) break;
1815 sig_delete (trace, sig_ptr, TRUE, ADD_LAST);
1816 }
1817 sig_sel_pattern_cb (NULL, trace, NULL);
1818 }
1819
sig_sel_del_const(Trace_t * trace,Boolean_t ignorexz)1820 void sig_sel_del_const (
1821 Trace_t *trace,
1822 Boolean_t ignorexz) /* TRUE = ignore xz */
1823 {
1824 Signal_t *sig_ptr;
1825 int i;
1826
1827 if (DTPRINT_ENTRY) printf ("In sig_sel_del_const_cb - trace=%p\n",trace);
1828
1829 /* loop thru signals on deleted queue and add to list */
1830 for (i=0; 1; i++) {
1831 sig_ptr = (trace->select.del_signals)[i];
1832 if (!sig_ptr) break;
1833
1834 /* Delete it */
1835 if (sig_is_constant (trace, sig_ptr, ignorexz)) {
1836 sig_delete (trace, sig_ptr, FALSE, ADD_LAST);
1837 }
1838 }
1839 sig_sel_pattern_cb (NULL, trace, NULL);
1840 }
1841
sig_sel_del_const_xz_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1842 void sig_sel_del_const_xz_cb (
1843 Widget w,
1844 Trace_t *trace,
1845 XmAnyCallbackStruct *cb)
1846 {
1847 sig_sel_del_const (trace, TRUE);
1848 }
1849
sig_sel_del_const_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1850 void sig_sel_del_const_cb (
1851 Widget w,
1852 Trace_t *trace,
1853 XmAnyCallbackStruct *cb)
1854 {
1855 sig_sel_del_const (trace, FALSE);
1856 }
1857
sig_sel_add_list_cb(Widget w,Trace_t * trace,XmListCallbackStruct * cb)1858 void sig_sel_add_list_cb (
1859 Widget w,
1860 Trace_t *trace,
1861 XmListCallbackStruct *cb)
1862 {
1863 int sel, i;
1864 Signal_t *sig_ptr;
1865
1866 if (DTPRINT_ENTRY) printf ("In sig_sel_add_list_cb - trace=%p\n",trace);
1867
1868 for (sel=0; sel < cb->selected_item_count; sel++) {
1869 i = (cb->selected_item_positions)[sel] - 1;
1870 sig_ptr = (trace->select.add_signals)[i];
1871 if (!sig_ptr) fprintf (stderr, "Unexpected null signal\n");
1872 /*if (DTPRINT) printf ("Pos %d sig '%s'\n", i, sig_ptr->signame);*/
1873
1874 /* Add it */
1875 sig_move (global->deleted_trace_head, sig_ptr, trace, ADD_LAST);
1876 }
1877 sig_sel_pattern_cb (NULL, trace, NULL);
1878 }
1879
sig_sel_del_list_cb(Widget w,Trace_t * trace,XmListCallbackStruct * cb)1880 void sig_sel_del_list_cb (
1881 Widget w,
1882 Trace_t *trace,
1883 XmListCallbackStruct *cb)
1884 {
1885 int sel, i;
1886 Signal_t *sig_ptr;
1887
1888 if (DTPRINT_ENTRY) printf ("In sig_sel_del_list_cb - trace=%p\n",trace);
1889
1890 for (sel=0; sel < cb->selected_item_count; sel++) {
1891 i = (cb->selected_item_positions)[sel] - 1;
1892 sig_ptr = (trace->select.del_signals)[i];
1893 if (!sig_ptr) fprintf (stderr, "Unexpected null signal\n");
1894 /*if (DTPRINT) printf ("Pos %d sig '%s'\n", i, sig_ptr->signame);*/
1895
1896 /* Delete it */
1897 sig_delete (trace, sig_ptr, TRUE, ADD_LAST);
1898 }
1899 sig_sel_pattern_cb (NULL, trace, NULL);
1900 }
1901
1902 /**********************************************************************/
1903
1904 typedef int (*qsort_compar) (const void *, const void *);
sig_sel_sort_cmp(Signal_t ** siga_pptr,Signal_t ** sigb_pptr)1905 static int sig_sel_sort_cmp (
1906 Signal_t **siga_pptr,
1907 Signal_t **sigb_pptr)
1908 {
1909 return (strcmp((*siga_pptr)->key, (*sigb_pptr)->key));
1910 }
1911
sig_sel_sort(Trace_t * trace,Boolean_t usebasename)1912 void sig_sel_sort (
1913 Trace_t *trace,
1914 Boolean_t usebasename)
1915 {
1916 Signal_t *sig_ptr;
1917 int i;
1918 int nel = 0;
1919 if (DTPRINT_ENTRY) printf ("In sig_sel_sort - trace=%p\n",trace);
1920
1921 /* loop thru signals on deleted queue and add to list */
1922 for (i=0; 1; i++) {
1923 sig_ptr = (trace->select.del_signals)[i];
1924 if (!sig_ptr) break;
1925 /* Add to sort list */
1926 nel = i+1;
1927 sig_ptr->key = usebasename ? sig_basename (trace, sig_ptr)
1928 : sig_ptr->signame;
1929 /*printf ("sortn %s\n", sig_ptr->key);*/
1930 }
1931
1932 /* sortem */
1933 qsort ((trace->select.del_signals), nel, sizeof (Signal_t *), (qsort_compar)sig_sel_sort_cmp);
1934
1935 /* reextract */
1936 for (i=0; i<nel; i++) {
1937 sig_ptr = (trace->select.del_signals)[i];
1938 /*printf ("sorted %s\n", sig_ptr->key);*/
1939 sig_move (trace, sig_ptr, trace, ADD_LAST);
1940 }
1941
1942 sig_sel_apply_cb (NULL, trace, NULL);
1943 }
1944
sig_sel_sort_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1945 void sig_sel_sort_cb (
1946 Widget w,
1947 Trace_t *trace,
1948 XmAnyCallbackStruct *cb)
1949 {
1950 sig_sel_sort (trace, FALSE);
1951 }
1952
sig_sel_sort_base_cb(Widget w,Trace_t * trace,XmAnyCallbackStruct * cb)1953 void sig_sel_sort_base_cb (
1954 Widget w,
1955 Trace_t *trace,
1956 XmAnyCallbackStruct *cb)
1957 {
1958 sig_sel_sort (trace, TRUE);
1959 }
1960
1961 /**********************************************************************/
1962 /**********************************************************************/
1963 /****************************** PRESERVATION ****************************************/
1964
1965 /* Preserving signal ordering and other information across trace reading
1966 sig_cross_preserve
1967 Make new trace structure with old data
1968 Clear out transition data (to save memory space)
1969
1970 read new trace information
1971
1972 sig_cross_restore
1973 Erase copy of old trace
1974 Erase old signal information
1975 */
1976
1977 #define new_trace_sig verilog_next /* Use existing unused field (not current trace) */
1978 #define new_forward_sig verilog_next /* Use existing unused field (in current trace) */
1979
sig_cross_preserve(Trace_t * trace)1980 void sig_cross_preserve (
1981 /* This is pre-cleanup when preserving signal information for a new trace to be read */
1982 Trace_t *trace)
1983 {
1984 Signal_t *sig_ptr;
1985 Trace_t *trace_ptr;
1986
1987 if (DTPRINT_ENTRY) printf ("In sig_cross_preserve - trace=%p\n",trace);
1988
1989 /* Save the current trace into a new preserved place */
1990 assert (global->preserved_trace==NULL);
1991
1992 if (! global->save_ordering) {
1993 /* Will be freed by sig_free call later inside trace reading */
1994 return;
1995 }
1996
1997 global->preserved_trace = XtNew (Trace_t);
1998 memcpy (global->preserved_trace, trace, sizeof (Trace_t));
1999
2000 /* Other signals, AND deleted signals */
2001 for (trace_ptr = global->deleted_trace_head; trace_ptr; trace_ptr = trace_ptr->next_trace) {
2002 for (sig_ptr = trace_ptr->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
2003
2004 if (sig_ptr->trace == trace) {
2005 /* change to point to the new preserved structure */
2006 sig_ptr->trace = global->preserved_trace;
2007 sig_ptr->new_trace_sig = NULL;
2008 }
2009 }
2010 }
2011
2012 /* Tell old trace that it no longer has any signals */
2013 trace->firstsig = NULL;
2014 trace->lastsig = NULL;
2015 trace->dispsig = NULL;
2016 trace->numsigstart = 0;
2017 }
2018
sig_hash_name(Trace_t * trace,uint_t hashsize,Signal_t ** hash)2019 static void sig_hash_name (
2020 /* Assign signal names a hash value for faster lookup */
2021 Trace_t *trace,
2022 uint_t hashsize,
2023 Signal_t **hash
2024 )
2025 {
2026 Signal_t *sig_ptr;
2027 Signal_t **change_pptr;
2028 for (sig_ptr = trace->firstsig; sig_ptr; sig_ptr = sig_ptr->forward) {
2029 uint_t hashval = 0;
2030 char *tp = sig_ptr->signame;
2031 while (*tp) hashval = (hashval*33) + *tp++;
2032 hashval = hashval % hashsize;
2033 sig_ptr->signame_hash = hashval;
2034 if (hash) {
2035 change_pptr = &hash[hashval];
2036 /* Add to the end of the hash list so that signals w/ identical name will retain ordering */
2037 /* Verilog_next is overloaded for hash chain */
2038 while (*change_pptr) { change_pptr = &((*change_pptr)->verilog_next); }
2039 *change_pptr = sig_ptr;
2040 }
2041 /* Clear link in prep for next operation */
2042 sig_ptr->new_trace_sig = NULL;
2043 sig_ptr->preserve_match = 0;
2044 }
2045 }
2046
sig_cross_sigmatch(Trace_t * new_trace,Trace_t * old_trace)2047 static void sig_cross_sigmatch (
2048 /* Look through each signal in the old list, attempt to match with
2049 signal from the new_trace. When found create new_trace_sig link to/from old & new signal */
2050 Trace_t *new_trace,
2051 Trace_t *old_trace)
2052 {
2053 Signal_t *new_sig_ptr; /* New signal now searching on */
2054 Signal_t *old_sig_ptr;
2055 Signal_t **hash;
2056 uint_t hashsize;
2057
2058 if (!old_trace->firstsig || !new_trace->firstsig) return; /* Empty */
2059 if (old_trace == new_trace) return;
2060
2061 /* Speed up name comparison by hashing names */
2062 hashsize = new_trace->numsig*2;
2063 hash = (Signal_t**)XtCalloc(hashsize, (unsigned) sizeof(Signal_t *));
2064
2065 sig_hash_name (new_trace, hashsize, hash); /* Also sets new_trace_sig = NULL */
2066 sig_hash_name (old_trace, hashsize, NULL);
2067
2068 /* Look at each old signal */
2069 for (old_sig_ptr = old_trace->firstsig; old_sig_ptr; old_sig_ptr = old_sig_ptr->forward) {
2070 /* See if have new signal in hash bucket */
2071 for (new_sig_ptr = hash[old_sig_ptr->signame_hash];
2072 new_sig_ptr; new_sig_ptr = new_sig_ptr->verilog_next) {
2073 char *os = old_sig_ptr->signame;
2074 char *ns = new_sig_ptr->signame;
2075 /*printf ("Compare %p %s == %p %s\n",
2076 old_sig_ptr, old_sig_ptr->signame, new_sig_ptr, new_sig_ptr->signame);*/
2077 /* Do our own strcmp; much faster */
2078 while (*os && *os++ == *ns++);
2079 if (*os == '\0' && *ns == '\0'
2080 && !new_sig_ptr->preserve_match) {
2081 /* Match */
2082 if (DTPRINT_FILE) printf ("Matched %s %d %p == %s %d %p\n",
2083 old_sig_ptr->signame, old_sig_ptr->file_pos, old_sig_ptr,
2084 new_sig_ptr->signame, new_sig_ptr->file_pos, new_sig_ptr);
2085 old_sig_ptr->new_trace_sig = new_sig_ptr;
2086 new_sig_ptr->preserve_match = 1; /* So duplicate sig names work ok */
2087 /* Save color, etc */
2088 new_sig_ptr->color = old_sig_ptr->color;
2089 new_sig_ptr->search = old_sig_ptr->search;
2090 new_sig_ptr->radix = old_sig_ptr->radix;
2091 new_sig_ptr->waveform = old_sig_ptr->waveform;
2092 break; /* On to next old signal */
2093 }
2094 }
2095 }
2096 DFree(hash);
2097 }
2098
sig_cross_restore(Trace_t * trace)2099 void sig_cross_restore (
2100 /* Try to make new trace's signal placement match the old placement */
2101 Trace_t *trace) /* New trace */
2102 {
2103 Signal_t *old_sig_ptr;
2104 Trace_t *trace_ptr;
2105 Signal_t *new_sig_ptr; /* Pointer to new trace's signal */
2106 Signal_t *next_sig_ptr;
2107
2108 Signal_t *newlist_firstsig;
2109 Signal_t **back_sig_pptr;
2110
2111 Signal_t *new_dispsig;
2112
2113 if (DTPRINT_ENTRY) printf ("In sig_cross_restore - trace=%p\n",trace);
2114
2115 if (global->save_ordering && global->preserved_trace) {
2116 /* Preserve colors, etc */
2117
2118 /* Establish links */
2119 sig_cross_sigmatch (trace, global->deleted_trace_head);
2120 sig_cross_sigmatch (trace, global->preserved_trace);
2121 for (trace_ptr = global->deleted_trace_head; trace_ptr; trace_ptr = trace_ptr->next_trace) {
2122 sig_cross_sigmatch (trace, trace_ptr);
2123 }
2124 if (DTPRINT_PRESERVE) printf ("Preserve: Match done\n");
2125
2126 /* Deleted signals */
2127 if (DTPRINT_PRESERVE) printf ("Preserve: Deleting signals\n");
2128 for (old_sig_ptr = global->deleted_trace_head->firstsig; old_sig_ptr; old_sig_ptr = old_sig_ptr->forward) {
2129 if (old_sig_ptr->trace == global->preserved_trace) {
2130 /* Signal was deleted in preserved trace, so delete new one too */
2131 new_sig_ptr = old_sig_ptr->new_trace_sig;
2132 if (old_sig_ptr->deleted_preserve && (NULL != new_sig_ptr)) {
2133 if (DTPRINT_PRESERVE) printf ("Preserve: Please delete %s\n", old_sig_ptr->signame);
2134 sig_delete (trace, new_sig_ptr, TRUE, NULL/*killorder-faster*/);
2135 }
2136 }
2137 }
2138
2139 /* Remember scrolling position before move signals around */
2140 new_dispsig = NULL; /* But, don't set it yet, the pointer may move */
2141 if (global->preserved_trace->dispsig) {
2142 }
2143 if (global->preserved_trace->dispsig && global->preserved_trace->dispsig->new_trace_sig) {
2144 new_dispsig = global->preserved_trace->dispsig->new_trace_sig;
2145 }
2146
2147 /* Other signals */
2148 if (DTPRINT_PRESERVE) printf ("Preserve: Copy/move to other\n");
2149 for (trace_ptr = global->trace_head; trace_ptr; trace_ptr = trace_ptr->next_trace) {
2150 for (old_sig_ptr = global->preserved_trace->firstsig; old_sig_ptr; old_sig_ptr = old_sig_ptr->forward) {
2151 if ( (old_sig_ptr->trace == global->preserved_trace) /* Sig from old trace */
2152 && (trace_ptr != global->preserved_trace) ) { /* Not in old trace */
2153 if (NULL != (new_sig_ptr = old_sig_ptr->new_trace_sig)) {
2154 if (old_sig_ptr->copyof && !old_sig_ptr->file_copy) {
2155 /* Copy to other */
2156 if (DTPRINT_PRESERVE) printf ("Preserve: Please copy-to-other %s\n", old_sig_ptr->signame);
2157 sig_copy (trace, new_sig_ptr, trace_ptr, old_sig_ptr);
2158 }
2159 else {
2160 /* Move to other */
2161 if (DTPRINT_PRESERVE) printf ("Preserve: Please move-to-other %s\n", old_sig_ptr->signame);
2162 sig_move (trace, new_sig_ptr, trace_ptr, old_sig_ptr);
2163 }
2164 }
2165 }
2166 }
2167 }
2168 if (DTPRINT_PRESERVE && global->preserved_trace->firstsig) printf ("Preserve: %d %s\n", __LINE__, global->preserved_trace->firstsig->signame);
2169
2170 /* Zero new_forward_sigs in prep of making new list */
2171 for (new_sig_ptr = trace->firstsig; new_sig_ptr; new_sig_ptr = new_sig_ptr->forward) {
2172 new_sig_ptr->new_forward_sig = NULL;
2173 new_sig_ptr->preserve_done = FALSE; /* Temp flag to indicate has been moved to new link structure */
2174 }
2175
2176 /* Our trace, reestablish signal ordering and copying */
2177 if (DTPRINT_PRESERVE) printf ("Preserve: Ordering\n");
2178 trace_ptr = trace;
2179 newlist_firstsig = NULL;
2180 back_sig_pptr = &(newlist_firstsig);
2181 old_sig_ptr = global->preserved_trace->firstsig; /* This will trash old list, kill heads now */
2182 global->preserved_trace->firstsig = NULL;
2183 global->preserved_trace->lastsig = NULL;
2184 global->preserved_trace->dispsig = NULL;
2185 if (DTPRINT_PRESERVE) printf ("Preserve: %d\n", __LINE__);
2186 while (old_sig_ptr) {
2187 if (DTPRINT_PRESERVE && old_sig_ptr) printf ("Preserve: %s\n", old_sig_ptr->signame);
2188
2189 if (old_sig_ptr->trace != global->preserved_trace) { /* NOT sig from old trace */
2190 /* Copy or moved from a third independant trace file into this view,
2191 cheat by just relinking into new structure */
2192 if (DTPRINT_PRESERVE) printf ("Preserve: Please cp/mv-to-new %s\n", old_sig_ptr->signame);
2193 new_sig_ptr = old_sig_ptr;
2194 new_sig_ptr->preserve_done = TRUE;
2195 *back_sig_pptr = new_sig_ptr;
2196 back_sig_pptr = &(new_sig_ptr->new_forward_sig);
2197 /* Next OLD */
2198 next_sig_ptr = old_sig_ptr->forward;
2199 old_sig_ptr = next_sig_ptr;
2200 }
2201 else { /* In same trace */
2202 new_sig_ptr = old_sig_ptr->new_trace_sig;
2203 if (new_sig_ptr && !(new_sig_ptr->preserve_done)) {
2204 if (DTPRINT_PRESERVE) printf ("Preserve: %d\n", __LINE__);
2205 /* Has equivelent */
2206 new_sig_ptr->preserve_done = TRUE;
2207 *back_sig_pptr = new_sig_ptr;
2208 back_sig_pptr = &(new_sig_ptr->new_forward_sig);
2209 }
2210
2211 /* Don't need old_sig any more */
2212 /* Next OLD */
2213 if (DTPRINT_PRESERVE) printf ("Preserve: %d\n", __LINE__);
2214 next_sig_ptr = old_sig_ptr->forward;
2215 sig_free (trace_ptr, old_sig_ptr, FALSE, FALSE);
2216 old_sig_ptr = next_sig_ptr;
2217 }
2218 }
2219 *back_sig_pptr = NULL; /* Final link */
2220
2221 /* Insert any new signals that don't have links */
2222 if (DTPRINT_PRESERVE) printf ("Preserve: Inserting leftovers\n");
2223 old_sig_ptr = newlist_firstsig; /* This will trash old list, kill heads now */
2224 back_sig_pptr = &(newlist_firstsig);
2225 for (new_sig_ptr = trace->firstsig; new_sig_ptr; new_sig_ptr = new_sig_ptr->forward) {
2226 if (DTPRINT_PRESERVE) printf ("Preserve: %d new %s del%d lk %s nxt %s \n", __LINE__, new_sig_ptr->signame, new_sig_ptr->preserve_done,
2227 DeNullSignal(new_sig_ptr->new_forward_sig), DeNullSignal(new_sig_ptr->forward) );
2228 if (! new_sig_ptr->preserve_done) {
2229 /* TRUE insertion into list */
2230 new_sig_ptr->preserve_done = TRUE;
2231 new_sig_ptr->new_forward_sig = *back_sig_pptr;
2232 *back_sig_pptr = new_sig_ptr;
2233 }
2234 /* Either way, new_forward is now pointing to something */
2235 back_sig_pptr = &(new_sig_ptr->new_forward_sig); /* Insert next signal after this one */
2236 }
2237
2238 /* Relink forward & backwards links - may have been trashed above */
2239 if (DTPRINT_PRESERVE) printf ("Preserve: Relinking\n");
2240 trace->firstsig = newlist_firstsig;
2241 trace->numsig = 0;
2242 trace->numsigstart = 0;
2243 old_sig_ptr = NULL;
2244 for (new_sig_ptr = newlist_firstsig; new_sig_ptr; new_sig_ptr = new_sig_ptr->new_forward_sig) {
2245 trace->numsig++;
2246 new_sig_ptr->deleted = FALSE;
2247 new_sig_ptr->forward = new_sig_ptr->new_forward_sig;
2248 new_sig_ptr->backward = old_sig_ptr;
2249 old_sig_ptr = new_sig_ptr;
2250 }
2251 trace->lastsig = old_sig_ptr;
2252
2253 /* Restore scrolling position */
2254 trace->dispsig = (new_dispsig) ? new_dispsig : trace->firstsig;
2255 vscroll_new (trace,0);
2256
2257 if (DTPRINT_PRESERVE) printf ("Preserve: Done\n");
2258 }
2259
2260 /* Free information for the preserved trace */
2261 free_data (global->preserved_trace);
2262 DFree (global->preserved_trace);
2263
2264 if (DTDEBUG) debug_integrity_check_cb (NULL);
2265 }
2266
2267
2268
2269 /****************************** Enable COMBINING ******************************/
2270
sig_modify_en_signal(Trace_t * trace,Signal_t * en_sig_ptr,Signal_t * base_sig_ptr,Boolean_t is_cosmos)2271 static void sig_modify_en_signal (
2272 Trace_t *trace,
2273 Signal_t *en_sig_ptr,
2274 Signal_t *base_sig_ptr,
2275 Boolean_t is_cosmos)
2276 {
2277 Signal_t *new_sig_ptr;
2278 Value_t *base_cptr, *en_cptr;
2279 Value_t new_value, base_value, en_value;
2280 Boolean_t first_last_data=TRUE;
2281
2282 /*DTPRINT = (!strncmp(base_sig_ptr->signame, "k->MEMDATA", 10));*/
2283
2284 if (DTPRINT_FILE) printf ("sig_modify_en_signal %s + %s -> %s\n", en_sig_ptr->signame,
2285 base_sig_ptr->signame, base_sig_ptr->signame);
2286
2287 if (en_sig_ptr->bits != base_sig_ptr->bits) {
2288 printf ("sig_modify_en_signal, can't combine different sizes of %s and %s!!!\n",
2289 base_sig_ptr->signame, base_sig_ptr->signame);
2290 return;
2291 }
2292
2293 val_zero (&new_value);
2294
2295 new_sig_ptr = sig_replicate (trace, base_sig_ptr);
2296 /* Forget this is a copy, and allocate new data storage space */
2297 new_sig_ptr->signame = strdup (new_sig_ptr->signame);
2298 new_sig_ptr->copyof = NULL;
2299 new_sig_ptr->blocks = BLK_SIZE;
2300 new_sig_ptr->bptr = (Value_t *)XtMalloc ((new_sig_ptr->blocks*sizeof(uint_t))
2301 + (sizeof(Value_t)*2 + 2));
2302 val_zero (new_sig_ptr->bptr); /* So we know is empty */
2303 new_sig_ptr->cptr = new_sig_ptr->bptr;
2304
2305 base_cptr = base_sig_ptr->bptr;
2306 en_cptr = en_sig_ptr->bptr;
2307 val_copy (&base_value, base_cptr);
2308 val_copy (&en_value, en_cptr);
2309
2310 while ((CPTR_TIME(base_cptr) != EOT)
2311 && (CPTR_TIME(en_cptr) != EOT)) {
2312 /*if (DTPRINT_FILE) {
2313 printf ("BASE "); print_cptr (base_cptr);
2314 printf ("EN "); print_cptr (en_cptr);
2315 }*/
2316
2317 if (CPTR_TIME(base_cptr) == CPTR_TIME(en_cptr)) {
2318 val_copy (&en_value, en_cptr);
2319 val_copy (&base_value, base_cptr);
2320 }
2321 else if (CPTR_TIME(base_cptr) < CPTR_TIME(en_cptr)) {
2322 val_copy (&base_value, base_cptr);
2323 }
2324 else {
2325 val_copy (&en_value, en_cptr);
2326 }
2327
2328 val_copy (&new_value, &base_value);
2329
2330 /* Determine new value */
2331 /* Cosmos enable means force 0/1 -> U */
2332 /* Verilator enable means force 0/1 -> Z */
2333 switch (en_value.siglw.stbits.state) {
2334 case STATE_0: /* Leave value normal */
2335 break;
2336 case STATE_1: /* Single bit, disable it */
2337 new_value.siglw.stbits.state = is_cosmos ? STATE_U : STATE_Z;
2338 break;
2339
2340 /* STATE_1 can't occur below in the base because we know */
2341 /* the width of the enable is the same as the width of the base */
2342 /* and STATE_1 can only occur with 1 bits, B32 with 2 or more bits */
2343 case STATE_B32: /* Some bitmask of U's */
2344 switch (base_value.siglw.stbits.state) {
2345 case STATE_0:
2346 new_value.number[0] = 0;
2347 /* FALLTHRU */
2348 case STATE_B32:
2349 default:
2350 new_value.siglw.stbits.state = STATE_F32;
2351 if (is_cosmos) new_value.number[0] &= ~en_value.number[0]; /*U*/
2352 else new_value.number[0] |= en_value.number[0]; /*Z*/
2353 new_value.number[1] = en_value.number[0];
2354 break;
2355 case STATE_B128:
2356 new_value.siglw.stbits.state = STATE_F128;
2357 if (is_cosmos) new_value.number[0] &= ~en_value.number[0]; /*U*/
2358 else new_value.number[0] |= en_value.number[0]; /*Z*/
2359 new_value.number[4] = en_value.number[0];
2360 break;
2361 } /* en=B32, switch base_state */
2362 break;
2363
2364 case STATE_B128: /* Some bitmask of U's */
2365 switch (base_value.siglw.stbits.state) {
2366 case STATE_0:
2367 new_value.number[0] = 0;
2368 /* FALLTHRU */
2369 case STATE_B32:
2370 default:
2371 /* Make it look like the base value is a B128 */
2372 new_value.number[1] = 0;
2373 new_value.number[2] = 0;
2374 new_value.number[3] = 0;
2375 /* FALLTHRU */
2376 case STATE_B128:
2377 new_value.siglw.stbits.state = STATE_F128;
2378 if (is_cosmos) new_value.number[0] &= ~en_value.number[0]; /*U*/
2379 else new_value.number[0] |= en_value.number[0]; /*Z*/
2380 if (is_cosmos) new_value.number[1] &= ~en_value.number[1]; /*U*/
2381 else new_value.number[1] |= en_value.number[1]; /*Z*/
2382 if (is_cosmos) new_value.number[2] &= ~en_value.number[2]; /*U*/
2383 else new_value.number[2] |= en_value.number[2]; /*Z*/
2384 if (is_cosmos) new_value.number[3] &= ~en_value.number[3]; /*U*/
2385 else new_value.number[3] |= en_value.number[3]; /*Z*/
2386 new_value.number[4] = en_value.number[0];
2387 new_value.number[5] = en_value.number[1];
2388 new_value.number[6] = en_value.number[2];
2389 new_value.number[7] = en_value.number[3];
2390 break;
2391 } /* en=B32, switch base_state */
2392 break;
2393 } /* switch */
2394 /** end of determining new value **/
2395
2396 /* Calc time */
2397 if (CPTR_TIME(base_cptr) == CPTR_TIME(en_cptr)) {
2398 new_value.time = CPTR_TIME(base_cptr);
2399 base_cptr = CPTR_NEXT(base_cptr);
2400 en_cptr = CPTR_NEXT(en_cptr);
2401 }
2402 else if (CPTR_TIME(base_cptr) < CPTR_TIME(en_cptr)) {
2403 new_value.time = CPTR_TIME(base_cptr);
2404 base_cptr = CPTR_NEXT(base_cptr);
2405 }
2406 else {
2407 new_value.time = CPTR_TIME(en_cptr);
2408 en_cptr = CPTR_NEXT(en_cptr);
2409 }
2410
2411 if (new_value.number[4]
2412 && (new_value.number[4] == (new_sig_ptr->value_mask[0] & 0xffffffff))
2413 && (new_value.number[5] == (new_sig_ptr->value_mask[1] & 0xffffffff))
2414 && (new_value.number[6] == (new_sig_ptr->value_mask[2] & 0xffffffff))
2415 && (new_value.number[7] == (new_sig_ptr->value_mask[3] & 0xffffffff))
2416 && (new_value.number[0] == (new_sig_ptr->value_mask[0] & 0xffffffff))
2417 && (new_value.number[1] == (new_sig_ptr->value_mask[1] & 0xffffffff))
2418 && (new_value.number[2] == (new_sig_ptr->value_mask[2] & 0xffffffff))
2419 && (new_value.number[3] == (new_sig_ptr->value_mask[3] & 0xffffffff))) {
2420 new_value.siglw.stbits.state = STATE_Z;
2421 }
2422
2423 if ((CPTR_TIME(base_cptr) == EOT) && (CPTR_TIME(en_cptr) == EOT)) {
2424 first_last_data=TRUE;
2425 }
2426 /*if (DTPRINT_FILE) {
2427 printf ("%s Time %d, type = %d%s\n",
2428 new_sig_ptr->signame,
2429 CPTR_TIME(&new_value),
2430 new_value.siglw.stbits.state,
2431 (first_last_data?", LAST_DATA": ""));
2432 }*/
2433 fil_add_cptr (new_sig_ptr, &new_value, first_last_data);
2434 first_last_data=FALSE;
2435 }
2436
2437 /* Add ending data & EOT marker */
2438 new_value.time = EOT;
2439 fil_add_cptr (new_sig_ptr, &new_value, TRUE);
2440 new_sig_ptr->cptr = new_sig_ptr->bptr;
2441
2442 sig_add_to_queue (trace, new_sig_ptr, base_sig_ptr);
2443
2444 /*if (DTPRINT_FILE) {
2445 print_sig_info (new_sig_ptr);
2446 printf ("\n");
2447 }*/
2448
2449 if (! global->save_enables) {
2450 sig_free (trace, base_sig_ptr, FALSE, FALSE);
2451 sig_free (trace, en_sig_ptr, FALSE, FALSE);
2452 trace->numsig-=2;
2453 }
2454 }
2455
sig_wordcmp(const char * str,const char * word)2456 static Boolean_t sig_wordcmp(const char* str, const char* word) {
2457 /* Return true if this signal ends in the specified pattern*/
2458 while (*word) {
2459 if (!*str || *word != *str) return FALSE;
2460 word++; str++;
2461 }
2462 /* Next character must end a word*/
2463 return (!*str || (!isalnum(*str) && *str!='_'));
2464 }
2465
sig_modify_enables(Trace_t * trace)2466 void sig_modify_enables (
2467 Trace_t *trace)
2468 {
2469 Signal_t *sig_ptr, *en_sig_ptr, *base_sig_ptr;
2470 char *tp, *nonenablename;
2471 Boolean_t did_one=FALSE;
2472 Boolean_t is_cosmos=FALSE;
2473
2474 for (sig_ptr = trace->firstsig; sig_ptr; ) {
2475 for (tp=sig_ptr->signame; *tp; tp++) {
2476 if (tp[0]=='_' && tp[1]=='_'
2477 && (sig_wordcmp(tp+2, "en")
2478 || sig_wordcmp(tp+2, "EN")
2479 || sig_wordcmp(tp+2, "inen")
2480 || sig_wordcmp(tp+2, "INEN")
2481 || sig_wordcmp(tp+2, "cos")
2482 || sig_wordcmp(tp+2, "COS")))
2483 break;
2484 }
2485 if (*tp) {
2486 /* Got enable! */
2487
2488 /* if (DTPRINT_FILE) printf ("Checking %s\n", sig_ptr->signame); */
2489 nonenablename = strdup (sig_ptr->signame);
2490
2491 /* Chop _en from the middle of the name (sig__en<xx> -> sig<xx>)*/
2492 if (tp[2]=='e' || tp[2]=='E') {
2493 is_cosmos = FALSE;
2494 strcpy_overlap (nonenablename + (tp - sig_ptr->signame),
2495 nonenablename + (tp - sig_ptr->signame) + 4);
2496 }
2497 else if (tp[2]=='c' || tp[2]=='C') {
2498 is_cosmos = TRUE;
2499 strcpy_overlap (nonenablename + (tp - sig_ptr->signame),
2500 nonenablename + (tp - sig_ptr->signame) + 5);
2501 }
2502 else {
2503 /* (sig__inen<xx> -> sig__in<xx>)*/
2504 is_cosmos = FALSE;
2505 strcpy_overlap (nonenablename + (tp - sig_ptr->signame) + 4,
2506 nonenablename + (tp - sig_ptr->signame) + 6);
2507 }
2508
2509 en_sig_ptr = sig_ptr;
2510
2511 /* Start search right before this signal, in case there are duplicate signames */
2512 base_sig_ptr = en_sig_ptr;
2513 if (base_sig_ptr->backward) base_sig_ptr=base_sig_ptr->backward;
2514 base_sig_ptr = sig_find_signame_start_backward (base_sig_ptr, nonenablename);
2515 if (!base_sig_ptr) base_sig_ptr = sig_find_signame (trace, nonenablename);
2516
2517 /* Point to next signal, as we will be deleting several, */
2518 /* make sure we don't point at one being deleted */
2519 sig_ptr = sig_ptr->forward;
2520 while (sig_ptr && ((sig_ptr == en_sig_ptr) || (sig_ptr==base_sig_ptr))) {
2521 sig_ptr = sig_ptr->forward;
2522 }
2523
2524 free (nonenablename);
2525
2526 if (base_sig_ptr) {
2527 sig_modify_en_signal (trace, en_sig_ptr, base_sig_ptr, is_cosmos);
2528 did_one = TRUE;
2529 }
2530 }
2531 else {
2532 sig_ptr = sig_ptr->forward;
2533 }
2534 }
2535
2536 if (did_one) {
2537 if (DTPRINT_FILE) printf ("Done sig_modify_enables\n");
2538 /*read_mark_cptr_end (trace);*/
2539 }
2540 }
2541
2542
2543