Logo Search packages:      
Sourcecode: pccts version File versions  Download package

ASTBase.cpp

/* Abstract syntax tree manipulation functions
 *
 * SOFTWARE RIGHTS
 *
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
 * company may do whatever they wish with source code distributed with
 * PCCTS or the code generated by PCCTS, including the incorporation of
 * PCCTS, or its output, into commerical software.
 *
 * We encourage users to develop software with PCCTS.  However, we do ask
 * that credit is given to us for developing PCCTS.  By "credit",
 * we mean that if you incorporate our source code into one of your
 * programs (commercial product, research project, or otherwise) that you
 * acknowledge this fact somewhere in the documentation, research report,
 * etc...  If you like PCCTS and have developed a nice tool with the
 * output, please mention that you developed it using PCCTS.  In
 * addition, we ask that this header remain intact in our source code.
 * As long as these guidelines are kept, we expect to continue enhancing
 * this system and expect to make other tools available as they are
 * completed.
 *
 * ANTLR 1.33
 * Terence Parr
 * Parr Research Corporation
 * with Purdue University and AHPCRC, University of Minnesota
 * 1989-2000
 */

#include "pcctscfg.h"

#include "pccts_stdio.h"
#include "pccts_stdarg.h"

PCCTS_NAMESPACE_STD

#define ANTLR_SUPPORT_CODE

#include "ASTBase.h"

/* ensure that tree manipulation variables are current after a rule
 * reference
 */
void
ASTBase::link(ASTBase **_root, ASTBase **_sibling, ASTBase **_tail)
{
      if ( *_sibling == NULL ) return;
      if ( *_root == NULL ) *_root = *_sibling;
      else if ( *_root != *_sibling ) (*_root)->_down = *_sibling;
      if ( *_tail==NULL ) *_tail = *_sibling;
      while ( (*_tail)->_right != NULL ) *_tail = (*_tail)->_right;
}

/* add a child node to the current sibling list */
void
ASTBase::subchild(ASTBase **_root, ASTBase **_sibling, ASTBase **_tail)
{
      if ( *_tail != NULL ) (*_tail)->_right = this;
      else {
            *_sibling = this;
            if ( *_root != NULL ) (*_root)->_down = *_sibling;
      }
      *_tail = this;
      if ( *_root == NULL ) *_root = *_sibling;
}

/* make a new AST node.  Make the newly-created
 * node the root for the current sibling list.  If a root node already
 * exists, make the newly-created node the root of the current root.
 */
void
ASTBase::subroot(ASTBase **_root, ASTBase **_sibling, ASTBase **_tail)
{
      if ( *_root != NULL )
            if ( (*_root)->_down == *_sibling ) *_sibling = *_tail = *_root;
      *_root = this;
      (*_root)->_down = *_sibling;
}

/* Apply preorder_action(), etc.. to root then each sibling */
//
//  7-Apr-97 133MR1
//    Fix suggested by Ron House (house@helios.usq.edu.au)
//
void
ASTBase::preorder(void* pData /*= NULL*/ /* MR23 */)
{
      ASTBase *tree = this;

      while ( tree!= NULL )
      {
            if ( tree->_down != NULL ) {
                  tree->preorder_before_action(pData);            // MR1      
            };
            tree->preorder_action(pData);
            if ( tree->_down!=NULL )
            {
                  tree->_down->preorder(pData);
                  tree->preorder_after_action(pData);             // MR1
            }
            tree = tree->_right;
      }
}

/* free all AST nodes in tree; apply func to each before freeing */
void
ASTBase::destroy()
{
   ASTBase* tree = this;
   while (tree) {
      if (tree->_down) tree->_down->destroy();

      ASTBase* cur = tree;
      tree = tree->_right;
      delete cur;
   }
}

/* build a tree (root child1 child2 ... NULL)
 * If root is NULL, simply make the children siblings and return ptr
 * to 1st sibling (child1).  If root is not single node, return NULL.
 *
 * Siblings that are actually siblins lists themselves are handled
 * correctly.  For example #( NULL, #( NULL, A, B, C), D) results
 * in the tree ( NULL A B C D ).
 *
 * Requires at least two parameters with the last one being NULL.  If
 * both are NULL, return NULL.
 */
