This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [tree-ssa] Tree Browser


Hi,

Thanks for comments on the first version of the Tree Browser.
I've included the 'portable' version of getline provided by Dan,
implemented the up/prev as suggested by Frank Ch. Eigler,
and it "recognizes the new tree chaining scheme we have in GENERIC and  
GIMPLE trees."  I've also included a history stack to keep track of 
different nodes we've visited.

Bootstrapped on x86.


2002-11-26  Sebastian Pop  <s.pop@laposte.net>

	* Makefile.in (OBJS): Add tree-browser.o.
	(tree-browser.o): New dependency.

	* tree-browser.c: New file.

	* tree-browser.def: New file.

Attachment: M.diff
Description: Text document

/* Tree browser.
   Copyright (C) 2002 Free Software Foundation, Inc.
   Contributed by Sebastian Pop <s.pop@laposte.net>

This file is part of GCC.

GCC 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.

GCC 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 GCC; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include "config.h"
#include "system.h"
#include "errors.h"
#include "tree.h"
#include "tree-inline.h"
#include "diagnostic.h"
#include "hashtab.h"


#define TB_OUT_FILE stdout
#define TB_IN_FILE stdin
#define TB_NIY fprintf (TB_OUT_FILE, "Sorry this command is not yet implemented.\n")
#define TB_WF fprintf (TB_OUT_FILE, "Warning, this command failed.\n")


/* Structures for handling Tree Browser's commands.  */
#define DEFTBCODE(COMMAND, STRING, HELP)   COMMAND,
enum TB_Comm_code {
#include "tree-browser.def"
  TB_UNUSED_COMMAND
};
#undef DEFTBCODE
typedef enum TB_Comm_code TB_CODE;

struct tb_command {
  const char *help_msg;
  const char *comm_text;
  size_t comm_len;
  TB_CODE comm_code;
};

#define DEFTBCODE(code, str, help) { help, str, sizeof(str) - 1, code },
#ifdef HOST_EBCDIC
static struct tb_command tb_commands[] =
#else
static const struct tb_command tb_commands[] =
#endif
{
#include "tree-browser.def"
};
#undef DEFTBCODE

#define TB_COMMAND_LEN(N) (tb_commands[N].comm_len)
#define TB_COMMAND_TEXT(N) (tb_commands[N].comm_text)
#define TB_COMMAND_CODE(N) (tb_commands[N].comm_code)
#define TB_COMMAND_HELP(N) (tb_commands[N].help_msg)


/* Next structure is for parsing TREE_CODEs.  */
struct tb_tree_code {
  enum tree_code code;
  const char *code_string;
  size_t code_string_len;
};

#define DEFTREECODE(SYM, STRING, TYPE, NARGS) { SYM, STRING, sizeof (STRING) - 1 }, 
#ifdef HOST_EBCDIC
static struct tb_tree_code tb_tree_codes[] = 
#else
static const struct tb_tree_code tb_tree_codes[] = 
#endif
{
#include "tree.def"
};
#undef DEFTREECODE

#define TB_TREE_CODE(N) (tb_tree_codes[N].code)
#define TB_TREE_CODE_TEXT(N) (tb_tree_codes[N].code_string)
#define TB_TREE_CODE_LEN(N) (tb_tree_codes[N].code_string_len)


/* Function declarations.  */

static long TB_getline                   PARAMS ((char **, long *, FILE *)); 
static TB_CODE TB_get_command            PARAMS ((char *)); 
static enum tree_code TB_get_tree_code   PARAMS ((char *)); 
static tree find_node_with_code          PARAMS ((tree *, int *, void *)); 
static tree store_child_info             PARAMS ((tree *, int *, void *)); 
static void TB_update_up                 PARAMS ((tree));
static tree TB_current_chain_node        PARAMS ((tree));
static tree TB_prev_expr                 PARAMS ((tree));
static tree TB_next_expr                 PARAMS ((tree));
static tree TB_up_expr                   PARAMS ((tree));
static tree TB_first_in_bind             PARAMS ((tree));
static tree TB_last_in_bind              PARAMS ((tree));
static int  TB_parent_eq                 PARAMS ((const void *, const void *));
static tree TB_history_prev              PARAMS ((void));

