home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Language / Compiler / copyTree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-16  |  6.4 KB  |  225 lines
  1. /*
  2.  * @(#)copyTree.c    1.2  1/20/89
  3.  */
  4. #include "assert.h"
  5. #include "nodes.h"
  6. #include "sequence.h"
  7. #include "system.h"
  8. #include "map.h"
  9. #include "semantics.h"
  10. #include "trace.h"
  11.  
  12. static Map copyMap;
  13. static NodePtr *swith;
  14. static Symbol *sfor;
  15. static int slength;
  16. static NodePtr gRoot, gNewRoot;
  17.  
  18. NodePtr cTree(), _cTree();
  19. #define CTREE(T) ((int)(T) <= 0x200 ? (T) : _cTree(T))
  20.  
  21. void cSymbol(new, old)
  22. NodePtr new, old;
  23. { 
  24.   register Symbol s = old->b.symdef.symbol;
  25.   register Symbol newS;
  26.   register NodePtr r;
  27.   NodePtr list;
  28.   register int mapResult;
  29.  
  30.   mapResult = Map_Lookup(copyMap, (int)s);
  31.   if (old->tag == P_SYMDEF) {
  32.     newS = (Symbol) malloc(sizeof(STEntry));
  33.     *newS = *s;
  34.     Map_Insert(copyMap, (int)s, (int)newS);
  35.     if (mapResult == NIL) {
  36.       /* this is the first time we saw the symbol */
  37.     } else {
  38.       /* we need to fix previously seen symrefs */
  39.       assert(mapResult < 0);
  40.       list = (NodePtr) (-mapResult);
  41.       assert(list->tag == T_SEQUENCE);
  42.       Sequence_For(r, list)
  43.     assert(r->tag == P_SYMREF);
  44.     r->b.symref.symbol = newS;
  45.       Sequence_Next
  46.       free((char *) list);
  47.     }
  48.     newS->value.ATinfo = NULL;
  49.     newS->value.CTinfo = NULL;
  50.     newS->value.value = NULL;
  51.     newS->isManifest = FALSE;
  52.     newS->hasValue = FALSE;
  53.     new->b.symdef.symbol = newS;
  54.   } else {
  55.     assert(old->tag == P_SYMREF);
  56.     if (mapResult != NIL && mapResult > 0) {
  57.       new->b.symref.symbol = (Symbol) mapResult;
  58.     } else {
  59.       if (mapResult == NIL) {
  60.     list = F_NewNode(T_SEQUENCE, 4);
  61.     Map_Insert(copyMap, (int)s, -(int)list);
  62.       } else {
  63.     list = (NodePtr) (-mapResult);
  64.       }
  65.       Sequence_Add(&list, new);
  66.       new->b.symref.symbol = old->b.symref.symbol;
  67.     }
  68.   }
  69. }
  70.  
  71. /*
  72.  * We need to copy all nodes making this object.
  73.  */
  74.  
  75. NodePtr _cTree(p)
  76. register NodePtr p;
  77. {
  78.   register NodePtr newNode;
  79.   register int i, nRealChildren;
  80.   register Symbol st;
  81.   if ((int) p <= 0x200) {
  82.     newNode = p;
  83.   } else if ((newNode = (NodePtr) Map_Lookup(copyMap, (int)p)) != (NodePtr) NIL) {
  84.     /* do nothing, newNode is the right thing to return */
  85.   } else if ((p->tag == P_ATLIT || p->tag == P_OBLIT) && p->b.atlit.f.writeSeparately) {
  86.     assert(p->b.atlit.id != 0);
  87.     newNode = Construct(P_GLOBALREF, 0);
  88.     newNode->b.globalref.id = p->b.atlit.id;
  89.     newNode->b.globalref.value = p;
  90.   } else if (p->tag == P_SYMREF || p->tag == P_SYMDEF) {
  91.     st = p->b.symref.symbol;
  92.     for (i = 0; i < slength && sfor[i] != st; i++) ;
  93.     if (i < slength) {
  94.       /*
  95.        * We found it.  Return a pointer to the thing in swith[i].
  96.        */
  97.       newNode = swith[i];
  98.     } else {
  99.       goto regular;
  100.     }
  101.   } else {
  102. regular:
  103.     nRealChildren = p->nChildren - p->firstChild;
  104.     if (p == gRoot) {
  105.       newNode = gNewRoot;
  106.     } else {
  107.       newNode = F_NewNode(p->tag, nRealChildren);
  108.       newNode->nChildren += nRealChildren;
  109.     }
  110.     newNode->lineNumber = p->lineNumber;
  111.     Map_Insert(copyMap, (int)p, (int)newNode);
  112.     for (i = 0; i < newNode->firstChild; i++)
  113.       newNode->b.children[i] = p->b.children[i];
  114.  
  115.     switch (p->tag) {
  116.       case P_SYMDEF:
  117.       case P_SYMREF:
  118.     cSymbol(newNode, p);
  119.     break;
  120.       case P_INVOC:
  121.     newNode->b.invoc.resultTypeOID = 0;
  122.     for (i = newNode->firstChild; i < newNode->nChildren; i++)
  123.       newNode->b.children[i] = CTREE(p->b.children[i]);
  124.     break;
  125.       case P_VECTORLIT:
  126.     newNode->b.vectorlit.vectorType = NN;
  127.     for (i = newNode->firstChild; i < newNode->nChildren; i++)
  128.       newNode->b.children[i] = CTREE(p->b.children[i]);
  129.     break;
  130.       case P_OBLIT:
  131.       case P_ATLIT:
  132.     TRACE4(copy, 1, "Copying %s %s 0x%08x -> 0x%08x", 
  133.       tagNames[(int)p->tag],
  134.       p->b.oblit.name == NN ? "unknown" : 
  135.         ST_SymbolName(p->b.oblit.name->b.symdef.symbol),
  136.       p,
  137.       newNode);
  138.     newNode->b.oblit.sfname = p->b.oblit.sfname;
  139.     newNode->b.oblit.setq = CTREE(p->b.oblit.setq);
  140.     newNode->b.oblit.name = CTREE(p->b.oblit.name);
  141.     newNode->b.oblit.name->b.symdef.symbol->isSelf = TRUE;
  142.     newNode->b.oblit.name->b.symdef.symbol->value.value = newNode;
  143.     newNode->b.oblit.id = 0;
  144.     newNode->b.oblit.codeOID = 0;
  145.     newNode->b.oblit.f.isManifest = FALSE;
  146.     newNode->b.oblit.f.writeSeparately = FALSE;
  147.     newNode->b.oblit.f.isTypeVariable = FALSE;
  148.     newNode->b.oblit.f.inExecutableConstruct = FALSE;
  149.     newNode->b.oblit.f.dependsOnTypeVariable = FALSE;
  150.     newNode->b.oblit.f.typesAreAssigned = FALSE;
  151.     newNode->b.oblit.f.typesHaveBeenChecked = FALSE;
  152.     if (p->tag == P_ATLIT) {
  153.       newNode->b.atlit.ops = CTREE(p->b.atlit.ops);
  154.     } else {
  155.       newNode->b.oblit.myat = NULL;
  156.       newNode->b.oblit.instat = NULL;
  157.       newNode->b.oblit.export = CTREE(p->b.oblit.export);      
  158.       newNode->b.oblit.decls = CTREE(p->b.oblit.decls);      
  159.       newNode->b.oblit.monitor = CTREE(p->b.oblit.monitor);      
  160.       newNode->b.oblit.ops = CTREE(p->b.oblit.ops);      
  161.       newNode->b.oblit.process = CTREE(p->b.oblit.process);      
  162.     }
  163.     break;
  164.       default:
  165.     for (i = newNode->firstChild; i < newNode->nChildren; i++)
  166.       newNode->b.children[i] = CTREE(p->b.children[i]);
  167.     break;
  168.     }
  169.   }
  170.   return(newNode);
  171. }
  172.  
  173. /*
  174.  * This routine returns a copy of the tree, with symbols resolved, but no
  175.  * type checking or assignment done.  Each occurance of a symref node in the 
  176.  * tree that refers to one of the symbols in subfor is replaced with a
  177.  * reference to the corresponding thing from subwith.
  178.  */
  179.  
  180. NodePtr cTree(p, newRoot, subfor, subwith)
  181. NodePtr p, newRoot, subfor, subwith;
  182. {
  183.   NodePtr result;
  184.   register int i;
  185.  
  186.   if ((p->tag == P_ATLIT || p->tag == P_OBLIT) && p->b.atlit.f.writeSeparately) {
  187.     if (newRoot == NN) {
  188.       assert(p->b.atlit.id != 0);
  189.       result = Construct(P_GLOBALREF, 0);
  190.       result->b.globalref.id = p->b.atlit.id;
  191.       result->b.globalref.value = p;
  192.     } else {
  193.       assert(newRoot->tag == P_GLOBALREF);
  194.       assert(newRoot->b.globalref.value == p);
  195.       result = newRoot;
  196.     }
  197.     return(result);
  198.   }
  199.   if (newRoot == NN) {
  200.     /*
  201.      * Just allocate and return the root.
  202.      */
  203.     result = F_NewNode(p->tag, p->nChildren - p->firstChild);
  204.     result->nChildren = p->nChildren;
  205.   } else {
  206.     slength = Sequence_Length(subfor);
  207.     assert(Sequence_Length(subwith) == slength);
  208.     sfor = (Symbol *) calloc((unsigned)slength, sizeof(Symbol));
  209.     swith = (NodePtr *) calloc((unsigned)slength, sizeof(NodePtr));
  210.     for (i = 0; i < slength; i++) {
  211.       sfor[i] = subfor->b.children[i]->b.symdef.symbol;
  212.       swith[i] = subwith->b.children[i];
  213.     }
  214.     copyMap = Map_Create();
  215.     gRoot = p;
  216.     gNewRoot = newRoot;
  217.     result = CTREE(p);
  218.     assert(result == gNewRoot);
  219.     Map_Destroy(copyMap);
  220.     free((char *)sfor);
  221.     free((char *)swith);
  222.   }
  223.   return(result);
  224. }
  225.