---

tree.c

 /*
  * plint/prog/tree.c : code blocks tree nodes handling
  * 
  * Time-stamp: <2003-01-08 21:09:45 gseba>
  * 
  * Copyright (C) Sebastian Glita, email: gseba@users.sourceforge.net
  * 
  * This file is part of plint.
  * 
  * plint is free software; you can  redistribute it and/or modify it under the
  * terms of the  GNU General Public License as published  by the Free Software
  * Foundation; either version 2, or (at your option) any later version.
  *
  * plint  is distributed  in the  hope  that it  will be  useful, but  WITHOUT
  * ANY  WARRANTY; without  even  the implied  warranty  of MERCHANTABILITY  or
  * FITNESS FOR A  PARTICULAR PURPOSE.  See the GNU  General Public License for
  * more details.
  * 
  * You should  have received a  copy of the  GNU General Public  License along
  * with  plint; see  the file  COPYING.  If  not, write  to the  Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA USA.
  *
  */

#pragma GCC dependency "Makefile" maybe some command line defines have changed

#include "plint.h"
#include "error.h"

#include "data.h"
#include "parse.h"
#include "proc.h"

#include "misc/file.h"
#include "misc/sys.h"



plint_tree_t plint_tree_new()
{
  char const * filename;

#ifdef PLINT_TMP_CHECK
  int fd;
  FILE * file;
  plint_tree_t p = 0;

  do
    fd = open(filename = plint_temp_new(), O_CREAT | O_RDWR | O_EXCL, S_IWUSR | S_IRUSR); /* test not to overwrite */ 
  while (fd < 0);
  close(fd);

  if ((file = plint_file_open(filename, "wt")))
    {
      NEW(p);
      p->level = plint->syn.level;
      p->srcfile = strndup(filename, PLINT_OUT_LEN);
      p->file = file;
    }
  else
    PLINT_ERROR(PLINT_ERR_TMP);

#else
  plint_tree_t p;

  filename = plint_temp_new();

  NEW(p);
  p->level = plint->syn.level;
  p->srcfile = strndup(filename, PLINT_OUT_LEN);
  p->file = plint_file_open(filename, "wt");
#endif

  p->prnt = 0;
  p->user = slot_create();

  return p;
}

static int prc_two(plint_tree_t p)
{
  plint_proc.lup.sig = p->proc;
  return !!plint_proc_lup_sig(plint_proc.lup.ptr);
}

int plint_tree_open(plint_tree_t chld)
{
  plint_tree_t prnt;
  register int two = 0, old = !!chld->prnt;

  prnt = plint_code.tree;
  if (!old)
    PLINT_MAP_TREE(NEW, chld->blk, chld);

  plint_proc.lup.ptr = plint_tree_non_ins(prnt);
  if (PLINT_TREE_ISINS(chld))                           /* it's an insertion, */
    {
      size_t i;
      if (!0
          && !PLINT_TREE_ISPRS(chld)                    /* already parsed, */
          && plint->tree.ins == PLINT_INS_INSERT        /* not included, but inserted */
          && !plint_ins.top->count)                     /* without any insert points in the subtree */
        for (i = 0; i < chld->nchlds; ++i)
          if (PLINT_TREE_ISPRC(chld->chlds[i]))
            if ((two = prc_two(chld->chlds[i])))
              break;

      chld->host_id = 1;
      chld->host.d = plint_tree_host(prnt);
    }
  else
    {
      if (PLINT_TREE_ISPRC(chld))/* checking if there are other procedures
                                    with the same name & arrity, at the same level */
        two = prc_two(chld);

      /* default host: inherited */
      chld->host_id = prnt->host_id;
      chld->host = prnt->host;
      if (PLINT_TREE_ISPRC(prnt)) /* direct if procedure */
        {
          chld->host_id = 1;
          chld->host.d = prnt;
        }
      else if (PLINT_TREE_ISINS(prnt)) /* indirect if insertion */
        {
          chld->host_id = 0;
          chld->host.i = &prnt->host.d;
        }
    }

  prnt->chlds = realloc(prnt->chlds, ++prnt->nchlds*sizeof(plint_tree_t));
  prnt->chlds[prnt->nchlds - 1] = chld;
  chld->prnt = prnt;

  PLINT_MAP_TREE(NEW_PRNT, chld->blk, chld);

  plint_code.tree = chld;

  PLINT_MAP_TREE(NEW_CHLD, prnt->blk, prnt);

  if (!old)
    {
      plint_eblk_t b;
      for (b = _PLINT_BLK_start; ++b < _PLINT_BLK_stop ;)
        PLINT_MAP_TREE(NEW_USER, b, chld);
    }

  plint_trace(block, 0);

  return !two;
}

