[cparse] / expr.c

#include "cparse.h"

struct expression *expr(enum expression_type type, const struct location *where) {
  struct expression *e;

  NEW(e);
  e->type = type;
  e->where = *where;
  return e;
}

struct expression *binary(int op,
			  struct expression *l,
			  struct expression *r,
			  const struct location *where) {
  struct expression *e;
  struct declarator *valuetype = 0;

  /* all binary operators require array decay (C99 6.3.2.1) */
  l = array_decay(l);
  r = array_decay(r);

  if(l->valuetype && r->valuetype) {
    switch(op) {
    case '[':
      /* C99 6.5.2.1 */
      
      /* one side must be pointer to T, the other integral, the result type
       * is T */
      if(is_integral_type(l->valuetype)
	 && is_pointer_type(r->valuetype)) {
	valuetype = target_type(r->valuetype);
      } else if(is_pointer_type(l->valuetype)
		&& is_integral_type(r->valuetype)) {
	valuetype = target_type(l->valuetype);
      } else {
	inputerror(where, "invalid operands to [] operator");
#if 1
	{
	  dump_state *dump = dump_new(stderr);
	  dump_locations(dump, 0);
	  dump_declaration_specifiers(dump,
				      l->valuetype->declaration_specifiers,
				      2);
	  dump_declarator(dump, l->valuetype, 2);
	  fputc('\n', stderr);
	  
	  dump = dump_new(stderr);
	  dump_locations(dump, 0);
	  dump_declaration_specifiers(dump,
				      r->valuetype->declaration_specifiers,
				      2);
	  dump_declarator(dump, r->valuetype, 2);
	  fputc('\n', stderr);
	  abort();
	}
#endif
      }
      break;
      
    case '.':
    case MEMBER:
      /* XXX */
      break;

    case '*':
    case '/':
      /* C99 6.5.5 */
      if(!is_arithmetic_type(l->valuetype)
	 || !is_arithmetic_type(r->valuetype))
	inputerror(where, "arguments to %c must have arithmetic type");
      else
	valuetype = usual_arithmetic_conversions(&l, &r, where);
      break;

    case '%':
      /* C99 6.5.5 */
      if(!is_integral_type(l->valuetype)
	 || !is_integral_type(r->valuetype))
	inputerror(where, "arguments to %c must have integral type", op);
      else
	valuetype = usual_arithmetic_conversions(&l, &r, where);
      break;
      
    case '+':
    case '-':
      /* C99 6.5.6 */
      /* XXX constraints */
      if(is_arithmetic_type(l->valuetype)
	 && is_arithmetic_type(r->valuetype))
	valuetype = usual_arithmetic_conversions(&l, &r, where);
      /* XXX pointers */
      break;
      
    case SL:
    case SR:
      /* C99 6.5.7 */
      /* XXX constraints */
      if(!is_integral_type(l->valuetype)
	 || !is_integral_type(r->valuetype))
	inputerror(where,
		   "arguments to shift operators must have integral type");
      else {
	l = integer_promotions(l);
	r = integer_promotions(r);
	valuetype = l->valuetype;
      }
      break;

      break;

    case '<':
    case '>':
    case LE:
    case GE:
      /* C99 6.5.8 */
      /* XXX constraints */
      if(is_arithmetic_type(l->valuetype)
	 && is_arithmetic_type(r->valuetype))
	usual_arithmetic_conversions(&l, &r, where);
      /* XXX valuetype */
      break;
      
    case EQ:
    case NE:
      /* C99 6.5.9 */
      break;
      
    case '&':
    case '|':
    case '^':
      /* C99 6.5.10-12 */
      if(!is_integral_type(l->valuetype)
	 || !is_integral_type(r->valuetype))
	inputerror(where, "arguments to %c must have integral type", op);
      else
	valuetype = usual_arithmetic_conversions(&l, &r, where);
      break;

    case AND:
    case OR:
      /* C99 6.5.13-14 */
      if(!is_scalar_type(l->valuetype)
	 || !is_scalar_type(r->valuetype))
	inputerror(where,
		   "arguments to logical operators must have scalar type", op);
      /* XXX valuetype */
      break;

    case ':':
      /* C99 6.5.15 */
      /* XXX constraints */
      /* XXX valuetype */
      break;

    case '?':
      /* C99 6.5.15 */
      if(!is_scalar_type(l->valuetype))
	inputerror(where,
		   "left argument of ? operator must have scalar type");
      /* XXX valuetype will be bad until ':' is done */
      break;

      /* XXX assignment operators */
      
    }
  }
  e = expr(ex_binary, where);
  e->operator = op;
  e->u.binary.l = l;
  e->u.binary.r = r;
  e->valuetype = valuetype;
  return e;
}

  struct expression *prefix(int op, struct expression *r,
			  const struct location *where) {
  struct expression *e = expr(ex_prefix, where);
  e->operator = op;
  e->u.unary = r;
  /* XXX constraints */
  /* XXX valuetype */
  return e;
}