/* FIXME: To be declared in a .h file.  */ 
void browse_tree                           PARAMS ((tree)); 

/* Static variables.  */
static htab_t TB_up_ht;
static tree TB_history_stack = NULL_TREE;
static int TB_verbose = 1;
 

/* Entry point in the Tree Browser.  */

void 
browse_tree (begin)
     tree begin;
{
  tree head;
  TB_CODE tbc = TB_UNUSED_COMMAND;
  ssize_t rd;
  char *input = NULL;
  long input_size = 0;
  
  fprintf (TB_OUT_FILE, "\nTree Browser\n");

#define TB_SET_HEAD(N) do {                                           \
  TB_history_stack = tree_cons (NULL_TREE, (N), TB_history_stack);    \
  head = N;                                                           \
  if (TB_verbose)                                                     \
    if (head)                                                         \
      {                                                               \
	print_generic_expr (TB_OUT_FILE, head, 0);                    \
	fprintf (TB_OUT_FILE, "\n");                                  \
      }                                                               \
} while (0)

  TB_SET_HEAD (begin);
  
  /* Store in a hashtable information about previous and upper statements.  */
  {
    TB_up_ht = htab_create (1023, htab_hash_pointer, &TB_parent_eq, NULL);
    TB_update_up (head);
  }

  while (24)
    {
      fprintf (TB_OUT_FILE, "TB> ");
      rd = TB_getline (&input, &input_size, TB_IN_FILE);
      
      if (rd == -1)
	/* EOF.  */
	goto ret;
      
      if (rd != 1)
	/* Get a new command.  Otherwise the user just pressed enter, and thus 
	   she expects the last command to be reexecuted.  */
	tbc = TB_get_command (input);

      switch (tbc)
	{
	case TB_UPDATE_UP:
	  TB_update_up (head);
	  break;
	  
	case TB_MAX:
	  if (head && (INTEGRAL_TYPE_P (head)
		       || TREE_CODE (head) == REAL_TYPE))
	    TB_SET_HEAD (TYPE_MAX_VALUE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_MIN:
	  if (head && (INTEGRAL_TYPE_P (head)
		       || TREE_CODE (head) == REAL_TYPE))
	    TB_SET_HEAD (TYPE_MIN_VALUE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ELT:
	  if (head && TREE_CODE (head) == TREE_VEC)
	    {
	      /* This command takes another argument: the element number:
		 for example "elt 1".  */
	      TB_NIY;
	    }
	  else if (head && TREE_CODE (head) == VECTOR_CST)
	    {
	      /* This command takes another argument: the element number: 
                 for example "elt 1".  */ 
              TB_NIY;
	    }
	  else
	    TB_WF;
	  break;
	  
	case TB_VALUE:
	  if (head && TREE_CODE (head) == TREE_LIST)
	    TB_SET_HEAD (TREE_VALUE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_PURPOSE:
	  if (head && TREE_CODE (head) == TREE_LIST)
	    TB_SET_HEAD (TREE_PURPOSE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_IMAG:
	  if (head && TREE_CODE (head) == COMPLEX_CST)
	    TB_SET_HEAD (TREE_IMAGPART (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_REAL:
	  if (head && TREE_CODE (head) == COMPLEX_CST)
	    TB_SET_HEAD (TREE_REALPART (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_BLOCK:
	  if (head && TREE_CODE (head) == BIND_EXPR)
	    TB_SET_HEAD (TREE_OPERAND (head, 2));
	  else
	    TB_WF;
	  break;
	  
	case TB_SUBBLOCKS:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'b')
	    TB_SET_HEAD (BLOCK_SUBBLOCKS (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_SUPERCONTEXT:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'b')
	    TB_SET_HEAD (BLOCK_SUPERCONTEXT (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_VARS:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'b')
	    TB_SET_HEAD (BLOCK_VARS (head));
	  else if (head && TREE_CODE (head) == BIND_EXPR)
	    TB_SET_HEAD (TREE_OPERAND (head, 0));
	  else
	    TB_WF;
	  break;
	  
	case TB_REFERENCE_TO_THIS:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
	    TB_SET_HEAD (TYPE_REFERENCE_TO (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_POINTER_TO_THIS:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
	    TB_SET_HEAD (TYPE_POINTER_TO (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_BASETYPE:
	  if (head && TREE_CODE (head) == OFFSET_TYPE)
	    TB_SET_HEAD (TYPE_OFFSET_BASETYPE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ARG_TYPES:
	  if (head && (TREE_CODE (head) == FUNCTION_TYPE
		       || TREE_CODE (head) == METHOD_TYPE))
	    TB_SET_HEAD (TYPE_ARG_TYPES (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_METHOD_BASE_TYPE:
	  if (head && (TREE_CODE (head) == FUNCTION_TYPE
		       || TREE_CODE (head) == METHOD_TYPE)
	      && TYPE_METHOD_BASETYPE (head))
	    TB_SET_HEAD (TYPE_METHOD_BASETYPE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_FIELDS:
	  if (head && (TREE_CODE (head) == RECORD_TYPE
		       || TREE_CODE (head) == UNION_TYPE
		       || TREE_CODE (head) == QUAL_UNION_TYPE))
	    TB_SET_HEAD (TYPE_FIELDS (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_DOMAIN:
	  if (head && (TREE_CODE (head) == ARRAY_TYPE 
		       || TREE_CODE (head) == SET_TYPE))
	    TB_SET_HEAD (TYPE_DOMAIN (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_VALUES:
	  if (head && TREE_CODE (head) == ENUMERAL_TYPE)
	    TB_SET_HEAD (TYPE_VALUES (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ARG_TYPE_AS_WRITTEN:
	  if (head && TREE_CODE (head) == PARM_DECL)
	    TB_SET_HEAD (DECL_ARG_TYPE_AS_WRITTEN (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ARG_TYPE:
	  if (head && TREE_CODE (head) == PARM_DECL)
	    TB_SET_HEAD (DECL_ARG_TYPE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_INITIAL:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_INITIAL (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_RESULT:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_RESULT_FLD (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ARGUMENTS:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_ARGUMENTS (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ABSTRACT_ORIGIN:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));
	  else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'b')
	    TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_ATTRIBUTES:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_ATTRIBUTES (head));
	  else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
	    TB_SET_HEAD (TYPE_ATTRIBUTES (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_CONTEXT:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_CONTEXT (head));
	  else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't'
		   && TYPE_CONTEXT (head))
	    TB_SET_HEAD (TYPE_CONTEXT (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_OFFSET:
	  if (head && TREE_CODE (head) == FIELD_DECL)
	    TB_SET_HEAD (DECL_FIELD_OFFSET (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_BIT_OFFSET:
	  if (head && TREE_CODE (head) == FIELD_DECL) 
	    TB_SET_HEAD (DECL_FIELD_BIT_OFFSET (head));
	  else
	    TB_WF;
          break;
	  
	case TB_UNIT_SIZE:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_SIZE_UNIT (head));
	  else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
	    TB_SET_HEAD (TYPE_SIZE_UNIT (head));
	  else
	    TB_WF;
	  break;

	case TB_SIZE:
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
	    TB_SET_HEAD (DECL_SIZE (head));
	  else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
	    TB_SET_HEAD (TYPE_SIZE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_TYPE:
	  if (head && TREE_TYPE (head))
	    TB_SET_HEAD (TREE_TYPE (head));
	  else 
	    TB_WF;
	  break;
	  
	case TB_DECL_SAVED_TREE:
	  if (head && TREE_CODE (head) == FUNCTION_DECL
	      && DECL_SAVED_TREE (head))
	    TB_SET_HEAD (DECL_SAVED_TREE (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_BODY:
	  if (head && TREE_CODE (head) == BIND_EXPR)
	    TB_SET_HEAD (TREE_OPERAND (head, 1));
	  else
	    TB_WF;
	  break;

	case TB_CHILD_0:
	  if (head && (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
		       || TREE_CODE_CLASS (TREE_CODE (head)) == 'r'
		       || TREE_CODE_CLASS (TREE_CODE (head)) == 's')
	      && TREE_OPERAND (head, 0))
	    TB_SET_HEAD (TREE_OPERAND (head, 0));
	  else
	    TB_WF;
	  break;
	  
	case TB_CHILD_1: 
          if (head && (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
		       || TREE_CODE_CLASS (TREE_CODE (head)) == 'r' 
                       || TREE_CODE_CLASS (TREE_CODE (head)) == 's')
	      && TREE_OPERAND (head, 1))
	    TB_SET_HEAD (TREE_OPERAND (head, 1));
	  else
	    TB_WF;
          break;
	  
	case TB_CHILD_2: 
          if (head && (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
		       || TREE_CODE_CLASS (TREE_CODE (head)) == 'r'  
                       || TREE_CODE_CLASS (TREE_CODE (head)) == 's')
	      && TREE_OPERAND (head, 2)) 
	    TB_SET_HEAD (TREE_OPERAND (head, 2));
	  else
	    TB_WF;
          break;
	  
	case TB_CHILD_3: 
          if (head && (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
		       || TREE_CODE_CLASS (TREE_CODE (head)) == 'r'  
                       || TREE_CODE_CLASS (TREE_CODE (head)) == 's')
	      && TREE_OPERAND (head, 3))
	    TB_SET_HEAD (TREE_OPERAND (head, 3));
	  else 
	    TB_WF;
          break;
	  
	case TB_PRINT:
	  if (head)
	    debug_tree (head);
	  else
	    TB_WF;
	  break;
	  
	case TB_PRETTY_PRINT:
	  if (head)
	    {
	      print_generic_stmt (TB_OUT_FILE, head, 0);
	      fprintf (TB_OUT_FILE, "\n");
	    }
	  else
	    TB_WF;
	  break;
	  
	case TB_SEARCH_NAME:
	  
	  break;
	  
	case TB_SEARCH_CODE:
	  {
	    enum tree_code code;
	    char *arg_text;
	    
	    arg_text = strchr (input, ' ');
	    if (arg_text == NULL) 
	      {
		fprintf (TB_OUT_FILE, "First argument is missing.  This isn't a valid search command.  \n");
		break;
	      }
	    code = TB_get_tree_code (arg_text + 1);
	    
	    /* Search in the subtree a node with the given code.  */
	    {
	      tree res;
	      
	      res = walk_tree (&head, find_node_with_code, &code, NULL);
	      if (res == NULL_TREE)
		{
		  fprintf (TB_OUT_FILE, "There's no node with this code (reachable via the walk_tree function from this node).\n");
		}
	      else
		{
		  fprintf (TB_OUT_FILE, "Achoo!  I got this node in the tree.\n");
		  TB_SET_HEAD (res);
		}
	    }
	    break;
	  }
	  
#define TB_MOVE_HEAD(FCT) do {       \
  if (head)                          \
    {                                \
      tree t;                        \
      t = FCT (head);                \
      if (t)                         \
        TB_SET_HEAD (t);             \
      else                           \
	TB_WF;                       \
    }                                \
  else                               \
    TB_WF;                           \
} while (0)
	  
	case TB_FIRST:
	  TB_MOVE_HEAD (TB_first_in_bind);
          break;
	  
        case TB_LAST:
          TB_MOVE_HEAD (TB_last_in_bind);
          break;
	  
	case TB_UP:
	  TB_MOVE_HEAD (TB_up_expr);
	  break;
	  
	case TB_PREV:
	  TB_MOVE_HEAD (TB_prev_expr);
	  break;
	  
	case TB_NEXT:
	  TB_MOVE_HEAD (TB_next_expr);
	  break;
	  
	case TB_HPREV:
	  /* This command is a little bit special, since it deals with history
	     stack.  For this reason it should keep the "head = ..." statement
	     and not use TB_MOVE_HEAD.  */
	  if (head)
	    {
	      tree t;
	      t = TB_history_prev ();
	      if (t)
		{
		  head = t;
		  if (TB_verbose)
		    {
		      print_generic_expr (TB_OUT_FILE, head, 0);
		      fprintf (TB_OUT_FILE, "\n");
		    }
		}
	      else
		TB_WF;
	    }
	  else
	    TB_WF;
	  break;
	  
	case TB_CHAIN:
	  /* Don't go further if it's the last node in this chain.  */
	  if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'b')
	    TB_SET_HEAD (BLOCK_CHAIN (head));
	  else if (head && TREE_CHAIN (head))
	    TB_SET_HEAD (TREE_CHAIN (head));
	  else
	    TB_WF;
	  break;
	  
	case TB_FUN:
	  /* Go up to the current function declaration.  */
	  TB_SET_HEAD (current_function_decl);
	  fprintf (TB_OUT_FILE, "Current function declaration.\n");
	  break;
	  
	case TB_HELP:
	  /* Display a help message.  */
	  {
	    int i;
	    fprintf (TB_OUT_FILE, "Possible commands are:\n\n");
	    for (i = 0; i < TB_UNUSED_COMMAND; i++)
	      {
		fprintf (TB_OUT_FILE, "%20s  -  %s\n", TB_COMMAND_TEXT (i), TB_COMMAND_HELP (i));
	      }
	  }
	  break;

	case TB_VERBOSE:
	  if (TB_verbose == 0)
	    {
	      TB_verbose = 1;
	      fprintf (TB_OUT_FILE, "Verbose on.\n");
	    }
	  else
	    {
	      TB_verbose = 0;
	      fprintf (TB_OUT_FILE, "Verbose off.\n");
	    }
	  break;
	  
	case TB_EXIT:
	case TB_QUIT:
	  /* Just exit from this function.  */
	  goto ret;
	  
	default:
	  TB_NIY;
	}
    }

 ret:;
  htab_delete (TB_up_ht);
  return;
}


/* Search the first node in this BIND_EXPR.  */

static tree
TB_first_in_bind (node)
     tree node;
{
  tree t;

  if (node == NULL_TREE)
    return NULL_TREE;
  
  while ((t = TB_prev_expr (node))) 
    node = t;
  
  return node;
}

/* Search the last node in this BIND_EXPR.  */

static tree
TB_last_in_bind (node)
     tree node;
{
  tree t;
  
  if (node == NULL_TREE)
    return NULL_TREE;
  
  while ((t = TB_next_expr (node)))
    node = t;

  return node;
}

/* Search the parent expression for this node.  */

static tree 
TB_up_expr (node) 
     tree node;
{
  tree res;
  if (node == NULL_TREE)
    return NULL_TREE;
  
  res = (tree) htab_find (TB_up_ht, node);
  return res;
}

/* Search the previous expression in this BIND_EXPR.  */

static tree
TB_prev_expr (node)
     tree node;
{
  node = TB_current_chain_node (node);

  if (node == NULL_TREE)
    return NULL_TREE;

  node = TB_up_expr (node);
  if (node && TREE_CODE (node) == COMPOUND_EXPR)
    return node;
  else
    return NULL_TREE;
}

/* Search the next expression in this BIND_EXPR.  */

static tree
TB_next_expr (node)
     tree node;
{
  node = TB_current_chain_node (node);
  
  if (node == NULL_TREE)
    return NULL_TREE;
  
  node = TREE_OPERAND (node, 1);
  return node;
}

static tree
TB_current_chain_node (node)
     tree node;
{
  if (node == NULL_TREE)
    return NULL_TREE;

  if (TREE_CODE (node) == COMPOUND_EXPR)
    return node;
  
  node = TB_up_expr (node);
  if (node)
    {
      if (TREE_CODE (node) == COMPOUND_EXPR)
	return node;
      
      node = TB_up_expr (node);
      if (TREE_CODE (node) == COMPOUND_EXPR)
	return node;
    }
  
  return NULL_TREE;
}

/* For each node store in its children nodes that the current node is their 
   parent.  This function is used by walk_tree.  */

static tree 
store_child_info (tp, walk_subtrees, data)
     tree *tp;
     int *walk_subtrees ATTRIBUTE_UNUSED;
     void *data ATTRIBUTE_UNUSED;
{
  tree node;
  void **slot;

  node = *tp;

  /* 'node' is the parent of 'TREE_OPERAND (node, *)'.  */
  if (TREE_CODE_CLASS (TREE_CODE (node)) == 'e')
    {

#define STORE_CHILD(N) do {                                                \
  tree op = TREE_OPERAND (node, N);                                        \
  slot = htab_find_slot (TB_up_ht, op, INSERT);                               \
  *slot = (void *) node;                                                   \
} while (0)

      switch (TREE_CODE_LENGTH (TREE_CODE (node)))
	{
	case 4:
	  STORE_CHILD (0);
	  STORE_CHILD (1);
	  STORE_CHILD (2);
	  STORE_CHILD (3);
	  break;
	  
	case 3:
	  STORE_CHILD (0);
	  STORE_CHILD (1);
	  STORE_CHILD (2);
	  break;
	  
	case 2:
	  STORE_CHILD (0);
	  STORE_CHILD (1);
	  break;
	  
	case 1:
	  STORE_CHILD (0);
	  break;
	  
	case 0:
	default:
	  /* No children: nothing to do.  */
	  break;
	}
#undef STORE_CHILD
    }
  
  /* Never stop walk_tree.  */
  return NULL_TREE;
}

/* Function used in TB_up_ht.  */

static int
TB_parent_eq (p1, p2)
     const void *p1, *p2;
{
  tree node, parent;
  node = (tree) p2;
  parent = (tree) p1;
  
  if (p1 == NULL || p2 == NULL)
    return 0;
  
  if (TREE_CODE_CLASS(TREE_CODE(parent)) == 'e') 
    { 
      
#define TEST_CHILD(N) do {               \
  if (node == TREE_OPERAND (parent, N))  \
    return 1;                            \
} while (0) 
 
    switch (TREE_CODE_LENGTH (TREE_CODE (parent))) 
      { 
      case 4: 
	TEST_CHILD (0); 
	TEST_CHILD (1); 
	TEST_CHILD (2); 
	TEST_CHILD (3); 
	break; 
           
      case 3: 
	TEST_CHILD (0); 
	TEST_CHILD (1); 
	TEST_CHILD (2); 
	break; 
           
      case 2: 
	TEST_CHILD (0); 
	TEST_CHILD (1); 
	break; 
           
      case 1: 
	TEST_CHILD (0); 
	break; 
           
      case 0: 
      default: 
	/* No children: nothing to do.  */ 
	break; 
      } 
#undef TEST_CHILD 
    } 
   
  return 0;
} 

/* Update information about upper expressions in the hash table.  */ 
 
static void 
TB_update_up (node) 
     tree node; 
{ 
  while (node) 
    { 
      walk_tree (&node, store_child_info, NULL, NULL); 
 
      /* Walk function's body.  */ 
      if (TREE_CODE (node) == FUNCTION_DECL) 
        if (DECL_SAVED_TREE (node)) 
          walk_tree (&DECL_SAVED_TREE (node), store_child_info, NULL, NULL); 
      
      /* Walk rest of the chain.  */ 
      node = TREE_CHAIN (node);
    } 
  fprintf (TB_OUT_FILE, "Up/prev expressions updated.\n"); 
} 

/* Parse the input string for determining the command the user asked for.  */

static TB_CODE 
TB_get_command (input)
     char *input;
{
  unsigned int mn, size_tok;
  int comp;
  char *space;
  
  space = strchr (input, ' ');
  if (space != NULL)
    size_tok = strlen (input) - strlen (space);
  else
    size_tok = strlen (input) - 1;

  for (mn = 0; mn < TB_UNUSED_COMMAND; mn++)
    {
      if (size_tok != TB_COMMAND_LEN (mn))
	continue;
      
      comp = memcmp (input, TB_COMMAND_TEXT (mn), TB_COMMAND_LEN (mn));
      if (comp == 0)
	/* Here we just determined the command.  If this command takes 
	   an argument, then the argument is determined later.  */
	return TB_COMMAND_CODE (mn);
    }
  
  /* Not a valid command.  */
  return TB_UNUSED_COMMAND;
}

/* Parse the input string for determining the tree code.  */

static enum tree_code
TB_get_tree_code (input)
     char *input;
{
  unsigned int mn, size_tok;
  int comp;
  char *space; 
   
  space = strchr (input, ' '); 
  if (space != NULL) 
    size_tok = strlen (input) - strlen (space); 
  else 
    size_tok = strlen (input) - 1;
  
  for (mn = 0; mn < LAST_AND_UNUSED_TREE_CODE; mn++)
    {
      if (size_tok != TB_TREE_CODE_LEN (mn))
	continue;
      
      comp = memcmp (input, TB_TREE_CODE_TEXT (mn), TB_TREE_CODE_LEN (mn));
      if (comp == 0)
	{
	  fprintf (TB_OUT_FILE, "%s\n", TB_TREE_CODE_TEXT (mn));
	  return TB_TREE_CODE (mn);
	}
    }
  
  /* This isn't a valid code.  */
  return LAST_AND_UNUSED_TREE_CODE;
}

/* Find a node with a given code.  This function is used as an argument to 
   walk_tree.  */

static tree
find_node_with_code (tp, walk_subtrees, data)
     tree *tp;
     int *walk_subtrees ATTRIBUTE_UNUSED;
     void *data;
{
  enum tree_code *code;
  code = (enum tree_code *) data;
  if (*code == TREE_CODE (*tp))
    return *tp;
  
  return NULL_TREE;
}

/* Returns a pointer to the last visited node.  */

static tree
TB_history_prev ()
{
  if (TB_history_stack)
    {
      TB_history_stack = TREE_CHAIN (TB_history_stack);
      if (TB_history_stack)
	return TREE_VALUE (TB_history_stack);
    }
  return NULL_TREE;
}

/* Read up to (and including) a '\n' from STREAM into *LINEPTR 
   (and null-terminate it). *LINEPTR is a pointer returned from malloc 
   (or NULL), pointing to *N characters of space.  It is realloc'd as 
   necessary.  Returns the number of characters read (not including the 
   null terminator), or -1 on error or EOF.   
   This function comes from sed (and is supposed to be a portable version  
   of getline).  */ 
 
static long 
TB_getline (lineptr, n, stream) 
     char **lineptr; 
     long *n; 
     FILE *stream; 
{ 
  char *line, *p; 
  long size, copy; 
 
  if (lineptr == NULL || n == NULL) 
    { 
      errno = EINVAL; 
      return -1; 
    } 
 
  if (ferror (stream)) 
    return -1; 
 
  /* Make sure we have a line buffer to start with.  */ 
  if (*lineptr == NULL || *n < 2) /* !seen and no buf yet need 2 chars.  */ 
    { 
#ifndef MAX_CANON 
#define MAX_CANON       256 
#endif 
      line = (char *) xrealloc (*lineptr, MAX_CANON); 
      if (line == NULL) 
        return -1; 
      *lineptr = line; 
      *n = MAX_CANON; 
    } 
 
  line = *lineptr; 
  size = *n; 
 
  copy = size; 
  p = line; 
 
  while (1) 
    {       
      long len; 
                
      while (--copy > 0) 
        { 
          register int c = getc (stream); 
          if (c == EOF) 
            goto lose; 
          else if ((*p++ = c) == '\n') 
            goto win; 
        } 
          
      /* Need to enlarge the line buffer.  */ 
      len = p - line;                         
      size *= 2;      
      line = (char *) xrealloc (line, size); 
      if (line == NULL)                      
        goto lose; 
      *lineptr = line; 
      *n = size;       
      p = line + len; 
      copy = size - len; 
    } 
 
 lose: 
  if (p == *lineptr) 
    return -1; 
 
  /* Return a partial line since we got an error in the middle.  */ 
 win: 
#if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(MSDOS) 
  if (p - 2 >= *lineptr && p[-2] == '\r') 
    p[-2] = p[-1], --p; 
#endif 
  *p = '\0'; 
  return p - *lineptr; 
} 

Attachment: tree-browser.def
Description: Text document


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]