![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree_walk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to tree_walk.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /* -*- Mode: C -*- */
2: /*
3: $Source: /usr3/lang/benson/work/stripped_cfront/RCS/tree_walk.c,v $ $RCSfile: tree_walk.c,v $
4: $Revision: 1.1 $ $Date: 89/11/20 08:51:06 $
5: $Author: benson $ $Locker: $
6: $State: Exp $
7: */
8:
9: /* Utilities for tree-walking */
10:
11: #include "cfront.h"
12: #include "tree_walk.H"
13: #include <stdarg.h>
14: #include "hash.h"
15: // #include <alloca.h>
16: // need to add an explicit call of free
17: #include <streamdefs.h>
18: #include <malloc.h>
19:
20: class walker {
21: tree_walk_control control;
22: Pnode orig_addr;
23: Hash *nodes_seen_hash;
24: int depth;
25: int made_ht;
26: tree_walk_tree * cur_tree;
27: public:
28: walker(tree_walk_control& c) ;
29:
30: ~walker () {
31: if(made_ht) delete nodes_seen_hash;
32: }
33: tree_node_action walk (Pnode&);
34: tree_node_action walk_ (Pnode& n)
35: {
36: if(n) {
37: int save_depth = depth;
38: tree_walk_tree * save_cur_tree = cur_tree;
39:
40: depth ++;
41: if(control.alloc_stack_bytes) {
42: cur_tree = (tree_walk_tree *)
43: // alloca (control.alloc_stack_bytes + sizeof (tree_walk_tree));
44: malloc(control.alloc_stack_bytes + sizeof (tree_walk_tree));
45: cur_tree->parent = save_cur_tree;
46: }
47: tree_node_action r = walk(n);
48: depth = save_depth;
49: return r;
50: } else return tna_continue;
51: }
52:
53: tree_node_action walk(Pgen& n)
54: { return walk_ ((struct node * &)n); };
55: tree_node_action walk(Pvec& n)
56: { return walk_ ((struct node * &)n); };
57: tree_node_action walk(Pptr& n)
58: { return walk_ ((struct node * &)n); };
59: tree_node_action walk(Ptype& n)
60: { return walk_ ((struct node * &)n); };
61: tree_node_action walk(Pfct& n)
62: { return walk_ ((struct node * &)n); };
63: tree_node_action walk(Ptable& n)
64: { return walk_ ((struct node * &)n); };
65: tree_node_action walk(Pbase& n)
66: { return walk_ ((struct node * &)n); };
67: tree_node_action walk(Pname& n)
68: { return walk_ ((struct node * &)n); };
69: tree_node_action walk(Pexpr& n)
70: { return walk_ ((struct node * &)n); };
71: tree_node_action walk(Pstmt& n)
72: { return walk_ ((struct node * &)n); };
73: tree_node_action walk(Pblock& n)
74: { return walk_ ((struct node * &)n); };
75: tree_node_action walk(Penum& n)
76: { return walk_ ((struct node * &)n); };
77: tree_node_action walk(Pclass& n)
78: { return walk_ ((struct node * &)n); };
79: tree_node_action walk(Pvirt& n)
80: { return walk_ ((struct node * &)n); };
81: tree_node_action walk(Plist& n)
82: { return walk_ ((struct node * &)n); };
83: tree_node_action walk(Pin& n)
84: { return walk_ ((struct node * &)n); };
85: tree_node_action walk(struct ia * & n)
86: { return walk_ ((struct node * &)n); };
87: tree_node_action walk(Pbcl& n)
88: { return walk_ ((struct node * &)n); };
89: private:
90: int fetching () { return (control.fetcher != null_tfp); } ;
91: void free_fetched (void *);
92: int fetch (void *, unsigned long, void *&);
93: int fetch (void * a, unsigned long l, Pnode& p)
94: {
95: int ret;
96: void * t; /* this is an output argument */
97: ret = fetch(a,l,t);
98: if(!ret) {
99: p = Pnode(t);
100: }
101: return ret;
102: };
103: // void error (const char *,...); ?? at&t -- to get it up quick, line 155
104: void error ( char *, unsigned long=0 );
105: tree_node_action pre_act_on_node (Pnode node, node_class nc,
106: Pnode node_copy, Pnode& replacement);
107:
108: tree_node_action a_gen (Pnode, Pgen, Pnode&);
109: tree_node_action a_vec (Pnode, Pvec, Pnode&);
110: tree_node_action a_ptr (Pnode, Pptr, Pnode&);
111: tree_node_action a_fct (Pnode, Pfct, Pnode&);
112: tree_node_action a_table (Pnode, Ptable, Pnode&);
113: tree_node_action a_basetype (Pnode, Pbase, Pnode&);
114: tree_node_action a_name(Pnode, Pname, Pnode&);
115: tree_node_action a_expr (Pnode, Pexpr, Pnode&);
116: tree_node_action a_stmt (Pnode, Pstmt, Pnode&);
117: tree_node_action a_enumdef (Pnode, Penum, Pnode&);
118: tree_node_action a_classdef (Pnode, Pclass, Pnode&);
119: tree_node_action a_virt (Pnode, Pvirt, Pnode&);
120: tree_node_action a_name_list (Pnode, Plist, Pnode&);
121: tree_node_action a_iline (Pnode, Pin, Pnode&);
122: tree_node_action a_ia (Pnode, struct ia *, Pnode&);
123: tree_node_action a_baseclass (Pnode, Pbcl, Pnode&);
124: tree_node_action a_expr_guts (Pexpr);
125: };
126:
127:
128: walker::walker(tree_walk_control& c)
129: { control = c;
130: made_ht = 0;
131: if (c.nodes_seen_hash)
132: nodes_seen_hash = c.nodes_seen_hash;
133: else {
134: nodes_seen_hash = new pointer_hash (100);
135: made_ht = 1;
136: }
137: depth = 0;
138: cur_tree = 0;
139: }
140:
141:
142: tree_node_action
143: walk_tree (tree_walk_control& c, Pnode& n)
144: {
145: walker w (c);
146: return w.walk(n);
147: }
148:
149:
150: /* error messages are of finite length, so no need to run
151: around mallocing strings */
152:
153: // void walker::error (const char * format, ...)
154: void walker::error (char *format, unsigned long v)
155: {
156: va_list args;
157: va_start(args, format);
158: if(control.call_i_error) {
159: char buf[1000];
160: // vsprintf(buf, format, args);
161: // vsprintf not universal: by inspection
162: // all calls are currently of 1 or 0 arguments
163: sprintf(buf, format, v);
164: (*control.i_error)('i', buf);
165: } else {
166: vostream_printf (format, args, *control.error_stream);
167: *control.error_stream << "\n";
168: control.error_stream->flush();
169: }
170: va_end (args);
171: }
172:
173:
174: void
175: walker::free_fetched (void * addr)
176: {
177: if (control.fetcher != null_tfp) /* null indicates no cross-address-space */
178: free ((char *)addr);
179: }
180:
181: int
182: walker::fetch (void * addr, unsigned long length, void*& taddr)
183: {
184: int err;
185:
186: if (control.fetcher == null_tfp) {
187: taddr = addr;
188: return 0;
189: } else {
190: taddr = (void *)malloc ((unsigned int)length);
191: if(taddr == 0) {
192: error ("walker::fetch: failed to malloc %d bytes.", length);
193: return 1;
194: }
195:
196: err = (*control.fetcher) (control.callback_info, addr, length, 0, taddr);
197: if(err) {
198: error("walker::fetch: fetcher returned %d.", err);
199: return 1;
200: }
201: }
202: }
203:
204: /* ::walk is called with a node pointer and a reference to
205: a replacement node pointer. When it returns,
206: replacement will be set if the action procedure
207: called on the node decided to copy it or replace it.
208: There are two possible modularities.
209: In case there is cross-address-space action,
210: ::walk can't call the action procedure until it has
211: entered the case on node bases. Once it has,
212: it calls the per-structure-type procedure,
213: which calls the action proc. If the action
214: proc supplies a replacement, then that replacement
215: will be returned up via the reference parameters to
216: the per-structure procedures.
217:
218: It the action procedure returns tna_continue,
219: then the walk continues against the new copy of the node
220: so that further replacements are reflected in the new copies.
221: This prevents replacement from being meaningful cross-address-space,
222: since the new copy will presumably be in the current
223: (and not the cross) address space. That is, if the node
224: is replaced by the action proc, the pointers in the new
225: node will drive the subsequent tree walk. Usually one
226: would just bitcopy, and then they would be replaced in turn.
227: */
228:
229: tree_node_action
230: walker::walk (Pnode& top)
231: {
232: Pnode replacement = 0;
233: tree_node_action err;
234: int class_err;
235: node_class nclass;
236: Pnode node = 0; /* assign to shut up compiler,
237: which dosen't recognize pass-by-reference as a set */
238:
239: orig_addr = top;
240:
241: if(fetching ()) {
242: if(fetch((void *)top, sizeof (struct node), node))
243: return tna_error;
244: } else node = top;
245:
246: /* This has a complete catalog of bases, rather than just a list
247: of those associated with data structures. Its important
248: to detect the errs.
249: */
250:
251: nclass = classify_node (node, class_err);
252:
253: if(class_err) {
254: error("walker::walk: unknown node type %d.", node->base);
255: free_fetched ((void *)node);
256: err = tna_error;
257: goto Return;
258: }
259:
260: switch(nclass)
261: {
262: default:
263: case nc_unused:
264: error("walker::walk: unused node type %d.", node->base);
265: err = tna_error;
266: goto Return;
267:
268: case nc_eof:
269: break;
270:
271: case nc_virt:
272: fetch((void *)top, sizeof (struct virt), node);
273: err = a_virt(top, Pvirt (node), replacement);
274: break;
275:
276: case nc_nlist:
277: fetch((void *)top, sizeof (struct name_list), node);
278: err = a_name_list(top, (struct name_list *)node, replacement);
279: break;
280:
281: case nc_iline:
282: fetch((void *)top, sizeof (struct iline), node);
283: err = a_iline(top, (struct iline *)node, replacement);
284: break;
285:
286: case nc_gen:
287: fetch((void *)top, sizeof (struct gen), node);
288: err = a_gen(top, Pgen (node), replacement);
289: break;
290:
291: case nc_vec:
292: fetch((void *)top, sizeof (struct vec), node);
293: err = a_vec(top, Pvec(node), replacement);
294: break;
295:
296: case nc_ptr:
297: fetch((void *)top, sizeof (struct ptr), node);
298: err = a_ptr(top, Pptr(node), replacement);
299: break;
300:
301: case nc_fct:
302: fetch((void *)top, sizeof (struct fct), node);
303: err = a_fct(top, Pfct(node), replacement);
304: break;
305:
306: case nc_table:
307: fetch((void *)top, sizeof (struct table), node);
308: err = a_table(top, Ptable(node), replacement);
309: break;
310:
311: case nc_basetype:
312: fetch((void *)top, sizeof (struct basetype), node);
313: err = a_basetype(top, Pbase(node), replacement);
314: break;
315:
316: case nc_name:
317: fetch((void *)top, sizeof (struct name), node);
318: err = a_name(top, Pname(node), replacement);
319: break;
320:
321: case nc_expr:
322: fetch((void *)top, sizeof (struct expr), node);
323: err = a_expr(top, Pexpr(node), replacement);
324: break;
325:
326: case nc_stmt:
327: fetch((void *)top, sizeof (struct stmt), node);
328: err = a_stmt(top, Pstmt(node), replacement);
329: break;
330:
331: case nc_enumdef:
332: fetch((void *)top, sizeof (struct enumdef), node);
333: err = a_enumdef(top, Penum(node), replacement);
334: break;
335:
336: case nc_classdef:
337: fetch((void *)top, sizeof (struct classdef), node);
338: err = a_classdef(top, Pclass(node), replacement);
339: break;
340:
341: case nc_ia:
342: fetch((void *)top, sizeof (struct ia), node);
343: err = a_ia(top, (struct ia *)node, replacement);
344: break;
345:
346: case nc_baseclass:
347: fetch((void *)top, sizeof (struct basecl), node);
348: err = a_baseclass(top, Pbcl(node), replacement);
349: break;
350:
351: }
352:
353: if(replacement) {
354: if (fetching ()) {
355: error
356: ("walker::walk: Attempt to replace tree in cross-address space mode.");
357: err = tna_error;
358: }
359: else top = replacement;
360: }
361:
362: if (control.post_action_proc && err != tna_error) {
363: tree_node_action post_err;
364: Pnode& post_repl = node;
365:
366: (*control.post_action_proc) (post_repl, nclass, control.callback_info, post_err,
367: depth, orig_addr, *cur_tree);
368: if(post_err != tna_continue) err = post_err;
369: if(post_repl != node) {
370: if (fetching ()) {
371: error
372: ("walker::walk: Attempt to replace tree in cross-address space mode.");
373: err = tna_error;
374: }
375: else top = post_repl;
376: }
377: }
378:
379: free_fetched((void *) node);
380:
381: Return:
382: return err;
383: }
384:
385: /* This is called in pre-order for each node. Then
386: post_act_on_node is called after whatever recursive
387: processing ensues.
388:
389: This is called from each of the structure-specific procedures
390: to give the action procedure an opportunity to act.
391: It can return a replacement pointer and control
392: whether to examine the insides of the node.
393: */
394:
395: tree_node_action
396: walker::pre_act_on_node (Pnode node, node_class nc,
397: Pnode node_copy, Pnode& replacement)
398: {
399: /* If we have been here before, then we never proceed */
400: /* node_copy is != node when a fetcher is in use */
401:
402: int found;
403: int old_node;
404: tree_node_action action;
405: Pnode new_node;
406: int register_in_hash = 1;
407:
408: nodes_seen_hash->action((int)node, 0, Hash::probe, found, old_node);
409:
410: if(found) {
411: new_node = Pnode(old_node);
412: if(new_node != node) replacement = new_node;
413: return tna_stop; /* no need to proceed */
414: }
415:
416: /* OK, we don't know from a previous pass. Call our actor */
417:
418: new_node = fetching () && node_copy ? node_copy : node;
419:
420: (*control.action_proc)(new_node, nc, control.callback_info, action,
421: depth, orig_addr, *cur_tree,
422: register_in_hash);
423:
424: if(action != tna_error && !fetching () && new_node != node) {
425: replacement = new_node;
426: if(register_in_hash)
427: nodes_seen_hash->action((int)node,
428: (int)new_node,
429: Hash::insert, 0, 0);
430: }
431: else {
432: if(register_in_hash)
433: nodes_seen_hash->action((int)node, (int) node, Hash::insert, 0, 0);
434: }
435: return action;
436: }
437:
438: tree_node_action walker::a_table(Pnode ta, Ptable t, Pnode& replacement)
439: {
440: /* no unions */
441:
442: int nx;
443: tree_node_action action;
444:
445: action = pre_act_on_node(ta, nc_table, Pnode(t), replacement);
446:
447: if(action != tna_continue) return action;
448:
449: /* -----------------------------*/
450: /* For Now, Never Walk a Table. */
451:
452: action = tna_stop; return action;
453:
454: /* an array of pointers. */
455: /* The action procedure is responsable for allocating a new one
456: of those if it replaced and continued. */
457:
458: if(!fetching () && replacement)
459: t = Ptable(replacement);
460:
461: Pname * t_entries;
462:
463: if(fetching ()) {
464: void * temp;
465: fetch((void *)t->entries, t->size * sizeof(Pname), temp);
466: t_entries = (Pname *)temp;
467: }
468: else t_entries = t->entries;
469:
470: for(nx = 0; nx < t->size; nx ++) {
471: action = walk(t_entries[nx]);
472: if(action == tna_error) return action;
473: }
474:
475: if(fetching ()) free_fetched ((void *)t_entries);
476:
477: Pnode n = Pnode(t->real_block);
478:
479: action = walk(t->real_block);
480: if(action == tna_error) return action;
481:
482: action = walk(t->next);
483:
484: action = walk(t->t_name);
485:
486: return tna_continue;
487: }
488:
489: tree_node_action walker::a_enumdef (Pnode ta, Penum e, Pnode& replacement)
490: {
491: tree_node_action action = pre_act_on_node(ta, nc_enumdef, Pnode(e), replacement);
492:
493: action = walk(e->mem);
494: if(action == tna_error) return action;
495:
496: action = walk(e->e_type);
497:
498: return tna_continue;
499: }
500:
501: tree_node_action walker::a_virt(Pnode ta, Pvirt v, Pnode& replacement)
502: {
503: /* no unions */
504:
505: int nx;
506: tree_node_action action = pre_act_on_node(ta, nc_enumdef, Pnode(v), replacement);
507:
508: if(action != tna_continue) return action;
509:
510: if(!fetching () && replacement)
511: v = Pvirt(replacement);
512:
513: /* an array of velem structures. */
514:
515: velem * v_virt_init;
516:
517: if(fetching ()) {
518: void * t;
519: fetch((void *)v->virt_init, v->n_init * sizeof(velem), t);
520: v_virt_init = (velem *)t;
521: }
522: else v_virt_init = v->virt_init;
523:
524: for(nx = 0; nx < v->n_init; nx ++) {
525: action = walk(v_virt_init[nx].n);
526: if(action == tna_error) return action;
527: }
528:
529: if(fetching ()) free_fetched ((void *)v_virt_init);
530:
531: action = walk(v->vclass);
532:
533: return tna_continue;
534: }
535:
536: tree_node_action walker::a_classdef(Pnode ta, Pclass c, Pnode& replacement)
537: {
538:
539: tree_node_action action = pre_act_on_node(ta, nc_classdef, Pnode(c), replacement);
540:
541: if(action != tna_continue) return action;
542:
543: if(!fetching () && replacement)
544: c = Pclass(replacement);
545:
546: action = walk(c->baselist);
547: if(action == tna_error) return action;
548:
549: action=walk(c->mem_list);
550: if(action == tna_error) return action;
551:
552: action=walk(c->memtbl);
553: if(action == tna_error) return action;
554:
555: action=walk(c->friend_list);
556: if(action == tna_error) return action;
557:
558: action=walk(c->pubdef);
559: if(action == tna_error) return action;
560:
561: action=walk(c->tn_list);
562: if(action == tna_error) return action;
563:
564: action=walk(c->in_class);
565: if(action == tna_error) return action;
566:
567: action=walk(c->in_fct);
568: if(action == tna_error) return action;
569:
570: action=walk(c->this_type);
571: if(action == tna_error) return action;
572:
573: action=walk(c->virt_list);
574: if(action == tna_error) return action;
575:
576: action=walk(c->c_ctor);
577: if(action == tna_error) return action;
578: action=walk(c->c_dtor);
579: if(action == tna_error) return action;
580: action=walk(c->c_itor);
581: if(action == tna_error) return action;
582:
583: action=walk(c->conv);
584: if(action == tna_error) return action;
585:
586: return tna_continue;
587: }
588:
589: tree_node_action walker::a_basetype(Pnode ta, Pbase b, Pnode& replacement)
590: {
591:
592: tree_node_action action = pre_act_on_node(ta, nc_basetype, Pnode(b), replacement);
593: int derr;
594:
595: if(action != tna_continue) return action;
596:
597: if(!fetching () && replacement)
598: b = Pbase(replacement);
599:
600: action = walk(b->b_name);
601: if(action == tna_error) return action;
602:
603: action = walk(b->b_table);
604: if(action == tna_error) return action;
605:
606: action = walk(b->b_field);
607: if(action == tna_error) return action;
608:
609: action = walk(b->b_xname);
610: if(action == tna_error) return action;
611:
612: switch(derr = b->discriminator(0)) {
613: case 0: break;
614: case 1:
615: action = walk(b->b_fieldtype);
616: if(action == tna_error) return action;
617: break;
618: case 2: break;
619: default:
620: error ("a_basetype: discrim error %d.", derr);
621: return tna_error;
622: }
623:
624: return tna_continue;
625: }
626:
627: tree_node_action walker::a_fct(Pnode ta, Pfct f, Pnode& replacement)
628: {
629:
630: tree_node_action action = pre_act_on_node(ta, nc_fct, Pnode(f), replacement);
631:
632: if(action != tna_continue) return action;
633:
634: if(!fetching () && replacement)
635: f = Pfct(replacement);
636:
637: action = walk(f->returns);
638: if(action == tna_error) return action;
639:
640: action = walk(f->argtype);
641: if(action == tna_error) return action;
642:
643: action = walk(f->s_returns);
644: if(action == tna_error) return action;
645:
646: action = walk(f->f_this);
647: if(action == tna_error) return action;
648:
649: action = walk(f->memof);
650: if(action == tna_error) return action;
651:
652: action = walk(f->body);
653: if(action == tna_error) return action;
654:
655: action = walk(f->f_init);
656: if(action == tna_error) return action;
657:
658: action = walk(f->f_expr);
659: if(action == tna_error) return action;
660:
661: action = walk(f->last_expanded);
662: if(action == tna_error) return action;
663:
664: action = walk(f->f_result);
665: if(action == tna_error) return action;
666:
667: action = walk(f->f_args);
668: if(action == tna_error) return action;
669:
670: return tna_continue;
671: }
672:
673: tree_node_action walker::a_name_list(Pnode ta, Plist l, Pnode& replacement)
674: {
675:
676: int cl_error;
677: tree_node_action action = pre_act_on_node(ta, nc_nlist, Pnode(l), replacement);
678:
679: if(action == tna_stop) {
680: if(!fetching () && replacement)
681: l = Plist(replacement);
682: cl_error = 0;
683: if((classify_node(Pnode(l), cl_error) == nc_nlist) && !cl_error) {
684: action = walk(l->l);
685: if(action == tna_error) return action;
686: }
687: }
688:
689: if(action != tna_continue) return action;
690:
691: if(!fetching () && replacement)
692: l = Plist(replacement);
693:
694: action = walk(l->f);
695: if(action == tna_error) return action;
696:
697: action = walk(l->l);
698: if(action == tna_error) return action;
699:
700: return tna_continue;
701: }
702:
703: tree_node_action walker::a_gen(Pnode ta, Pgen g, Pnode& replacement)
704: {
705:
706: tree_node_action action = pre_act_on_node(ta, nc_gen, Pnode(g), replacement);
707:
708: if(action != tna_continue) return action;
709:
710: if(!fetching () && replacement)
711: g = Pgen(replacement);
712:
713: action = walk(g->fct_list);
714: if(action == tna_error) return action;
715:
716: return tna_continue;
717: }
718:
719: tree_node_action walker::a_vec(Pnode ta, Pvec v, Pnode& replacement)
720: {
721:
722: tree_node_action action = pre_act_on_node(ta, nc_vec, Pnode(v), replacement);
723:
724: if(action != tna_continue) return action;
725:
726: if(!fetching () && replacement)
727: v = Pvec(replacement);
728:
729: action = walk(v->typ);
730: if(action == tna_error) return action;
731:
732: action = walk(v->dim);
733: if(action == tna_error) return action;
734:
735: return tna_continue;
736: }
737:
738: tree_node_action walker::a_ptr(Pnode ta, Pptr p, Pnode& replacement)
739: {
740:
741: tree_node_action action = pre_act_on_node(ta, nc_ptr, Pnode(p), replacement);
742:
743: if(action != tna_continue) return action;
744:
745: if(!fetching () && replacement)
746: p = Pptr(replacement);
747:
748: action = walk(p->typ);
749: if(action == tna_error) return action;
750:
751: action = walk(p->memof);
752: if(action == tna_error) return action;
753:
754: return tna_continue;
755: }
756:
757:
758: tree_node_action walker::a_expr_guts(Pexpr e)
759: {
760: int derr;
761: tree_node_action action;
762:
763: switch(derr = e->discriminator (0)) {
764: case 1:
765: action = walk(e->tp);
766: if(action == tna_error) return action;
767: break;
768: case 0:
769: break;
770: default:
771: error ("a_expr: discrim error %d on union 0.", derr);
772: return tna_error;
773: }
774:
775: switch(derr = e->discriminator (1)) {
776: case 0:
777: break;
778: default:
779: error ("a_expr: discrim error %d on union 1.", derr);
780: return tna_error;
781: case 1:
782: action = walk(e->e1);
783: if(action == tna_error) return action;
784: break;
785: case 2:
786: break;
787: case 3:
788: break;
789: }
790:
791: switch(derr = e->discriminator (2)) {
792: case 0:
793: break;
794: default:
795: error ("a_expr: discrim error %d on union 2.", derr);
796: return tna_error;
797: case 1:
798: /* elists are special. e2 for an elist is a peer, not
799: a child. */
800: if(e->base != ELIST) {
801: action = walk(e->e2);
802: if(action == tna_error) return action;
803: }
804: break;
805: case 2:
806: break;
807: case 3:
808: break;
809: case 4:
810: action = walk(e->n_initializer);
811: if(action == tna_error) return action;
812: break;
813: }
814:
815: switch(derr = e->discriminator (3)) {
816: case 0:
817: break;
818: default:
819: error ("a_expr: discrim error %d on union 3.", derr);
820: return tna_error;
821: case 1:
822: action = walk(e->tp2);
823: if(action == tna_error) return action;
824: break;
825: case 2:
826: action = walk(e->fct_name);
827: if(action == tna_error) return action;
828: break;
829: case 3:
830: action = walk(e->cond);
831: if(action == tna_error) return action;
832: break;
833: case 4:
834: action = walk(e->mem);
835: if(action == tna_error) return action;
836: break;
837: case 5:
838: action = walk(e->as_type);
839: if(action == tna_error) return action;
840: break;
841: case 6:
842: action = walk(e->n_table);
843: if(action == tna_error) return action;
844: break;
845: case 7:
846: action = walk(e->il);
847: if(action == tna_error) return action;
848: break;
849: case 8:
850: action = walk(e->query_this);
851: if(action == tna_error) return action;
852: break;
853: }
854: return tna_continue;
855: }
856:
857:
858: tree_node_action walker::a_expr(Pnode ta, Pexpr e, Pnode& replacement)
859: {
860: tree_node_action action = pre_act_on_node(ta, nc_expr, Pnode(e), replacement);
861:
862: if(action == tna_stop) {
863: if(!fetching () && replacement)
864: e = Pexpr(replacement);
865: /* ELIST implies that e2 is a peer, not a child */
866: if(e->base == ELIST) {
867: action = walk(e->e2);
868: return action;
869: }
870: }
871:
872: if(action != tna_continue) return action;
873:
874: if(!fetching () && replacement)
875: e = Pexpr(replacement);
876:
877: action = a_expr_guts(e);
878: if (action == tna_error) return action;
879: if(e->base == ELIST)
880: action = walk(e->e2);
881: return action;
882: }
883:
884: tree_node_action walker::a_baseclass(Pnode ta, Pbcl b, Pnode& replacement)
885: {
886: tree_node_action action = pre_act_on_node(ta, nc_baseclass, Pnode(b), replacement);
887:
888: if(action != tna_continue) return action;
889:
890: if(!fetching () && replacement)
891: b = Pbcl(replacement);
892:
893: action = walk(b->bclass);
894: if(action == tna_error) return action;
895:
896: action = walk(b->init);
897: if(action == tna_error) return action;
898:
899: action = walk(b->next);
900: if(action == tna_error) return action;
901:
902: return tna_continue;
903: }
904:
905:
906: /* a name is also an expr. */
907:
908:
909: tree_node_action walker::a_name(Pnode ta, Pname n, Pnode& replacement)
910: {
911: int derr;
912: int cl_error;
913: tree_node_action action = pre_act_on_node(ta, nc_name, Pnode(n), replacement);
914:
915: /* n_list is a sibling, not a child. We always process it
916: except in case of an error. */
917: if(action == tna_stop) {
918: cl_error = 0;
919: if(!fetching () && replacement)
920: n = Pname(replacement);
921: if((classify_node(Pnode(n), cl_error) == nc_name) && !cl_error) {
922: if(depth > 0 || !control.dont_chase_lists_top) {
923: action = walk(n->n_list);
924: if(action == tna_error) return action;
925: }
926: }
927: return tna_stop;
928: }
929:
930: if(action != tna_continue) return action;
931:
932: if(!fetching () && replacement)
933: n = Pname(replacement);
934:
935: /* We don't walk n_tbl_list. Its not part of the graph.
936: */
937:
938: switch(derr = n->discriminator(0)) {
939: case 0:
940: break;
941: case 1:
942: action = walk(n->n_qualifier);
943: if(action == tna_error) return action;
944: break;
945: case 2:
946: action = walk(n->n_realscope);
947: if(action == tna_error) return action;
948: break;
949: default:
950: error ("a_name: discrim error %d on union 0.", derr);
951: return tna_error;
952: }
953:
954: action = a_expr_guts(Pexpr(n));
955: if(action == tna_error) return action;
956:
957: if(depth > 0 || !control.dont_chase_lists_top) {
958: action = walk(n->n_list);
959: if(action == tna_error) return action;
960: }
961:
962: return action;
963: }
964:
965: /* --- NOTE: s_list should be deferred until AFTER the post-action
966: procedure is called, if there is one. Since no one uses
967: post-actions yet I haven't bothered to make this fix.
968: --benson */
969:
970: tree_node_action walker::a_stmt(Pnode ta, Pstmt s, Pnode& replacement)
971: {
972: int cl_error;
973: int derr;
974: tree_node_action action = pre_act_on_node(ta, nc_stmt, Pnode(s), replacement);
975:
976: if(action == tna_stop) {
977: if(!fetching () && replacement)
978: s = Pstmt(replacement);
979: cl_error = 0;
980: if((classify_node(Pnode(s), cl_error) == nc_stmt) && !cl_error) {
981: /* s_list is not our subordinate, it is our peer */
982: if(depth > 0 || !control.dont_chase_lists_top) {
983: action = walk(s->s_list); /* continue walk of sibs */
984: if (action == tna_error) return tna_error;
985: }
986: }
987: return tna_stop;
988: }
989:
990: if(action != tna_continue) return action;
991:
992: if(!fetching () && replacement)
993: s = Pstmt(replacement);
994:
995: action = walk(s->s);
996: if(action == tna_error) return action;
997:
998: action = walk(s->memtbl);
999: if(action == tna_error) return action;
1000:
1001: switch(derr = s->discriminator(0)) {
1002: default:
1003: error ("a_stmt: discrim error %d on union 0.", derr);
1004: return tna_error;
1005: case 4:
1006: case 0: break;
1007: case 1:
1008: action = walk(s->d);
1009: if(action == tna_error) return action;
1010: break;
1011: case 2:
1012: action = walk(s->e2);
1013: if(action == tna_error) return action;
1014: break;
1015: case 3:
1016: action = walk(s->has_default);
1017: if(action == tna_error) return action;
1018: break;
1019: case 5:
1020: action = walk(s->ret_tp);
1021: if(action == tna_error) return action;
1022: break;
1023: }
1024:
1025: switch(derr = s->discriminator(1)) {
1026: default:
1027: error ("a_stmt: discrim error %d on union 1.", derr);
1028: return tna_error;
1029: case 2:
1030: case 0: break;
1031: case 1:
1032: action = walk(s->e);
1033: if(action == tna_error) return action;
1034: break;
1035: case 3:
1036: action = walk(s->s2);
1037: if(action == tna_error) return action;
1038: break;
1039: }
1040:
1041: switch(derr = s->discriminator(2)) {
1042: default:
1043: error ("a_stmt: discrim error %d on union 2.", derr);
1044: return tna_error;
1045: case 0: break;
1046: case 1:
1047: action = walk(s->for_init);
1048: if(action == tna_error) return action;
1049: break;
1050: case 2:
1051: action = walk(s->else_stmt);
1052: if(action == tna_error) return action;
1053: break;
1054: case 3:
1055: action = walk(s->case_list);
1056: if(action == tna_error) return action;
1057: break;
1058: }
1059:
1060: if(depth > 0 || !control.dont_chase_lists_top) {
1061: action = walk(s->s_list);
1062: if(action == tna_error) return action;
1063: }
1064:
1065: return tna_continue;
1066: }
1067:
1068: tree_node_action walker::a_ia(Pnode ta, struct ia * ia, Pnode& replacement)
1069: {
1070: tree_node_action action = pre_act_on_node(ta, nc_ia, Pnode(ia), replacement);
1071:
1072: if(action != tna_continue) return action;
1073:
1074: if(!fetching () && replacement)
1075: ia = (struct ia *)&replacement;
1076:
1077: action = walk(ia->local);
1078: if(action == tna_error) return action;
1079:
1080: action = walk(ia->arg);
1081: if(action == tna_error) return action;
1082:
1083: action = walk(ia->tp);
1084: if(action == tna_error) return action;
1085:
1086: return tna_continue;
1087: }
1088:
1089: tree_node_action walker::a_iline(Pnode ta, Pin iline, Pnode& replacement)
1090: {
1091: tree_node_action action = pre_act_on_node(ta, nc_iline, Pnode(iline), replacement);
1092:
1093: if(action != tna_continue) return action;
1094:
1095: if(!fetching () && replacement)
1096: iline = Pin(replacement);
1097:
1098: action = walk(iline->fct_name);
1099: if(action == tna_error) return action;
1100:
1101: action = walk(iline->i_next);
1102: if(action == tna_error) return action;
1103:
1104: action = walk(iline->i_table);
1105: if(action == tna_error) return action;
1106:
1107: action = walk(iline->i_args);
1108: if(action == tna_error) return action;
1109:
1110: return tna_continue;
1111: }
1112:
1113: static char rcsinfo[] = "$Header: /usr3/lang/benson/work/stripped_cfront/RCS/tree_walk.c,v 1.1 89/11/20 08:51:06 benson Exp $";
1114:
1115:
1116: /*
1117: $Log: tree_walk.c,v $
1118: * Revision 1.1 89/11/20 08:51:06 benson
1119: * Initial revision
1120: *
1121: * Revision 1.17 89/10/20 14:32:06 benson
1122: * fixes to n_list processing and related items.
1123: *
1124: * Revision 1.16 89/10/04 19:03:50 dysak
1125: * Let the tree walker know about the n_persistent_db member of
1126: * a name node.
1127: *
1128: * Revision 1.15 89/10/02 09:58:33 benson
1129: * finish the job.
1130: *
1131: * Revision 1.14 89/10/02 09:44:30 benson
1132: * use hash table subclass.
1133: *
1134: * Revision 1.13 89/09/18 08:20:21 benson
1135: * flush freeze drying support.
1136: *
1137: * Revision 1.12 89/09/14 15:28:37 benson
1138: * don't especially prune at the gtbl and ktbl. Leave it to client to
1139: * do all pruning of this kind.
1140: *
1141: * Revision 1.11 89/09/13 09:21:26 benson
1142: * .10 also stops walking tables, ever. At least until we discover
1143: * a use for it.
1144: *
1145: * Revision 1.10 89/09/13 09:20:43 benson
1146: * rename aggregate to collection.
1147: *
1148: * Revision 1.9 89/09/02 22:07:13 benson
1149: * keep things out of the hash table. Used for template formals.
1150: *
1151: * Revision 1.8 89/08/29 13:41:05 benson
1152: * don't walk n_tbl_list
1153: *
1154: * Revision 1.7 89/08/24 08:44:52 benson
1155: * support for an activation stack.
1156: *
1157: * Revision 1.5 89/08/11 14:59:55 sam
1158: *
1159: *
1160: * Revision 1.4 89/07/27 13:32:28 benson
1161: * walk through stmt.memtbl.
1162: *
1163: * Revision 1.3 89/07/21 16:48:48 benson
1164: * fixes and extensions for frozen trees, notably support for BY_NAME.
1165: *
1166: * Revision 1.2 89/07/18 15:18:52 benson
1167: * fix bugs.
1168: *
1169: * Revision 1.1 89/07/14 10:55:49 benson
1170: * Initial revision
1171: *
1172:
1173: end_log
1174: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.