tree_no_comment.c

使用yacc和lex编写的cmm语言的词法分析和语法分析程序.

tree
size_in_bytes (type)
     tree type;
{
  if (type == error_mark_node)
    return integer_zero_node;
  type = TYPE_MAIN_VARIANT (type);
  if (TYPE_SIZE (type) == 0)
    {
      incomplete_type_error (0, type);
      return integer_zero_node;
    }
  return size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
		     size_int (BITS_PER_UNIT));
}
int
int_size_in_bytes (type)
     tree type;
{
  int size;
  if (type == error_mark_node)
    return 0;
  type = TYPE_MAIN_VARIANT (type);
  if (TYPE_SIZE (type) == 0)
    return -1;
  if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
    return -1;
  size = TREE_INT_CST_LOW (TYPE_SIZE (type));
  return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
}
tree
array_type_nelts (type)
     tree type;
{
  tree index_type = TYPE_DOMAIN (type);
  return (tree_int_cst_equal (TYPE_MIN_VALUE (index_type), integer_zero_node)
	  ? TYPE_MAX_VALUE (index_type)
	  : fold (build (MINUS_EXPR, integer_type_node,
			 TYPE_MAX_VALUE (index_type),
			 TYPE_MIN_VALUE (index_type))));
}

int
staticp (arg)
     tree arg;
{
  switch (TREE_CODE (arg))
    {
    case VAR_DECL:
    case FUNCTION_DECL:
    case CONSTRUCTOR:
      return TREE_STATIC (arg) || TREE_EXTERNAL (arg);
    case STRING_CST:
      return 1;
    case COMPONENT_REF:
    case BIT_FIELD_REF:
      return staticp (TREE_OPERAND (arg, 0));
    case INDIRECT_REF:
      return TREE_CONSTANT (TREE_OPERAND (arg, 0));
    case ARRAY_REF:
      if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
	  && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
	return staticp (TREE_OPERAND (arg, 0));
    }
  return 0;
}