struct expression *postfix(int op, struct expression *l,
			   const struct location *where) {
  struct expression *e = expr(ex_postfix, where);
  e->operator = op;
  e->u.unary = l;
  /* XXX constraints */
  /* XXX valuetype */
  return e;
}

struct expression *paren(struct expression *content,
			 const struct location *where) {
  struct expression *e = expr(ex_paren, where);
  e->u.unary = content;
  e->valuetype = content->valuetype;
  return e;
}

/* array-to-pointer decay (C99 6.3.2.1) */
struct expression *array_decay(struct expression *e) {
  struct expression *ne;
  struct declarator_type *dt;

  if(e->valuetype
     && e->valuetype->declarator_type
     && e->valuetype->declarator_type->type == dt_array) {
    NEW(ne);
    ne->type = ex_implicit_conversion;
    NEW(ne->valuetype);
    *ne->valuetype = *e->valuetype;
    NEW(dt);
    dt->type = dt_pointer;
    dt->type_qualifiers = e->valuetype->declarator_type->type_qualifiers;
    dt->next = e->valuetype->declarator_type->next;
    ne->valuetype->declarator_type = dt;
    ne->u.cast = e;
    return ne;
  }
  return e;
}

/* integral promotions (C99 6.3.1.1)
 * anything >= (unsigned) int stays as it is
 * otherwise if int is good enough we use that
 * otherwise we use unsigned
 *
 * This function determines the promoted type of e, or returns 0 if it does not
 * have known or integral type.
 */

static unsigned long integer_promoted_type(struct expression *e) {
  unsigned long basic, size, sign, ts;

  if(!e->valuetype || e->valuetype->declarator_type) return 0;
  ts = e->valuetype->declaration_specifiers->type_specifiers;
  basic = e->valuetype->declaration_specifiers->type_specifiers & TS__BASIC;
  if(basic == TS_ENUM) {
    ts = e->valuetype->declaration_specifiers->enum_compat_type;
    basic = e->valuetype->declaration_specifiers->type_specifiers & TS__BASIC;
  }
  size = e->valuetype->declaration_specifiers->type_specifiers & TS__LENGTH;
  sign = e->valuetype->declaration_specifiers->type_specifiers & TS__SIGN;
  switch(basic) {
  case 0:
  case TS_INT:
    if(size == TS_SHORT) {
      if(sign == TS_UNSIGNED) {
	/* unsigned short */
	if(P_USHRT_MAX <= P_INT_MAX)
	  return TS_INT;
	else
	  return TS_UNSIGNED;
      } else {
	/* (signed) short */
	return TS_INT;
      }
    }
    break;
  case TS_CHAR:
    if(sign == TS_UNSIGNED || (!sign && CHAR_MIN == 0)) {
      /* (unsigned) char */
      if(P_UCHAR_MAX <= P_INT_MAX)
	return TS_INT;
      else
	return TS_UNSIGNED;
    } else if(sign == TS_SIGNED || (!sign && CHAR_MIN < 0)) {
      /* (signed) char */
      return TS_INT;
    }
    break;

  case TS_BOOL:
    return TS_INT;
    break;

    /* XXX bit fields? */
  }
  return ts;
}

/* add an implicit conversion performing integer promotions if necessary */
struct expression *integer_promotions(struct expression *e) {
  struct expression *ne;
  unsigned long ts;