void plint_tree_close()
{
  plint_tree_t chld = plint_code.tree, prnt = chld->prnt;

  plint_trace(block, 1);

  if (PLINT_TREE_ISPRS(chld))
    {
      fprintf(chld->file, ";\n");
      plint_file_close(chld->file);

      if (PLINT_TREE_ISINS(chld)) /* keep it as read only,
                                     to insert it where & when
                                     it is required (not only now) */
        chld->file = plint_file_open(chld->srcfile, "rt");

      chld->flag <<= 1; /* done with parsing */
    }

  if (PLINT_TREE_ISINS(chld))
    if (plint->tree.ins == PLINT_INS_INSERT)
      {
        plint_file_insert(prnt->file, chld->file);
        PLINT_MAP_TREE(INSERT, prnt->blk, prnt);
      }
    else
      PLINT_MAP_TREE(INCLUDE, prnt->blk, prnt);
  else if (!PLINT_TREE_ISPRC(chld) && (!PLINT_TREE_ISWRP(chld) || !plint->flag.hook))
    {
      fprintf(prnt->file, " \\B %p ", chld);
      PLINT_MAP_TREE(BLOCK, chld->blk, chld);
    }

  if (prnt)
    PLINT_MAP_TREE(DONE_CHLD, prnt->blk, prnt);

  plint_code.tree = prnt;

  PLINT_MAP_TREE(DONE_PRNT, chld->blk, chld);

  PLINT_MAP_TREE(DONE, chld->blk, chld);
}

void plint_tree_free(plint_tree_t r)
{
  plint_tree_t q = 0;
  plint_code.tree = r;
  while ((r = plint_code.tree))
    {
      switch (plint->run)
        {
        case 0 OR 1: break;
        default:
          if (!q && PLINT_TREE_ISPRC(r) && r->flag < 4)
            {
              q = r;

#ifdef PLINT_VERB_WARN
              eprintf("\n%s%s%s", PLINT_PLINT, PLINT_WARN, PLINT_NEVER);
              plint_proc_log(stderr, r);
#endif
            }
        }

      while (r->nchlds)
        if (PLINT_TREE_ISINS(r->chlds[r->nchlds-1]))
          --r->nchlds;
        else /* don't descend into an insertion point */
          break;

      if (r->nchlds)
        {
          plint_code.tree = r->chlds[--r->nchlds];
          PLINT_MAP_TREE(FREE_CHLD, r->blk, r);

          plint_code.tree = r;
          r = r->chlds[r->nchlds];
          PLINT_MAP_TREE(FREE_PRNT, r->blk, r);

          plint_code.tree = r;
        }
      else
        {
          free(r->chlds);

          if (PLINT_TREE_ISPRS(r) || PLINT_TREE_ISINS(r))
            plint_file_close(r->file);

          unlink(r->srcfile);
          free(r->srcfile);

          if (!PLINT_TREE_ISINS(r))
            {
              plint_eblk_t b;
              for (b = _PLINT_BLK_start; ++b < _PLINT_BLK_stop ;)
                PLINT_MAP_TREE(FREE_USER, b, r);
            }

          plint_code.tree = r->prnt;

          /* special case - root */
          if (!plint_code.tree)
            PLINT_MAP_TREE(FREE_PRNT, r->blk, r);

          if (PLINT_TREE_ISPRC(r))
            {
              hash_remstr(plint_hash.id, r->proc.name);
              while (r->proc.arrity)
                hash_remstr(plint_hash.id, r->proc.args[--r->proc.arrity]);

              free(r->proc.args);
            }

          if (!PLINT_TREE_ISINS(r))
            {
              PLINT_MAP_TREE(FREE, r->blk, r);
              slot_delete(r->user);
              FREE(r);
            }

          switch (plint->run)
            {
            case 0 OR 1: break;
            default:
                if (q == r)
                  q = 0;
            }
        }
    }
}

---