tree_no_comment.c

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

{
  register tree t;
  register enum tree_code code = TREE_CODE (node);
  register int length;
  register int i;
  switch (TREE_CODE_CLASS (code))
    {
    case 'd':        length = sizeof (struct tree_decl);
      break;
    case 't':        length = sizeof (struct tree_type);
      break;
    case 'r':      case 'e':      case 's':      case '<':      case '1':      case '2':        length = sizeof (struct tree_exp)
	+ (tree_code_length[(int) code] - 1) * sizeof (char *);
      break;
    case 'c':              if (code == REAL_CST)
	{
	  length = sizeof (struct tree_real_cst);
	  break;
	}
    case 'x':        length = sizeof (struct tree_common)
	+ tree_code_length[(int) code] * sizeof (char *);
      if (code == TREE_VEC)
	length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
    }
  t = (tree) obstack_alloc (current_obstack, length);
  for (i = ((length + sizeof (int) - 1) / sizeof (int)) - 1;
       i >= 0;
       i--)
    ((int *) t)[i] = ((int *) node)[i];
  TREE_CHAIN (t) = 0;
  TREE_PERMANENT (t) = (current_obstack == &permanent_obstack);
  return t;
}
tree
copy_list (list)
     tree list;
{
  tree head;
  register tree prev, next;
  if (list == 0)
    return 0;
  head = prev = copy_node (list);
  next = TREE_CHAIN (list);
  while (next)
    {
      TREE_CHAIN (prev) = copy_node (next);
      prev = TREE_CHAIN (prev);
      next = TREE_CHAIN (next);
    }
  return head;
}

tree
get_identifier (text)
     register char *text;
{
  register int hi;
  register int i;
  register tree idp;
  register int len, hash_len;
    for (len = 0; text[len]; len++);
    hash_len = len;
  if (warn_id_clash && len > id_clash_len)
    hash_len = id_clash_len;
    hi = hash_len * 613 + (unsigned)text[0];
  for (i = 1; i < hash_len; i += 2)
    hi = ((hi * 613) + (unsigned)(text[i]));
  hi &= (1 << HASHBITS) - 1;
  hi %= MAX_HASH_TABLE;
    for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
    if (IDENTIFIER_LENGTH (idp) == len
	&& IDENTIFIER_POINTER (idp)[0] == text[0]
	&& !bcmp (IDENTIFIER_POINTER (idp), text, len))
      return idp;		    if (warn_id_clash && do_identifier_warnings && len >= id_clash_len)
    for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
      if (!strncmp (IDENTIFIER_POINTER (idp), text, id_clash_len))
	{
	  warning ("`%s' and `%s' identical in first %d characters",
		   IDENTIFIER_POINTER (idp), text, id_clash_len);
	  break;
	}
  if (tree_code_length[(int) IDENTIFIER_NODE] < 0)
    abort ();			    idp = make_node (IDENTIFIER_NODE);
  IDENTIFIER_LENGTH (idp) = len;
  id_string_size += len;
  IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len);
  TREE_CHAIN (idp) = hash_table[hi];
  hash_table[hi] = idp;
  return idp;			}
void
start_identifier_warnings ()
{
  do_identifier_warnings = 1;
}
void
set_identifier_size (size)
     int size;
{
  tree_code_length[(int) IDENTIFIER_NODE]
    = (size - sizeof (struct tree_common)) / sizeof (tree);
}