  if(e->valuetype
     && !e->valuetype->declarator_type) {
    ts = integer_promoted_type(e);
    if(ts != e->valuetype->declaration_specifiers->type_specifiers) {
      NEW(ne);
      ne->type = ex_implicit_conversion;
      NEW(ne->valuetype);
      NEW(ne->valuetype->declaration_specifiers);
      ne->valuetype->declaration_specifiers->type_specifiers = ts;
      ne->u.cast = e;
      return ne;
    }
  }
  return e;
}

static unsigned long corresponding_real_type(struct declarator *d) {
  unsigned long u;

  if(!d->declarator_type)
    switch((u = d->declaration_specifiers->type_specifiers & ~TS__CI)) {
    case TS_FLOAT:
    case TS_DOUBLE:
    case TS_LONG|TS_DOUBLE:
      return u;
    }
  return 0;
}

static struct expression *simple_implicit_conversion
     (struct expression *e,
      unsigned long nt,
      const struct location *where) {
  struct expression *ne;
  struct declarator *d;

  assert(e->valuetype != 0);
  assert(e->valuetype->declarator_type == 0);
  if(nt == e->valuetype->declaration_specifiers->type_specifiers)
    return e;
  NEW(d);
  NEW(d->declaration_specifiers);
  d->declaration_specifiers->type_specifiers = nt;
  d->where = *where;
  ne = expr(ex_implicit_conversion, where);
  ne->valuetype = d;
  ne->u.cast = e;
  return ne;
}

static const unsigned long rank_table[] = {
  TS_BOOL,
  TS_CHAR,
  TS_SHORT|TS_INT,
  TS_INT,
  TS_LONG|TS_INT,
  TS_LONGLONG|TS_INT
};

static int rank(const struct declaration_specifiers *d) {
  unsigned n;
  unsigned long t = d->type_specifiers;

  if((t & TS__BASIC) == TS_ENUM)
    t = d->enum_compat_type;
  t &= (TS__BASIC|TS__LENGTH);
  if(t & TS__BASIC)
    t |= TS_INT;
  for(n = 0; n < sizeof rank_table / sizeof *rank_table; ++n)
    if(rank_table[n] == t)
      return n;
  return -1;
}

static int sign(const struct declaration_specifiers *d) {
  unsigned long t = d->type_specifiers;

  if((t & TS__BASIC) == TS_ENUM)
    t = d->enum_compat_type;
  if(t & TS__SIGN)
    return t & TS__SIGN;
  switch(t & TS__BASIC) {
  case TS_BOOL:
    return TS_UNSIGNED;			/* XXX erm */
  case TS_CHAR:
    return TS_SIGNED;			/* XXX depends on compiler */
  default:
    return TS_SIGNED;			/* everything else is signed */
  }
}

/* C99 6.3.1.8 */
struct declarator *usual_arithmetic_conversions(struct expression **lp,
						struct expression **rp,
						const struct location *where) {
  struct expression *l = *lp, *r = *rp;
  unsigned long lcrt, rcrt;		/* common real type */
  unsigned long lpt, rpt;		/* integer-promoted type */
  unsigned long lsign, rsign;		/* sign bits */
  int lrank, rrank;			/* ranks */

  /* if type is unknown do nothing */
  if(!l->valuetype || !r->valuetype) return 0;

  /* find corresponding real type */
  lcrt = corresponding_real_type(l->valuetype);
  rcrt = corresponding_real_type(r->valuetype);
  if(rcrt > lcrt)
    return usual_arithmetic_conversions(rp, lp, where);
  if(lcrt > rcrt) {
    *rp = simple_implicit_conversion
           (r,
	    lcrt
	    | (r->valuetype->declaration_specifiers->type_specifiers & TS__CI),
	    where);
    return 0;
  }

  /* integer promotions */
  lpt = integer_promoted_type(l);
  l = simple_implicit_conversion(l, lpt, where);
  rpt = integer_promoted_type(r);
  r = simple_implicit_conversion(r, rpt, where);
  
  /* rules for promoted operands */
  if(lpt && rpt && lpt != rpt) {
    lrank = rank(l->valuetype->declaration_specifiers);
    rrank = rank(r->valuetype->declaration_specifiers);
    lsign = sign(l->valuetype->declaration_specifiers);
    rsign = sign(r->valuetype->declaration_specifiers);
    /* same signedness -> highest rank wins */
    if(lsign == rsign) {
      if(lrank > rrank)
	rpt = lpt;
      else
	lpt = rpt;
    /* if rank(unsigned type) >= rank(signed type), unsigned type wins */
    } else if(lsign == TS_UNSIGNED && lrank >= rrank)
      rpt = lpt;
    else if(rsign == TS_UNSIGNED && rrank >= lrank)
      lpt = rpt;
    /* if signed type \superset unsigned type, signed type wins */
    else if(lsign == TS_SIGNED && width(lpt) > width(rpt))
      rpt = lpt;
    else if(rsign == TS_SIGNED && width(rpt) > width(lpt))
      lpt = rpt;
    /* otherwise convert both to the unsigned type matching the signed type */
    else if(lsign == TS_SIGNED)
      rpt = lpt = (lpt & ~TS__SIGN) | TS_UNSIGNED;
    else 
      rpt = lpt = (rpt & ~TS__SIGN) | TS_UNSIGNED;
    l = simple_implicit_conversion(l, lpt, where);
    r = simple_implicit_conversion(r, rpt, where);
  }

  /* pass the answers back */
  *lp = l;
  *rp = r;

  return l->valuetype;
}

