chiark - git - mdw - cparse/blob - expr.c

   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 */