ASTBase *
ASTBase::tmake(ASTBase *root, ...)
{
      va_list ap;
      register ASTBase *child, *sibling=NULL, *tail=NULL /*MR23*/, *w;

      va_start(ap, root);

      if ( root != NULL )
            if ( root->_down != NULL ) {  
            root->reportOverwriteOfDownPointer();  /* MR21 Report problem which almost always an error */
            return NULL;
        }
      child = va_arg(ap, ASTBase *);
      while ( child != NULL )
      {
            for (w=child; w->_right!=NULL; w=w->_right) {;} /* find end of child */
            if ( sibling == NULL ) {sibling = child; tail = w;}
            else {tail->_right = child; tail = w;}
            child = va_arg(ap, ASTBase *);
      }
      if ( root==NULL ) root = sibling;
      else root->_down = sibling;
      va_end(ap);
      return root;
}

#ifndef PCCTS_NOT_USING_SOR

/* tree duplicate */
// forgot to check for NULL this (TJP July 23,1995)
ASTBase *
ASTBase::dup()
{
      ASTBase *u, *t=this;
      
      if ( t == NULL ) return NULL;
/*
      u = new ASTBase;
      *u = *t;
*/
      u = (ASTBase *)this->shallowCopy();
      if ( t->_right!=NULL ) u->_right = t->_right->dup();
      else u->_right = NULL;
      if ( t->_down!=NULL ) u->_down = t->_down->dup();
      else u->_down = NULL;
      return u;
}
#endif

//
//  7-Apr-97 133MR1
//         Fix suggested by Asgeir Olafsson (olafsson@cstar.ac.com)
//
/* tree duplicate */

#ifndef PCCTS_NOT_USING_SOR

ASTBase *
ASTDoublyLinkedBase::dup()
{
      ASTDoublyLinkedBase *u, *t=this;
      
      if ( t == NULL ) return NULL;
      u = (ASTDoublyLinkedBase *)this->shallowCopy();
      u->_up = NULL;          /* set by calling invocation */
      u->_left = NULL;
      if (t->_right!=NULL) {                                // MR1
          u->_right=t->_right->dup();                             // MR1
        ((ASTDoublyLinkedBase *)u->_right)->_left = u;            // MR1
        } else {                                      // MR1
        u->_right = NULL;                                   // MR1
        };                                            // MR1
      if (t->_down!=NULL) {                                 // MR1
        u->_down = t->_down->dup();                         // MR1
          ((ASTDoublyLinkedBase *)u->_down)->_up = u;             // MR1
        } else {                                      // MR1
        u->_down = NULL;                                    // MR1
        };                                            // MR1
      return u;
}

#endif

/*
 * Set the 'up', and 'left' pointers of all nodes in 't'.
 * Initial call is double_link(your_tree, NULL, NULL).
 */
void
ASTDoublyLinkedBase::double_link(ASTBase *left, ASTBase *up)
{
    ASTDoublyLinkedBase *t = this;

    t->_left = (ASTDoublyLinkedBase *) left;
    t->_up = (ASTDoublyLinkedBase *) up;
    if (t->_down != NULL)
            ((ASTDoublyLinkedBase *)t->_down)->double_link(NULL, t);
    if (t->_right != NULL)
            ((ASTDoublyLinkedBase *)t->_right)->double_link(t, up);
}

// MR21 ASTBase::reportOverwriteOfDownPointer

void ASTBase::reportOverwriteOfDownPointer()
{
    panic("Attempt to overwrite down pointer in ASTBase::tmake");
}

// MR21 ASTBase::panic

void ASTBase::panic(const char *msg)
{
      /* MR23 */ printMessage(stderr,"ASTBase panic: %s\n", msg);
      exit(PCCTS_EXIT_FAILURE);
}

#ifdef PCCTS_NOT_USING_SOR
//MR23
int ASTBase::printMessage(FILE* pFile, const char* pFormat, ...)
{
      va_list marker;
      va_start( marker, pFormat );
      int iRet = vfprintf(pFile, pFormat, marker);
      va_end( marker );
      return iRet;
}
#endif

Generated by  Doxygen 1.6.0   Back to index