struct expression *stringexpr(enum expression_type type,
			      char *value,
			      const struct location *where) {
  struct expression *e;

  e = expr(type, where);
  e->u.constant = value;
  NEW(e->valuetype);
  NEW(e->valuetype->declaration_specifiers);
  switch(type) {
  case ex_string:
    e->valuetype->declaration_specifiers->type_specifiers = TS_CHAR;
    break;
  case ex_char:
    e->valuetype->declaration_specifiers->type_specifiers = TS_INT;
    break;
  case ex_wstring:
    e->valuetype->declaration_specifiers->type_specifiers = P_WCHAR_T;
    break;
  case ex_wchar:
    e->valuetype->declaration_specifiers->type_specifiers = P_WCHAR_T;
    break;
  default:
    abort();
  }
  if(type == ex_string || type == ex_wstring) {
    if(constant_string_literals)
      e->valuetype->declaration_specifiers->type_qualifiers = TQ_CONST;
    NEW(e->valuetype->declarator_type);
    e->valuetype->declarator_type->type = dt_pointer;
  }
  NEW(e->valuetype->declarator_type);
  e->valuetype->declarator_type->type = dt_pointer;
  return e;
}

struct expression *fncallexpr(struct expression *f,
			      struct expression_list *l,
			      const struct location *where) {
  struct declarator_type *dt;
  struct expression *e;
  
  e = expr(ex_fncall, where);
  e->u.fncall.fn = f;
  e->u.fncall.args = l;
  if(f->valuetype) {
    /* f can either be a function or a pointer to a function (but not e.g. a
     * pointer to a pointer to a function) */
    dt = f->valuetype->declarator_type;
    if(dt && dt->type == dt_pointer)
      dt = dt->next;
  } else
    dt = 0;
  if(dt && (dt->type == dt_function
	    || dt->type == dt_old_function))
    e->valuetype = target_type(f->valuetype);
  else
    inputerror(where, "left operand to () operator is not a function");
  return e;
} 