tree
build_int_2 (low, hi)
     int low, hi;
{
  register tree t = make_node (INTEGER_CST);
  TREE_INT_CST_LOW (t) = low;
  TREE_INT_CST_HIGH (t) = hi;
  TREE_TYPE (t) = integer_type_node;
  return t;
}
tree
build_real (type, d)
     tree type;
     REAL_VALUE_TYPE d;
{
  tree v;
    CHECK_FLOAT_VALUE (TYPE_MODE (type), d);
  v = make_node (REAL_CST);
  TREE_TYPE (v) = type;
  TREE_REAL_CST (v) = d;
  return v;
}
REAL_VALUE_TYPE
real_value_from_int_cst (i)
     tree i;
{
  REAL_VALUE_TYPE d;
  REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i));
  if (TREE_INT_CST_HIGH (i) < 0)
    {
      d = (double) (~ TREE_INT_CST_HIGH (i));
      d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
	    * (double) (1 << (HOST_BITS_PER_INT / 2)));
      d += (double) (unsigned) (~ TREE_INT_CST_LOW (i));
      d = (- d - 1.0);
    }
  else
    {
      d = (double) TREE_INT_CST_HIGH (i);
      d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
	    * (double) (1 << (HOST_BITS_PER_INT / 2)));
      d += (double) (unsigned) TREE_INT_CST_LOW (i);
    }
  return d;
}
tree
build_real_from_int_cst (type, i)
     tree type;
     tree i;
{
  tree v;
  REAL_VALUE_TYPE d;
  v = make_node (REAL_CST);
  TREE_TYPE (v) = type;
  d = real_value_from_int_cst (i);
    CHECK_FLOAT_VALUE (TYPE_MODE (type), d);
  TREE_REAL_CST (v) = d;
  return v;
}
tree
build_string (len, str)
     int len;
     char *str;
{
  register tree s = make_node (STRING_CST);
  TREE_STRING_LENGTH (s) = len;
  TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len);
  return s;
}
tree
build_complex (real, imag)
     tree real, imag;
{
  register tree t = make_node (COMPLEX_CST);
  TREE_REALPART (t) = real;
  TREE_IMAGPART (t) = imag;
  return t;
}
tree
make_tree_vec (len)
     int len;
{
  register tree t;
  register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
  register struct obstack *obstack = current_obstack;
  register int i;
  tree_node_counts[(int)vec_kind]++;
  tree_node_sizes[(int)vec_kind] += length;
  t = (tree) obstack_alloc (obstack, length);
  TREE_TYPE (t) = 0;
  TREE_CHAIN (t) = 0;
  for (i = (length / sizeof (int)) - 1;
       i >= sizeof (struct tree_common) / sizeof (int) - 1;
       i--)
    ((int *) t)[i] = 0;
  TREE_SET_CODE (t, TREE_VEC);
  TREE_VEC_LENGTH (t) = len;
  if (obstack == &permanent_obstack)
    TREE_PERMANENT (t) = 1;
  return t;
}

int
integer_zerop (expr)
     tree expr;
{
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  return (TREE_CODE (expr) == INTEGER_CST
	  && TREE_INT_CST_LOW (expr) == 0
	  && TREE_INT_CST_HIGH (expr) == 0);
}
int
integer_onep (expr)
     tree expr;
{
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  return (TREE_CODE (expr) == INTEGER_CST
	  && TREE_INT_CST_LOW (expr) == 1
	  && TREE_INT_CST_HIGH (expr) == 0);
}
int
integer_all_onesp (expr)
     tree expr;
{
  register int prec;
  register int uns;
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  if (TREE_CODE (expr) != INTEGER_CST)
    return 0;
  uns = TREE_UNSIGNED (TREE_TYPE (expr));
  if (!uns)
    return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
  prec = TYPE_PRECISION (TREE_TYPE (expr));
  if (prec >= HOST_BITS_PER_INT)
    {
      int high_value, shift_amount;
      shift_amount = prec - HOST_BITS_PER_INT;
      if (shift_amount > HOST_BITS_PER_INT)
		abort ();
      else if (shift_amount == HOST_BITS_PER_INT)
		high_value = -1;
      else
	high_value = (1 << shift_amount) - 1;
      return TREE_INT_CST_LOW (expr) == -1
	&& TREE_INT_CST_HIGH (expr) == high_value;
    }
  else
    return TREE_INT_CST_LOW (expr) == (1 << prec) - 1;
}
int
integer_pow2p (expr)
     tree expr;
{
  int high, low;
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  if (TREE_CODE (expr) != INTEGER_CST)
    return 0;
  high = TREE_INT_CST_HIGH (expr);
  low = TREE_INT_CST_LOW (expr);
  if (high == 0 && low == 0)
    return 0;
  return ((high == 0 && (low & (low - 1)) == 0)
	  || (low == 0 && (high & (high - 1)) == 0));
}
int
real_zerop (expr)
     tree expr;
{
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  return (TREE_CODE (expr) == REAL_CST
	  && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0));
}
int
real_onep (expr)
     tree expr;
{
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  return (TREE_CODE (expr) == REAL_CST
	  && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1));
}
int
real_twop (expr)
     tree expr;
{
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    expr = TREE_OPERAND (expr, 0);
  return (TREE_CODE (expr) == REAL_CST
	  && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2));
}
int
really_constant_p (exp)
     tree exp;
{
  while (TREE_CODE (exp) == NOP_EXPR
	 || TREE_CODE (exp) == CONVERT_EXPR
	 || TREE_CODE (exp) == NON_LVALUE_EXPR)
    exp = TREE_OPERAND (exp, 0);
  return TREE_CONSTANT (exp);
}

