/[ascend]/trunk/ascend/compiler/destroyinst.c
ViewVC logotype

Contents of /trunk/ascend/compiler/destroyinst.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2688 - (show annotations) (download) (as text)
Mon Mar 4 08:11:49 2013 UTC (7 years ago) by jpye
File MIME type: text/x-csrc
File size: 19559 byte(s)
Various debug output to try to resolve bug 567.
1 /*
2 * Ascend Instance Tree Killing
3 * by Tom Epperly & Ben Allan
4 * 9/3/89
5 * Version: $Revision: 1.12 $
6 * Version control file: $RCSfile: destroyinst.c,v $
7 * Date last modified: $Date: 1997/07/18 12:28:50 $
8 * Last modified by: $Author: mthomas $
9 *
10 * This file is part of the Ascend Language Interpreter.
11 *
12 * Copyright (C) 1996 Ben Allan
13 * based on instance.c
14 * Copyright (C) 1990, 1993, 1994 Thomas Guthrie Epperly
15 *
16 * The Ascend Language Interpreter is free software; you can redistribute
17 * it and/or modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation; either version 2 of the
19 * License, or (at your option) any later version.
20 *
21 * The Ascend Language Interpreter is distributed in hope that it will be
22 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program. If not, see <http://www.gnu.org/licenses/>.
28 */
29 #include <stdarg.h>
30 #include <ascend/general/platform.h>
31 #include <ascend/general/panic.h>
32 #include <ascend/general/ascMalloc.h>
33 #include <ascend/general/pool.h>
34 #include <ascend/general/list.h>
35 #include <ascend/general/dstring.h>
36
37 #include "symtab.h"
38 #include "functype.h"
39 #include "expr_types.h"
40 #include "instance_name.h"
41 #include "instance_io.h"
42 #include "child.h"
43 #include "type_desc.h"
44 #include "instmacro.h"
45 #include "instquery.h"
46 #include "instance_types.h"
47 #include "setinstval.h"
48 #include "linkinst.h"
49 #include "destroyinst.h"
50 #include "arrayinst.h"
51 #include "parentchild.h"
52 #include "atomvalue.h"
53 #include "atomsize.h"
54 #include "check.h"
55 #include "dump.h"
56 #include "find.h"
57 #include "type_desc.h"
58 #include "prototype.h"
59 #include "pending.h"
60 #include "rel_blackbox.h"
61 #include "vlist.h"
62 #include "relation.h"
63 #include "logical_relation.h"
64 #include "logrelation.h"
65 #include "relation_util.h"
66 #include "logrel_util.h"
67 #include "rel_common.h"
68 #include "case.h"
69 #include "when_util.h"
70 #include "universal.h"
71 #include "instance_types.h"
72 #include "cmpfunc.h"
73 #include "slvreq.h"
74
75
76 static void DeleteIPtr(struct Instance *i){
77 assert(i&&InterfacePtrDelete);
78 AssertMemory(i);
79 switch(i->t) {
80 case SIM_INST:
81 slvreq_sim_destroy_hooks(i);
82 (*InterfacePtrDelete)(i,SIM_INST(i)->interface_ptr);
83 SIM_INST(i)->interface_ptr = NULL;
84 return;
85 case MODEL_INST:
86 (*InterfacePtrDelete)(i,MOD_INST(i)->interface_ptr);
87 MOD_INST(i)->interface_ptr = NULL;
88 break;
89 case REAL_ATOM_INST:
90 (*InterfacePtrDelete)(i,RA_INST(i)->interface_ptr);
91 RA_INST(i)->interface_ptr = NULL;
92 break;
93 case BOOLEAN_ATOM_INST:
94 (*InterfacePtrDelete)(i,BA_INST(i)->interface_ptr);
95 BA_INST(i)->interface_ptr = NULL;
96 break;
97 case INTEGER_ATOM_INST:
98 (*InterfacePtrDelete)(i,IA_INST(i)->interface_ptr);
99 IA_INST(i)->interface_ptr = NULL;
100 break;
101 case SET_ATOM_INST:
102 (*InterfacePtrDelete)(i,SA_INST(i)->interface_ptr);
103 SA_INST(i)->interface_ptr = NULL;
104 break;
105 case SYMBOL_ATOM_INST:
106 (*InterfacePtrDelete)(i,SYMA_INST(i)->interface_ptr);
107 SYMA_INST(i)->interface_ptr = NULL;
108 break;
109 case REL_INST:
110 (*InterfacePtrDelete)(i,RELN_INST(i)->interface_ptr);
111 RELN_INST(i)->interface_ptr = NULL;
112 break;
113 case LREL_INST:
114 (*InterfacePtrDelete)(i,LRELN_INST(i)->interface_ptr);
115 LRELN_INST(i)->interface_ptr = NULL;
116 break;
117 case WHEN_INST:
118 (*InterfacePtrDelete)(i,W_INST(i)->interface_ptr);
119 W_INST(i)->interface_ptr = NULL;
120 break;
121 /* constants */
122 case INTEGER_CONSTANT_INST:
123 (*InterfacePtrDelete)(i,IC_INST(i)->interface_ptr);
124 IC_INST(i)->interface_ptr = NULL;
125 break;
126 case BOOLEAN_CONSTANT_INST:
127 (*InterfacePtrDelete)(i,BC_INST(i)->interface_ptr);
128 BC_INST(i)->interface_ptr = NULL;
129 break;
130 case SYMBOL_CONSTANT_INST:
131 (*InterfacePtrDelete)(i,SYMC_INST(i)->interface_ptr);
132 SYMC_INST(i)->interface_ptr = NULL;
133 break;
134 case DUMMY_INST:
135 (*InterfacePtrDelete)(i,D_INST(i)->interface_ptr);
136 D_INST(i)->interface_ptr = NULL;
137 break;
138 case REAL_CONSTANT_INST: /* fall through */
139 /* arrays */
140 case ARRAY_INT_INST: /* fall through */
141 case ARRAY_ENUM_INST: /* fall through */
142 /* fundies */
143 case REAL_INST: /* fall through */
144 case INTEGER_INST: /* fall through */
145 case BOOLEAN_INST: /* fall through */
146 case SET_INST: /* fall through */
147 case SYMBOL_INST: /* fall through */
148 break;
149 default:
150 ASC_PANIC("Unknown instance type passed to DeleteIPtr.\n");
151 }
152 }
153
154 /**
155 This never returns anything but 1 for DUMMY_INSTs.
156 @return true value if inst should be deleted; otherwise, return 0.
157 */
158 static int RemoveParentReferences(
159 struct Instance *inst, struct Instance *parent
160 ){
161 register unsigned long c,pos,length;
162 AssertMemory(inst);
163 if(parent!=NULL){
164 AssertMemory(parent);
165 /* destroy link from inst to parent */
166 pos = SearchForParent(inst,parent);
167 if(pos != 0 || inst->t == DUMMY_INST){
168 /* Because the dummy always 'adds' a parent, it must always delete it to
169 keep the ref_count happy. Dummy knows of no parents, but knows exactly
170 how many it doesn't have. */
171 DeleteParent(inst,pos);
172 }
173 /* destroy link(s) from parent to inst */
174 while(0 != (pos = ChildIndex(parent,inst))){
175 StoreChildPtr(parent,pos,NULL);
176 }
177 return (NumberParents(inst) == 0);
178 }else{
179 length = NumberParents(inst);
180 if(inst->t == DUMMY_INST){
181 FPRINTF(ASCERR,
182 "The global dummy instance cannot be destroyed w/out parental consent\n"
183 );
184 FPRINTF(ASCERR, "You should not be seeing this message.\n");
185 return 0;
186 }
187 for(c=1;c<=length;c++) {
188 parent = InstanceParent(inst,c);
189 while(0 != (pos = ChildIndex(parent,inst))){
190 StoreChildPtr(parent,pos,NULL);
191 }
192 }
193 return 1;
194 }
195 }
196
197 static void RemoveFromClique(struct Instance *inst){
198 register struct Instance *i,*hold;
199 AssertMemory(inst);
200 if ((hold=i=NextCliqueMember(inst))==inst)
201 return;
202 while (NextCliqueMember(i)!=inst)
203 i = NextCliqueMember(i);
204 switch(i->t) {
205 case MODEL_INST:
206 MOD_INST(i)->alike_ptr = hold;
207 break;
208 case REAL_CONSTANT_INST:
209 RC_INST(i)->alike_ptr = hold;
210 break;
211 case BOOLEAN_CONSTANT_INST:
212 BC_INST(i)->alike_ptr = hold;
213 break;
214 case INTEGER_CONSTANT_INST:
215 IC_INST(i)->alike_ptr = hold;
216 break;
217 case SYMBOL_CONSTANT_INST:
218 SYMC_INST(i)->alike_ptr = hold;
219 break;
220 case REAL_ATOM_INST:
221 RA_INST(i)->alike_ptr = hold;
222 break;
223 case BOOLEAN_ATOM_INST:
224 BA_INST(i)->alike_ptr = hold;
225 break;
226 case INTEGER_ATOM_INST:
227 IA_INST(i)->alike_ptr = hold;
228 break;
229 case SET_ATOM_INST:
230 SA_INST(i)->alike_ptr = hold;
231 break;
232 case SYMBOL_ATOM_INST:
233 SYMA_INST(i)->alike_ptr = hold;
234 break;
235 default:
236 Asc_Panic(2, "RemoveFromClique",
237 "Invalid instance in clique found in RemoveFromClique.\n");
238 }
239 }
240
241 static void DeleteArrayChild(struct ArrayChild *acp, struct Instance *parent){
242 if ((acp!=NULL)&&(acp->inst!=NULL)) {
243 AssertContainedMemory(acp,sizeof(struct ArrayChild));
244 DestroyInstance(acp->inst,parent);
245 }
246 }
247
248 /**
249 Take an ATOM and tell all the relations that know about it to
250 forget it, then destroy the list that identifies those relations.
251 After this, a real ATOM can be safely deleted if there are no models
252 refering to it.
253 */
254 static void RemoveRelationLinks(struct Instance *i){
255 struct gl_list_t *list = RA_INST(i)->relations;
256 if(NULL==list)return;
257 register unsigned long c,length;
258 assert(list!=NULL);
259 length = gl_length(list);
260 for(c=1;c<=length;c++) {
261 CONSOLE_DEBUG("Var %p: remove links to this var in relation %p",i, INST(gl_fetch(list,c)));
262 ChangeRelationPointers(INST(gl_fetch(list,c)),i,INST(NULL));
263 }
264 gl_destroy(list);
265 RA_INST(i)->relations = NULL;
266 }
267
268
269 /**
270 Take a BOOLEAN ATOM, REL or LOGREL and tell all the logrelations that
271 know about them to forget them, then destroy the list that identifies
272 those logrelations.
273 After this, the ATOM, REL or LOGREL can be deleted if there are no
274 models or whens refering to it.
275 */
276 static
277 void RemoveLogRelLinks(struct Instance *i, struct gl_list_t *list)
278 {
279 register unsigned long c,length;
280 assert(list!=NULL);
281 length = gl_length(list);
282 for(c=1;c<=length;c++) {
283 ChangeLogRelPointers(INST(gl_fetch(list,c)),i,INST(NULL));
284 }
285 gl_destroy(list);
286 }
287
288
289 static
290 void RemoveWhenLinks(struct Instance *i, struct gl_list_t *list)
291 {
292 register unsigned long c,length;
293 assert(list!=NULL);
294 length = gl_length(list);
295 for(c=1;c<=length;c++) {
296 ChangeWhenPointers(INST(gl_fetch(list,c)),i,INST(NULL));
297 }
298 gl_destroy(list);
299 }
300
301 static void DestroyAtomChildren(
302 register struct Instance **i, register unsigned long int nc
303 ){
304 while(nc-- > 0){
305 AssertMemory(i);
306 AssertMemory(*i);
307 if ((*i)->t==SET_INST) {
308 if (S_INST(*i)->list!=NULL) {
309 DestroySet(S_INST(*i)->list);
310 }
311 }
312 i++; /* position pointer for next child */
313 }
314 }
315
316 /*
317 should only be called when there areno more references
318 to the object.
319 */
320 static void DestroyInstanceParts(struct Instance *i){
321 register unsigned long c,length;
322 register struct gl_list_t *l;
323 struct Instance *child;
324 AssertMemory(i);
325 switch(i->t) {
326 case SIM_INST:
327 child = InstanceChild(i,1); /* one child only */
328 DestroyInstance(child,i);
329 SIM_INST(i)->name = NULL; /* main symbol table owns the string */
330 SIM_INST(i)->extvars = NULL;
331 i->t = ERROR_INST;
332 DeleteTypeDesc(SIM_INST(i)->desc);
333 SIM_INST(i)->desc = NULL;
334 ascfree((char *)i);
335 return;
336 case MODEL_INST:
337 gl_destroy(MOD_INST(i)->parents);
338 MOD_INST(i)->parents = NULL;
339 MOD_INST(i)->alike_ptr = NULL;
340 if (MOD_INST(i)->whens!=NULL) {
341 RemoveWhenLinks(i,MOD_INST(i)->whens);
342 MOD_INST(i)->whens=NULL;
343 }
344 DestroyBList(MOD_INST(i)->executed);
345 MOD_INST(i)->executed = NULL;
346 /* destroy reference to children */
347 length = NumberChildren(i);
348 for(c=1;c<=length;c++) {
349 child = InstanceChild(i,c);
350 DestroyInstance(child,i);
351 }
352 i->t = ERROR_INST;
353 DeleteTypeDesc(MOD_INST(i)->desc);
354 MOD_INST(i)->desc = NULL;
355 gl_destroy(MOD_INST(i)->link_table);
356 ascfree((char *)i);
357 return;
358 case REAL_CONSTANT_INST:
359 /* continue delete the atom */
360 gl_destroy(RC_INST(i)->parents);
361 RC_INST(i)->parents = NULL;
362 DeleteTypeDesc(RC_INST(i)->desc);
363 RC_INST(i)->desc = NULL;
364 RC_INST(i)->alike_ptr = NULL;
365 /* children are automatically deleted by the following */
366 i->t = ERROR_INST;
367 ascfree((char *)i);
368 return;
369 case BOOLEAN_CONSTANT_INST:
370 gl_destroy(BC_INST(i)->parents);
371 BC_INST(i)->parents = NULL;
372 DeleteTypeDesc(BC_INST(i)->desc);
373 BC_INST(i)->desc = NULL;
374 BC_INST(i)->alike_ptr = NULL;
375 if (BC_INST(i)->whens!=NULL) {
376 RemoveWhenLinks(i,BC_INST(i)->whens);
377 BC_INST(i)->whens=NULL;
378 }
379 i->t = ERROR_INST;
380 ascfree((char *)i);
381 return;
382 case INTEGER_CONSTANT_INST:
383 gl_destroy(IC_INST(i)->parents);
384 IC_INST(i)->parents = NULL;
385 DeleteTypeDesc(IC_INST(i)->desc);
386 IC_INST(i)->desc = NULL;
387 IC_INST(i)->alike_ptr = NULL;
388 if (IC_INST(i)->whens!=NULL) {
389 RemoveWhenLinks(i,IC_INST(i)->whens);
390 IC_INST(i)->whens=NULL;
391 }
392 i->t = ERROR_INST;
393 ascfree((char *)i);
394 return;
395 case SYMBOL_CONSTANT_INST:
396 gl_destroy(SYMC_INST(i)->parents);
397 SYMC_INST(i)->parents = NULL;
398 DeleteTypeDesc(SYMC_INST(i)->desc);
399 SYMC_INST(i)->desc = NULL;
400 SYMC_INST(i)->alike_ptr = NULL;
401 SYMC_INST(i)->value = NULL;
402 if (SYMC_INST(i)->whens!=NULL) {
403 RemoveWhenLinks(i,SYMC_INST(i)->whens);
404 SYMC_INST(i)->whens=NULL;
405 }
406 i->t = ERROR_INST;
407 ascfree((char *)i);
408 return;
409 case REAL_ATOM_INST:
410 CONSOLE_DEBUG("Removing parts of var %p",i);
411 /* deallocate dynamic memory used by children */
412 DestroyAtomChildren(RA_CHILD(i,0),ChildListLen(GetChildList(RA_INST(i)->desc)));
413 /* continue delete the atom */
414 gl_destroy(RA_INST(i)->parents);
415 RA_INST(i)->parents = NULL;
416 DeleteTypeDesc(RA_INST(i)->desc);
417 RA_INST(i)->desc = NULL;
418 RA_INST(i)->alike_ptr = NULL;
419 RemoveRelationLinks(i);
420 /* children are automatically deleted by the following ---- EH??? how does that work? -JP */
421 i->t = ERROR_INST;
422 ascfree((char *)i);
423 return;
424 case BOOLEAN_ATOM_INST:
425 /* deallocate dynamic memory used by children */
426 DestroyAtomChildren(BA_CHILD(i,0),
427 ChildListLen(GetChildList(BA_INST(i)->desc)));
428 /* continue delete the atom */
429 gl_destroy(BA_INST(i)->parents);
430 BA_INST(i)->parents = NULL;
431 DeleteTypeDesc(BA_INST(i)->desc);
432 BA_INST(i)->desc = NULL;
433 BA_INST(i)->alike_ptr = NULL;
434 if (BA_INST(i)->logrelations!=NULL)
435 RemoveLogRelLinks(i,BA_INST(i)->logrelations);
436 if (BA_INST(i)->whens!=NULL) {
437 RemoveWhenLinks(i,BA_INST(i)->whens);
438 BA_INST(i)->whens=NULL;
439 }
440 i->t = ERROR_INST;
441 /* children are automatically deleted by the following */
442 ascfree((char *)i);
443 return;
444 case INTEGER_ATOM_INST:
445 /* deallocate dynamic memory used by children */
446 DestroyAtomChildren(IA_CHILD(i,0),
447 ChildListLen(GetChildList(IA_INST(i)->desc)));
448 /* continue delete the atom */
449 gl_destroy(IA_INST(i)->parents);
450 IA_INST(i)->parents = NULL;
451 DeleteTypeDesc(IA_INST(i)->desc);
452 IA_INST(i)->desc = NULL;
453 IA_INST(i)->alike_ptr = NULL;
454 if (IA_INST(i)->whens!=NULL) {
455 RemoveWhenLinks(i,IA_INST(i)->whens);
456 IA_INST(i)->whens=NULL;
457 }
458 i->t = ERROR_INST;
459 /* children are automatically deleted by the following */
460 ascfree((char *)i);
461 return;
462 case SET_ATOM_INST:
463 /* deallocate dynamic memory used by children */
464 DestroyAtomChildren(SA_CHILD(i,0),
465 ChildListLen(GetChildList(SA_INST(i)->desc)));
466 /* continue delete the atom */
467 gl_destroy(SA_INST(i)->parents);
468 SA_INST(i)->parents = NULL;
469 DeleteTypeDesc(SA_INST(i)->desc);
470 SA_INST(i)->desc = NULL;
471 SA_INST(i)->alike_ptr = NULL;
472 if (SA_INST(i)->list != NULL)
473 DestroySet(SA_INST(i)->list);
474 i->t = ERROR_INST;
475 ascfree((char *)i);
476 return;
477 case SYMBOL_ATOM_INST:
478 /* deallocate dynamic memory used by children */
479 DestroyAtomChildren(SYMA_CHILD(i,0),
480 ChildListLen(GetChildList(SYMA_INST(i)->desc)));
481 /* continue to delete the atom */
482 gl_destroy(SYMA_INST(i)->parents);
483 SYMA_INST(i)->parents = NULL;
484 DeleteTypeDesc(SYMA_INST(i)->desc);
485 SYMA_INST(i)->desc = NULL;
486 SYMA_INST(i)->alike_ptr = NULL;
487 if (SYMA_INST(i)->whens!=NULL) {
488 RemoveWhenLinks(i,SYMA_INST(i)->whens);
489 SYMA_INST(i)->whens = NULL;
490 }
491 SYMA_INST(i)->value = NULL;
492 i->t = ERROR_INST;
493 ascfree((char *)i);
494 return;
495 case REL_INST:
496 CONSOLE_DEBUG("Removing parts of rel %p",i);
497 /* deallocate dynamic memory used by children */
498 DestroyAtomChildren(REL_CHILD(i,0),
499 ChildListLen(GetChildList(RELN_INST(i)->desc)));
500 /* continue deleting the relation */
501 DeleteTypeDesc(RELN_INST(i)->desc);
502 RELN_INST(i)->desc = NULL;
503 RELN_INST(i)->parent[0] = NULL;
504 RELN_INST(i)->parent[1] = NULL;
505 if (RELN_INST(i)->logrels!=NULL) {
506 RemoveLogRelLinks(i,RELN_INST(i)->logrels);
507 RELN_INST(i)->logrels=NULL;
508 }
509 if (RELN_INST(i)->whens!=NULL) {
510 RemoveWhenLinks(i,RELN_INST(i)->whens);
511 RELN_INST(i)->whens=NULL;
512 }
513 /* delete references of reals to this expression */
514 if(RELN_INST(i)->ptr != NULL){
515 CONSOLE_DEBUG("Destroying links to relation %p",i);
516 DestroyRelation(RELN_INST(i)->ptr,i);
517 RELN_INST(i)->ptr = NULL;
518 }
519 /* after relation has been destroyed */
520 if(RELN_INST(i)->ptr != NULL){
521 ERROR_REPORTER_HERE(ASC_PROG_ERR,"Rel ptr not null where expected");
522 }
523 i->t = ERROR_INST;
524 ascfree((char *)i);
525 return;
526 case LREL_INST:
527 DestroyAtomChildren(LREL_CHILD(i,0),
528 ChildListLen(GetChildList(LRELN_INST(i)->desc)));
529 DeleteTypeDesc(LRELN_INST(i)->desc);
530 LRELN_INST(i)->desc = NULL;
531 LRELN_INST(i)->parent[0] = NULL;
532 LRELN_INST(i)->parent[1] = NULL;
533 if (LRELN_INST(i)->logrels!=NULL) {
534 RemoveLogRelLinks(i,LRELN_INST(i)->logrels);
535 LRELN_INST(i)->logrels=NULL;
536 }
537 if (LRELN_INST(i)->whens!=NULL) {
538 RemoveWhenLinks(i,LRELN_INST(i)->whens);
539 LRELN_INST(i)->whens=NULL;
540 }
541 if (LRELN_INST(i)->ptr != NULL){
542 DestroyLogRelation(LRELN_INST(i)->ptr,i);
543 LRELN_INST(i)->ptr = NULL;
544 }
545 LRELN_INST(i)->ptr = NULL;
546 i->t = ERROR_INST;
547 ascfree((char *)i);
548 return;
549 case WHEN_INST:
550 DeleteTypeDesc(W_INST(i)->desc);
551 W_INST(i)->desc = NULL;
552 W_INST(i)->parent[0] = NULL;
553 W_INST(i)->parent[1] = NULL;
554 if (W_INST(i)->whens!=NULL) {
555 RemoveWhenLinks(i,W_INST(i)->whens);
556 W_INST(i)->whens=NULL;
557 }
558 if (W_INST(i)->bvar!=NULL) {
559 DestroyWhenVarList(W_INST(i)->bvar,i);
560 W_INST(i)->bvar = NULL;
561 }
562 if (W_INST(i)->cases!=NULL) {
563 DestroyWhenCaseList(W_INST(i)->cases,i);
564 W_INST(i)->cases = NULL;
565 }
566 i->t = ERROR_INST;
567 ascfree((char *)i);
568 return;
569 case ARRAY_INT_INST:
570 case ARRAY_ENUM_INST:
571 DeleteTypeDesc(ARY_INST(i)->desc);
572 gl_destroy(ARY_INST(i)->parents);
573 ARY_INST(i)->parents = NULL;
574 l = ARY_INST(i)->children;
575 if (l!=NULL){
576 length = gl_length(l);
577 for (c=1; c <= length; c++) {
578 DeleteArrayChild((struct ArrayChild *)gl_fetch(l,c),i);
579 FREEPOOLAC(gl_fetch(l,c));
580 }
581 gl_destroy(l);
582 }
583 ARY_INST(i)->children = NULL;
584 i->t = ERROR_INST;
585 ascfree((char *)i);
586 return;
587 case REAL_INST:
588 i->t = ERROR_INST;
589 return;
590 case INTEGER_INST:
591 i->t = ERROR_INST;
592 return;
593 case BOOLEAN_INST:
594 i->t = ERROR_INST;
595 return;
596 case SET_INST:
597 if (S_INST(i)->list!=NULL)
598 DestroySet(S_INST(i)->list);
599 i->t = ERROR_INST;
600 return;
601 case SYMBOL_INST:
602 i->t = ERROR_INST;
603 return;
604 case DUMMY_INST:
605 /* no parts */
606 DeleteTypeDesc(D_INST(i)->desc);
607 i->t = ERROR_INST;
608 ascfree((char *)i);
609 return;
610 default:
611 Asc_Panic(2, "DeleteInstance",
612 "Unknown type of instance passed to DeleteInstance.\n");
613 }
614 }
615
616 void DestroyInstance(struct Instance *inst, struct Instance *parent){
617 struct TypeDescription *desc;
618 int delete;
619 if(inst==NULL) return;
620
621 if(InterfacePtrDelete!=NULL){
622 DeleteIPtr(inst);
623 }
624 delete = RemoveParentReferences(inst,parent);
625 if(delete){
626 if (inst->t != DUMMY_INST){
627 desc = InstanceTypeDesc(inst);
628 if(GetUniversalFlag(desc)){ /* universal is being deleted */
629 RemoveUniversalInstance(GetUniversalTable(),inst);
630 }
631 if(IsCompoundInstance(inst) &&
632 InstanceKind(inst) != SIM_INST &&
633 ((struct PendInstance *)(inst))->p != NULL
634 ){
635 // remove instance from the pending list, if such exists
636 RemoveInstance(inst);
637 }
638 /* remove PENDING or maybe not pending instance in destroy process. */
639 RemoveFromClique(inst);
640 DestroyInstanceParts(inst);
641 }else{
642 if(D_INST(inst)->ref_count<2){
643 desc = InstanceTypeDesc(inst);
644 if(GetUniversalFlag(desc)){ /* universal is being deleted */
645 RemoveUniversalInstance(GetUniversalTable(),inst);
646 }
647 /* dummy is never in cliques or pending */
648 DestroyInstanceParts(inst);
649 }
650 }
651 }
652 }
653

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22