/*
Local Variables:
c-basic-offset:2
comment-column:40
fill-column:79
End:
*/
Commit	Line	Data
3cd4b0f8 MW	1	#include "cparse.h"
	2
	3	struct expression expr(enum expression_type type, const struct location where) {
	4	struct expression *e;
	5
	6	NEW(e);
	7	e->type = type;
	8	e->where = *where;
	9	return e;
	10	}
	11
	12	struct expression *binary(int op,
	13	struct expression *l,
	14	struct expression *r,
	15	const struct location *where) {
	16	struct expression *e;
	17	struct declarator *valuetype = 0;
	18
	19	/* all binary operators require array decay (C99 6.3.2.1) */
	20	l = array_decay(l);
	21	r = array_decay(r);
	22
	23	if(l->valuetype && r->valuetype) {
	24	switch(op) {
	25	case '[':
	26	/* C99 6.5.2.1 */
	27
	28	/* one side must be pointer to T, the other integral, the result type
	29	* is T */
	30	if(is_integral_type(l->valuetype)
	31	&& is_pointer_type(r->valuetype)) {
	32	valuetype = target_type(r->valuetype);
	33	} else if(is_pointer_type(l->valuetype)
	34	&& is_integral_type(r->valuetype)) {
	35	valuetype = target_type(l->valuetype);
	36	} else {
	37	inputerror(where, "invalid operands to [] operator");
	38	#if 1
	39	{
	40	dump_state *dump = dump_new(stderr);
	41	dump_locations(dump, 0);
	42	dump_declaration_specifiers(dump,
	43	l->valuetype->declaration_specifiers,
	44	2);
	45	dump_declarator(dump, l->valuetype, 2);
	46	fputc('\n', stderr);
	47
	48	dump = dump_new(stderr);
	49	dump_locations(dump, 0);
	50	dump_declaration_specifiers(dump,
	51	r->valuetype->declaration_specifiers,
	52	2);
	53	dump_declarator(dump, r->valuetype, 2);
	54	fputc('\n', stderr);
	55	abort();
	56	}
	57	#endif
	58	}
	59	break;
	60
	61	case '.':
	62	case MEMBER:
	63	/* XXX */
	64	break;
65
66	case '*':
67	case '/':
68	/* C99 6.5.5 */
69	if(!is_arithmetic_type(l->valuetype)
70	\|\| !is_arithmetic_type(r->valuetype))
71	inputerror(where, "arguments to %c must have arithmetic type");
72	else
73	valuetype = usual_arithmetic_conversions(&l, &r, where);
74	break;
75
76	case '%':
77	/* C99 6.5.5 */
78	if(!is_integral_type(l->valuetype)
79	\|\| !is_integral_type(r->valuetype))
80	inputerror(where, "arguments to %c must have integral type", op);
81	else
82	valuetype = usual_arithmetic_conversions(&l, &r, where);
83	break;
84
85	case '+':
86	case '-':
87	/* C99 6.5.6 */
88	/* XXX constraints */
89	if(is_arithmetic_type(l->valuetype)
90	&& is_arithmetic_type(r->valuetype))
91	valuetype = usual_arithmetic_conversions(&l, &r, where);
92	/* XXX pointers */
93	break;
94
95	case SL:
96	case SR:
97	/* C99 6.5.7 */
98	/* XXX constraints */
99	if(!is_integral_type(l->valuetype)
100	\|\| !is_integral_type(r->valuetype))
101	inputerror(where,
102	"arguments to shift operators must have integral type");
103	else {
104	l = integer_promotions(l);
105	r = integer_promotions(r);
106	valuetype = l->valuetype;
107	}
108	break;
109
110	break;
111
112	case '<':
113	case '>':
114	case LE:
115	case GE:
116	/* C99 6.5.8 */
117	/* XXX constraints */
118	if(is_arithmetic_type(l->valuetype)
119	&& is_arithmetic_type(r->valuetype))
120	usual_arithmetic_conversions(&l, &r, where);
121	/* XXX valuetype */
122	break;
123
124	case EQ:
125	case NE:
126	/* C99 6.5.9 */
127	break;
128
129	case '&':
130	case '\|':
131	case '^':
132	/* C99 6.5.10-12 */
133	if(!is_integral_type(l->valuetype)
134	\|\| !is_integral_type(r->valuetype))
135	inputerror(where, "arguments to %c must have integral type", op);
136	else
137	valuetype = usual_arithmetic_conversions(&l, &r, where);
138	break;
139
140	case AND:
141	case OR:
142	/* C99 6.5.13-14 */
143	if(!is_scalar_type(l->valuetype)
144	\|\| !is_scalar_type(r->valuetype))
145	inputerror(where,
146	"arguments to logical operators must have scalar type", op);
147	/* XXX valuetype */
148	break;
149
150	case ':':
151	/* C99 6.5.15 */
152	/* XXX constraints */
153	/* XXX valuetype */
154	break;
155
156	case '?':
157	/* C99 6.5.15 */
158	if(!is_scalar_type(l->valuetype))
159	inputerror(where,
160	"left argument of ? operator must have scalar type");
161	/* XXX valuetype will be bad until ':' is done */
162	break;
163
164	/* XXX assignment operators */
165
166	}
167	}
168	e = expr(ex_binary, where);
169	e->operator = op;
170	e->u.binary.l = l;
171	e->u.binary.r = r;
172	e->valuetype = valuetype;
173	return e;
174	}
175
176	struct expression prefix(int op, struct expression r,
177	const struct location *where) {
178	struct expression *e = expr(ex_prefix, where);
179	e->operator = op;
180	e->u.unary = r;
181	/* XXX constraints */
182	/* XXX valuetype */
183	return e;
184	}
185
186	struct expression postfix(int op, struct expression l,
187	const struct location *where) {
188	struct expression *e = expr(ex_postfix, where);
189	e->operator = op;
190	e->u.unary = l;
191	/* XXX constraints */
192	/* XXX valuetype */
193	return e;
194	}
195
196	struct expression paren(struct expression content,
197	const struct location *where) {
198	struct expression *e = expr(ex_paren, where);
199	e->u.unary = content;
200	e->valuetype = content->valuetype;
201	return e;
202	}
203
204	/* array-to-pointer decay (C99 6.3.2.1) */
205	struct expression array_decay(struct expression e) {
206	struct expression *ne;
207	struct declarator_type *dt;
208
209	if(e->valuetype
210	&& e->valuetype->declarator_type
211	&& e->valuetype->declarator_type->type == dt_array) {
212	NEW(ne);
213	ne->type = ex_implicit_conversion;
214	NEW(ne->valuetype);
215	ne->valuetype = e->valuetype;
216	NEW(dt);
217	dt->type = dt_pointer;
218	dt->type_qualifiers = e->valuetype->declarator_type->type_qualifiers;
219	dt->next = e->valuetype->declarator_type->next;
220	ne->valuetype->declarator_type = dt;
221	ne->u.cast = e;
222	return ne;
223	}
224	return e;
225	}
226
227	/* integral promotions (C99 6.3.1.1)
228	* anything >= (unsigned) int stays as it is
229	* otherwise if int is good enough we use that
230	* otherwise we use unsigned
231	*
232	* This function determines the promoted type of e, or returns 0 if it does not
233	* have known or integral type.
234	*/
235
236	static unsigned long integer_promoted_type(struct expression *e) {
237	unsigned long basic, size, sign, ts;
238
239	if(!e->valuetype \|\| e->valuetype->declarator_type) return 0;
240	ts = e->valuetype->declaration_specifiers->type_specifiers;
241	basic = e->valuetype->declaration_specifiers->type_specifiers & TS__BASIC;
242	if(basic == TS_ENUM) {
243	ts = e->valuetype->declaration_specifiers->enum_compat_type;
244	basic = e->valuetype->declaration_specifiers->type_specifiers & TS__BASIC;
245	}
246	size = e->valuetype->declaration_specifiers->type_specifiers & TS__LENGTH;
247	sign = e->valuetype->declaration_specifiers->type_specifiers & TS__SIGN;
248	switch(basic) {
249	case 0:
250	case TS_INT:
251	if(size == TS_SHORT) {
252	if(sign == TS_UNSIGNED) {
253	/* unsigned short */
254	if(P_USHRT_MAX <= P_INT_MAX)
255	return TS_INT;
256	else
257	return TS_UNSIGNED;
258	} else {
259	/* (signed) short */
260	return TS_INT;
261	}
262	}
263	break;
264	case TS_CHAR:
265	if(sign == TS_UNSIGNED \|\| (!sign && CHAR_MIN == 0)) {
266	/* (unsigned) char */
267	if(P_UCHAR_MAX <= P_INT_MAX)
268	return TS_INT;
269	else
270	return TS_UNSIGNED;
271	} else if(sign == TS_SIGNED \|\| (!sign && CHAR_MIN < 0)) {
272	/* (signed) char */
273	return TS_INT;
274	}
275	break;
276
277	case TS_BOOL:
278	return TS_INT;
279	break;
280
281	/* XXX bit fields? */
282	}
283	return ts;
284	}
285
286	/* add an implicit conversion performing integer promotions if necessary */
287	struct expression integer_promotions(struct expression e) {
288	struct expression *ne;
289	unsigned long ts;
290
291	if(e->valuetype
292	&& !e->valuetype->declarator_type) {
293	ts = integer_promoted_type(e);
294	if(ts != e->valuetype->declaration_specifiers->type_specifiers) {
295	NEW(ne);
296	ne->type = ex_implicit_conversion;
297	NEW(ne->valuetype);
298	NEW(ne->valuetype->declaration_specifiers);
299	ne->valuetype->declaration_specifiers->type_specifiers = ts;
300	ne->u.cast = e;
301	return ne;
302	}
303	}
304	return e;
305	}
306
307	static unsigned long corresponding_real_type(struct declarator *d) {
308	unsigned long u;
309
310	if(!d->declarator_type)
311	switch((u = d->declaration_specifiers->type_specifiers & ~TS__CI)) {
312	case TS_FLOAT:
313	case TS_DOUBLE:
314	case TS_LONG\|TS_DOUBLE:
315	return u;
316	}
317	return 0;
318	}
319
320	static struct expression *simple_implicit_conversion
321	(struct expression *e,
322	unsigned long nt,
323	const struct location *where) {
324	struct expression *ne;
325	struct declarator *d;
326
327	assert(e->valuetype != 0);
328	assert(e->valuetype->declarator_type == 0);
329	if(nt == e->valuetype->declaration_specifiers->type_specifiers)
330	return e;
331	NEW(d);
332	NEW(d->declaration_specifiers);
333	d->declaration_specifiers->type_specifiers = nt;
334	d->where = *where;
335	ne = expr(ex_implicit_conversion, where);
336	ne->valuetype = d;
337	ne->u.cast = e;
338	return ne;
339	}
340
341	static const unsigned long rank_table[] = {
342	TS_BOOL,
343	TS_CHAR,
344	TS_SHORT\|TS_INT,
345	TS_INT,
346	TS_LONG\|TS_INT,
347	TS_LONGLONG\|TS_INT
348	};
349
350	static int rank(const struct declaration_specifiers *d) {
351	unsigned n;
352	unsigned long t = d->type_specifiers;
353
354	if((t & TS__BASIC) == TS_ENUM)
355	t = d->enum_compat_type;
356	t &= (TS__BASIC\|TS__LENGTH);
357	if(t & TS__BASIC)
358	t \|= TS_INT;
359	for(n = 0; n < sizeof rank_table / sizeof *rank_table; ++n)
360	if(rank_table[n] == t)
361	return n;
362	return -1;
363	}
364
365	static int sign(const struct declaration_specifiers *d) {
366	unsigned long t = d->type_specifiers;
367
368	if((t & TS__BASIC) == TS_ENUM)
369	t = d->enum_compat_type;
370	if(t & TS__SIGN)
371	return t & TS__SIGN;
372	switch(t & TS__BASIC) {
373	case TS_BOOL:
374	return TS_UNSIGNED; /* XXX erm */
375	case TS_CHAR:
376	return TS_SIGNED; /* XXX depends on compiler */
377	default:
378	return TS_SIGNED; /* everything else is signed */
379	}
380	}
381
382	/* C99 6.3.1.8 */
383	struct declarator usual_arithmetic_conversions(struct expression *lp,
384	struct expression **rp,
385	const struct location *where) {
386	struct expression l = lp, r = rp;
387	unsigned long lcrt, rcrt; /* common real type */
388	unsigned long lpt, rpt; /* integer-promoted type */
389	unsigned long lsign, rsign; /* sign bits */
390	int lrank, rrank; /* ranks */
391
392	/* if type is unknown do nothing */
393	if(!l->valuetype \|\| !r->valuetype) return 0;
394
395	/* find corresponding real type */
396	lcrt = corresponding_real_type(l->valuetype);
397	rcrt = corresponding_real_type(r->valuetype);
398	if(rcrt > lcrt)
399	return usual_arithmetic_conversions(rp, lp, where);
400	if(lcrt > rcrt) {
401	*rp = simple_implicit_conversion
402	(r,
403	lcrt
404	\| (r->valuetype->declaration_specifiers->type_specifiers & TS__CI),
405	where);
406	return 0;
407	}
408
409	/* integer promotions */
410	lpt = integer_promoted_type(l);
411	l = simple_implicit_conversion(l, lpt, where);
412	rpt = integer_promoted_type(r);
413	r = simple_implicit_conversion(r, rpt, where);
414
415	/* rules for promoted operands */
416	if(lpt && rpt && lpt != rpt) {
417	lrank = rank(l->valuetype->declaration_specifiers);
418	rrank = rank(r->valuetype->declaration_specifiers);
419	lsign = sign(l->valuetype->declaration_specifiers);
420	rsign = sign(r->valuetype->declaration_specifiers);
421	/* same signedness -> highest rank wins */
422	if(lsign == rsign) {
423	if(lrank > rrank)
424	rpt = lpt;
425	else
426	lpt = rpt;
427	/* if rank(unsigned type) >= rank(signed type), unsigned type wins */
428	} else if(lsign == TS_UNSIGNED && lrank >= rrank)
429	rpt = lpt;
430	else if(rsign == TS_UNSIGNED && rrank >= lrank)
431	lpt = rpt;
432	/* if signed type \superset unsigned type, signed type wins */
433	else if(lsign == TS_SIGNED && width(lpt) > width(rpt))
434	rpt = lpt;
435	else if(rsign == TS_SIGNED && width(rpt) > width(lpt))
436	lpt = rpt;
437	/* otherwise convert both to the unsigned type matching the signed type */
438	else if(lsign == TS_SIGNED)
439	rpt = lpt = (lpt & ~TS__SIGN) \| TS_UNSIGNED;
440	else
441	rpt = lpt = (rpt & ~TS__SIGN) \| TS_UNSIGNED;
442	l = simple_implicit_conversion(l, lpt, where);
443	r = simple_implicit_conversion(r, rpt, where);
444	}
445
446	/* pass the answers back */
447	*lp = l;
448	*rp = r;
449
450	return l->valuetype;
451	}
452
453	struct expression *stringexpr(enum expression_type type,
454	char *value,
455	const struct location *where) {
456	struct expression *e;
457
458	e = expr(type, where);
459	e->u.constant = value;
460	NEW(e->valuetype);
461	NEW(e->valuetype->declaration_specifiers);
462	switch(type) {
463	case ex_string:
464	e->valuetype->declaration_specifiers->type_specifiers = TS_CHAR;
465	break;
466	case ex_char:
467	e->valuetype->declaration_specifiers->type_specifiers = TS_INT;
468	break;
469	case ex_wstring:
470	e->valuetype->declaration_specifiers->type_specifiers = P_WCHAR_T;
471	break;
472	case ex_wchar:
473	e->valuetype->declaration_specifiers->type_specifiers = P_WCHAR_T;
474	break;
475	default:
476	abort();
477	}
478	if(type == ex_string \|\| type == ex_wstring) {
479	if(constant_string_literals)
480	e->valuetype->declaration_specifiers->type_qualifiers = TQ_CONST;
481	NEW(e->valuetype->declarator_type);
482	e->valuetype->declarator_type->type = dt_pointer;
483	}
484	NEW(e->valuetype->declarator_type);
485	e->valuetype->declarator_type->type = dt_pointer;
486	return e;
487	}
488
489	struct expression fncallexpr(struct expression f,
490	struct expression_list *l,
491	const struct location *where) {
492	struct declarator_type *dt;
493	struct expression *e;
494
495	e = expr(ex_fncall, where);
496	e->u.fncall.fn = f;
497	e->u.fncall.args = l;
498	if(f->valuetype) {
499	/* f can either be a function or a pointer to a function (but not e.g. a
500	* pointer to a pointer to a function) */
501	dt = f->valuetype->declarator_type;
502	if(dt && dt->type == dt_pointer)
503	dt = dt->next;
504	} else
505	dt = 0;
506	if(dt && (dt->type == dt_function
507	\|\| dt->type == dt_old_function))
508	e->valuetype = target_type(f->valuetype);
509	else
510	inputerror(where, "left operand to () operator is not a function");
511	return e;
512	}
513
514	/*
515	Local Variables:
516	c-basic-offset:2
517	comment-column:40
518	fill-column:79
519	End:
520	*/