tree
value_member (elem, list)
     tree elem, list;
{
  while (list)
    {
      if (elem == TREE_VALUE (list))
	return list;
      list = TREE_CHAIN (list);
    }
  return NULL_TREE;
}
tree
purpose_member (elem, list)
     tree elem, list;
{
  while (list)
    {
      if (elem == TREE_PURPOSE (list))
	return list;
      list = TREE_CHAIN (list);
    }
  return NULL_TREE;
}
tree
binfo_member (elem, list)
     tree elem, list;
{
  while (list)
    {
      if (elem == BINFO_TYPE (list))
	return list;
      list = TREE_CHAIN (list);
    }
  return NULL_TREE;
}
int
chain_member (elem, chain)
     tree elem, chain;
{
  while (chain)
    {
      if (elem == chain)
	return 1;
      chain = TREE_CHAIN (chain);
    }
  return 0;
}
int
list_length (t)
     tree t;
{
  register tree tail;
  register int len = 0;
  for (tail = t; tail; tail = TREE_CHAIN (tail))
    len++;
  return len;
}
tree
chainon (op1, op2)
     tree op1, op2;
{
  tree t;
  if (op1)
    {
      for (t = op1; TREE_CHAIN (t); t = TREE_CHAIN (t))
	if (t == op2) abort ();	      TREE_CHAIN (t) = op2;
      return op1;
    }
  else return op2;
}
tree
tree_last (chain)
     register tree chain;
{
  register tree next;
  if (chain)
    while (next = TREE_CHAIN (chain))
      chain = next;
  return chain;
}
tree
nreverse (t)
     tree t;
{
  register tree prev = 0, decl, next;
  for (decl = t; decl; decl = next)
    {
      next = TREE_CHAIN (decl);
      TREE_CHAIN (decl) = prev;
      prev = decl;
    }
  return prev;
}
tree
listify (chain)
     tree chain;
{
  tree result = NULL_TREE;
  tree in_tail = chain;
  tree out_tail = NULL_TREE;
  while (in_tail)
    {
      tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
      if (out_tail)
	TREE_CHAIN (out_tail) = next;
      else
	result = next;
      out_tail = next;
      in_tail = TREE_CHAIN (in_tail);
    }
  return result;
}

tree
build_tree_list (parm, value)
     tree parm, value;
{
  register tree t = make_node (TREE_LIST);
  TREE_PURPOSE (t) = parm;
  TREE_VALUE (t) = value;
  return t;
}
tree
build_decl_list (parm, value)
     tree parm, value;
{
  register tree node;
  register struct obstack *ambient_obstack = current_obstack;
  current_obstack = &temp_decl_obstack;
  node = build_tree_list (parm, value);
  current_obstack = ambient_obstack;
  return node;
}
tree
tree_cons (purpose, value, chain)
     tree purpose, value, chain;
{
  register tree node = make_node (TREE_LIST);
  register int i;
  register tree node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list));
  tree_node_counts[(int)x_kind]++;
  tree_node_sizes[(int)x_kind] += sizeof (struct tree_list);
  ((int *)node)[(sizeof (struct tree_common)/sizeof (int)) - 1] = 0;
  TREE_SET_CODE (node, TREE_LIST);
  if (current_obstack == &permanent_obstack)
    TREE_PERMANENT (node) = 1;
  TREE_TYPE (node) = 0;
  TREE_CHAIN (node) = chain;
  TREE_PURPOSE (node) = purpose;
  TREE_VALUE (node) = value;
  return node;
}
tree
decl_tree_cons (purpose, value, chain)
     tree purpose, value, chain;
{
  register tree node;
  register struct obstack *ambient_obstack = current_obstack;
  current_obstack = &temp_decl_obstack;
  node = tree_cons (purpose, value, chain);
  current_obstack = ambient_obstack;
  return node;
}
tree
perm_tree_cons (purpose, value, chain)
     tree purpose, value, chain;
{
  register tree node;
  register struct obstack *ambient_obstack = current_obstack;
  current_obstack = &permanent_obstack;
  node = tree_cons (purpose, value, chain);
  current_obstack = ambient_obstack;
  return node;
}
tree
temp_tree_cons (purpose, value, chain)
     tree purpose, value, chain;
{
  register tree node;
  register struct obstack *ambient_obstack = current_obstack;
  current_obstack = &temporary_obstack;
  node = tree_cons (purpose, value, chain);
  current_obstack = ambient_obstack;
  return node;
}
tree
saveable_tree_cons (purpose, value, chain)
     tree purpose, value, chain;
{
  register tree node;
  register struct obstack *ambient_obstack = current_obstack;
  current_obstack = saveable_obstack;
  node = tree_cons (purpose, value, chain);
  current_obstack = ambient_obstack;
  return node;
}