tree
save_expr (expr)
     tree expr;
{
  register tree t = fold (expr);
    while (TREE_CODE (t) == NON_LVALUE_EXPR)
    t = TREE_OPERAND (t, 0);
    if (TREE_CONSTANT (t) || TREE_READONLY (t) || TREE_CODE (t) == SAVE_EXPR)
    return t;
  t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL);
    TREE_SIDE_EFFECTS (t) = 1;
  return t;
}
tree
stabilize_reference (ref)
     tree ref;
{
  register tree result;
  register enum tree_code code = TREE_CODE (ref);
  switch (code)
    {
    case VAR_DECL:
    case PARM_DECL:
    case RESULT_DECL:
            return ref;
    case NOP_EXPR:
    case CONVERT_EXPR:
    case FLOAT_EXPR:
    case FIX_TRUNC_EXPR:
    case FIX_FLOOR_EXPR:
    case FIX_ROUND_EXPR:
    case FIX_CEIL_EXPR:
      result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
      break;
    case INDIRECT_REF:
      result = build_nt (INDIRECT_REF,
			 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
      break;
    case COMPONENT_REF:
      result = build_nt (COMPONENT_REF,
			 stabilize_reference (TREE_OPERAND (ref, 0)),
			 TREE_OPERAND (ref, 1));
      break;
    case BIT_FIELD_REF:
      result = build_nt (BIT_FIELD_REF,
			 stabilize_reference (TREE_OPERAND (ref, 0)),
			 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
			 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
      break;
    case ARRAY_REF:
      result = build_nt (ARRAY_REF,
			 stabilize_reference (TREE_OPERAND (ref, 0)),
			 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
      break;
          default:
      return ref;
    case ERROR_MARK:
      return error_mark_node;
    }
  TREE_TYPE (result) = TREE_TYPE (ref);
  TREE_READONLY (result) = TREE_READONLY (ref);
  TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
  TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
  TREE_RAISES (result) = TREE_RAISES (ref);
  return result;
}
static tree
stabilize_reference_1 (e)
     tree e;
{
  register tree result;
  register int length;
  register enum tree_code code = TREE_CODE (e);
  if (TREE_CONSTANT (e) || TREE_READONLY (e) || code == SAVE_EXPR)
    return e;
  switch (TREE_CODE_CLASS (code))
    {
    case 'x':
    case 't':
    case 'd':
    case '<':
    case 's':
    case 'e':
    case 'r':
                  if (TREE_SIDE_EFFECTS (e))
	return save_expr (e);
      return e;
    case 'c':
            return e;
    case '2':
            result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
			 stabilize_reference_1 (TREE_OPERAND (e, 1)));
      break;
    case '1':
            result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
      break;
    }
  TREE_TYPE (result) = TREE_TYPE (e);
  TREE_READONLY (result) = TREE_READONLY (e);
  TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
  TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
  TREE_RAISES (result) = TREE_RAISES (e);
  return result;
}

tree
build (va_alist)
     va_dcl
{
  va_list p;
  enum tree_code code;
  register tree t;
  register int length;
  register int i;
  va_start (p);
  code = va_arg (p, enum tree_code);
  t = make_node (code);
  length = tree_code_length[(int) code];
  TREE_TYPE (t) = va_arg (p, tree);
  if (length == 2)
    {
            register tree arg0 = va_arg (p, tree);
      register tree arg1 = va_arg (p, tree);
      TREE_OPERAND (t, 0) = arg0;
      TREE_OPERAND (t, 1) = arg1;
      if ((arg0 && TREE_SIDE_EFFECTS (arg0))
	  || (arg1 && TREE_SIDE_EFFECTS (arg1)))
	TREE_SIDE_EFFECTS (t) = 1;
      TREE_RAISES (t)
	= (arg0 && TREE_RAISES (arg0)) || (arg1 && TREE_RAISES (arg1));
    }
  else if (length == 1)
    {
      register tree arg0 = va_arg (p, tree);
            if (TREE_CODE_CLASS (code) != 's')
	abort ();
      TREE_OPERAND (t, 0) = arg0;
      if (arg0 && TREE_SIDE_EFFECTS (arg0))
	TREE_SIDE_EFFECTS (t) = 1;
      TREE_RAISES (t) = (arg0 && TREE_RAISES (arg0));
    }
  else
    {
      for (i = 0; i < length; i++)
	{
	  register tree operand = va_arg (p, tree);
	  TREE_OPERAND (t, i) = operand;
	  if (operand)
	    {
	      if (TREE_SIDE_EFFECTS (operand))
		TREE_SIDE_EFFECTS (t) = 1;
	      if (TREE_RAISES (operand))
		TREE_RAISES (t) = 1;
	    }
	}
    }
  va_end (p);
  return t;
}
tree
build1 (code, type, node)
     enum tree_code code;
     tree type;
     tree node;
{
  register struct obstack *obstack = current_obstack;
  register int i, length;
  register tree_node_kind kind;
  register tree t;
  if (TREE_CODE_CLASS (code) == 'r')
    kind = r_kind;
  else
    kind = e_kind;
  obstack = expression_obstack;
  length = sizeof (struct tree_exp);
  t = (tree) obstack_alloc (obstack, length);
  tree_node_counts[(int)kind]++;
  tree_node_sizes[(int)kind] += length;
  TREE_TYPE (t) = type;
  TREE_CHAIN (t) = 0;
  for (i = (length / sizeof (int)) - 2;
       i >= sizeof (struct tree_common) / sizeof (int) - 1;
       i--)
    ((int *) t)[i] = 0;
  TREE_SET_CODE (t, code);
  if (obstack == &permanent_obstack)
    TREE_PERMANENT (t) = 1;
  TREE_OPERAND (t, 0) = node;
  if (node)
    {
      if (TREE_SIDE_EFFECTS (node))
	TREE_SIDE_EFFECTS (t) = 1;
      if (TREE_RAISES (node))
	TREE_RAISES (t) = 1;
    }
  return t;
}
tree
build_nt (va_alist)
     va_dcl
{
  va_list p;
  register enum tree_code code;
  register tree t;
  register int length;
  register int i;
  va_start (p);
  code = va_arg (p, enum tree_code);
  t = make_node (code);
  length = tree_code_length[(int) code];
  for (i = 0; i < length; i++)
    TREE_OPERAND (t, i) = va_arg (p, tree);
  va_end (p);
  return t;
}
tree
build_parse_node (va_alist)
     va_dcl
{
  register struct obstack *ambient_obstack = expression_obstack;
  va_list p;
  register enum tree_code code;
  register tree t;
  register int length;
  register int i;
  expression_obstack = &temp_decl_obstack;
  va_start (p);
  code = va_arg (p, enum tree_code);
  t = make_node (code);
  length = tree_code_length[(int) code];
  for (i = 0; i < length; i++)
    TREE_OPERAND (t, i) = va_arg (p, tree);
  va_end (p);
  expression_obstack = ambient_obstack;
  return t;
}
tree
build_op_identifier (op1, op2)
     tree op1, op2;
{
  register tree t = make_node (OP_IDENTIFIER);
  TREE_PURPOSE (t) = op1;
  TREE_VALUE (t) = op2;
  return t;
}

tree
build_decl (code, name, type)
     enum tree_code code;
     tree name, type;
{
  register tree t;
  t = make_node (code);
  DECL_NAME (t) = name;
  DECL_ASSEMBLER_NAME (t) = name;
  TREE_TYPE (t) = type;
  if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
    layout_decl (t, 0);
  else if (code == FUNCTION_DECL)
    DECL_MODE (t) = FUNCTION_MODE;
  return t;
}

tree
build_block (vars, tags, subblocks, supercontext, chain)
     tree vars, tags, subblocks, supercontext, chain;
{
  register tree block = make_node (BLOCK);
  BLOCK_VARS (block) = vars;
  BLOCK_TYPE_TAGS (block) = tags;
  BLOCK_SUBBLOCKS (block) = subblocks;
  BLOCK_SUPERCONTEXT (block) = supercontext;
  BLOCK_CHAIN (block) = chain;
  return block;
}

tree
build_type_variant (type, constp, volatilep)
     tree type;
     int constp, volatilep;
{
  register tree t, m = TYPE_MAIN_VARIANT (type);
  register struct obstack *ambient_obstack = current_obstack;
    constp = !!constp;
  volatilep = !!volatilep;
    if (!flag_gen_aux_info)
    for (t = m; t; t = TYPE_NEXT_VARIANT (t))
      if (constp == TYPE_READONLY (t) && volatilep == TYPE_VOLATILE (t))
        return t;
    current_obstack
    = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
  t = copy_node (type);
  TYPE_READONLY (t) = constp;
  TYPE_VOLATILE (t) = volatilep;
  TYPE_POINTER_TO (t) = 0;
  TYPE_REFERENCE_TO (t) = 0;
    TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
  TYPE_NEXT_VARIANT (m) = t;
  current_obstack = ambient_obstack;
  return t;
}

struct type_hash
{
  struct type_hash *next;	  int hashcode;			  tree type;			};
struct type_hash *type_hash_table[TYPE_HASH_SIZE];
int
type_hash_list (list)
     tree list;
{
  register int hashcode;
  register tree tail;
  for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
    hashcode += TYPE_HASH (TREE_VALUE (tail));
  return hashcode;
}
tree
type_hash_lookup (hashcode, type)
     int hashcode;
     tree type;
{
  register struct type_hash *h;
  for (h = type_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
    if (h->hashcode == hashcode
	&& TREE_CODE (h->type) == TREE_CODE (type)
	&& TREE_TYPE (h->type) == TREE_TYPE (type)
	&& (TYPE_MAX_VALUE (h->type) == TYPE_MAX_VALUE (type)
	    || tree_int_cst_equal (TYPE_MAX_VALUE (h->type),
				   TYPE_MAX_VALUE (type)))
	&& (TYPE_MIN_VALUE (h->type) == TYPE_MIN_VALUE (type)
	    || tree_int_cst_equal (TYPE_MIN_VALUE (h->type),
				   TYPE_MIN_VALUE (type)))
	&& (TYPE_DOMAIN (h->type) == TYPE_DOMAIN (type)
	    || (TYPE_DOMAIN (h->type)
		&& TREE_CODE (TYPE_DOMAIN (h->type)) == TREE_LIST
		&& TYPE_DOMAIN (type)
		&& TREE_CODE (TYPE_DOMAIN (type)) == TREE_LIST
		&& type_list_equal (TYPE_DOMAIN (h->type), TYPE_DOMAIN (type)))))
      return h->type;
  return 0;
}
void
type_hash_add (hashcode, type)
     int hashcode;
     tree type;
{
  register struct type_hash *h;
  h = (struct type_hash *) oballoc (sizeof (struct type_hash));
  h->hashcode = hashcode;
  h->type = type;
  h->next = type_hash_table[hashcode % TYPE_HASH_SIZE];
  type_hash_table[hashcode % TYPE_HASH_SIZE] = h;
}
int debug_no_type_hash = 0;
tree
type_hash_canon (hashcode, type)
     int hashcode;
     tree type;
{
  tree t1;
  if (debug_no_type_hash)
    return type;
  t1 = type_hash_lookup (hashcode, type);
  if (t1 != 0)
    {
      struct obstack *o
	= TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
      obstack_free (o, type);
      tree_node_counts[(int)t_kind]--;
      tree_node_sizes[(int)t_kind] -= sizeof (struct tree_type);
      return t1;
    }
    if (current_obstack == &permanent_obstack)
    type_hash_add (hashcode, type);
  return type;
}
int
type_list_equal (l1, l2)
     tree l1, l2;
{
  register tree t1, t2;
  for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
    {
      if (TREE_VALUE (t1) != TREE_VALUE (t2))
	return 0;
      if (TREE_PURPOSE (t1) != TREE_PURPOSE (t2))
	{
	  int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
	  if (cmp < 0)
	    abort ();
	  if (cmp == 0)
	    return 0;
	}
    }
  return t1 == t2;
}
int
tree_int_cst_equal (t1, t2)
     tree t1, t2;
{
  if (t1 == t2)
    return 1;
  if (t1 == 0 || t2 == 0)
    return 0;
  if (TREE_CODE (t1) == INTEGER_CST
      && TREE_CODE (t2) == INTEGER_CST
      && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
      && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
    return 1;
  return 0;
}
int
tree_int_cst_lt (t1, t2)
     tree t1, t2;
{
  if (t1 == t2)
    return 0;
  if (!TREE_UNSIGNED (TREE_TYPE (t1)))
    return INT_CST_LT (t1, t2);
  return INT_CST_LT_UNSIGNED (t1, t2);
}
int
simple_cst_list_equal (l1, l2)
     tree l1, l2;
{
  while (l1 != NULL_TREE && l2 != NULL_TREE)
    {
      int cmp = simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2));
      if (cmp < 0)
	abort ();
      if (cmp == 0)
	return 0;
      l1 = TREE_CHAIN (l1);
      l2 = TREE_CHAIN (l2);
    }
  return (l1 == l2);
}
int
simple_cst_equal (t1, t2)