mdw@git.distorted.org.uk Git - cparse/blob - constraints.c

   1 #include "cparse.h"
   2 #include <assert.h>
   3
   4 /* C99 6.4.3 */
   5 void ucn_constraints(unsigned long u) {
   6   switch(u) {
   7   case 0x24:
   8   case 0x40:
   9   case 0x60:
  10     break;
  11   default:
  12     if(u < 0x00A0)
  13       yyerror("UCN values below \\u00A0 are not allowed");
  14     else if(u >= 0xD800 && u <= 0xDFFF)
  15       yyerror("UCN values in [\\uD800, \\uDFFF] are not allowed");
  16     break;
  17   }
  18 }
  19
  20 enum type_category get_type_category(const struct declaration_specifiers *ds,
  21                                      const struct declarator_type *dt) {
  22   if(dt) {
  23     switch(dt->type) {
  24     case dt_function:
  25     case dt_old_function:
  26       return tc_function;
  27     case dt_pointer:
  28       return tc_complete;
  29     case dt_array:
  30       if(get_type_category(ds, dt->next) == tc_complete
  31          && (dt->u.array.size || (dt->u.array.flags & AF_STAR)))
  32         return tc_complete;
  33       return tc_incomplete;
  34     }
  35     abort();
  36   } else {
  37     if((ds->type_specifiers & TS__BASIC) == TS_VOID)
  38       return tc_incomplete;
  39     /* XXX detect incomplete struct/union types */
  40     return tc_complete;
  41   }
  42 }
  43
  44 /* C99 6.7.5.3 function declarators */
  45 static void check_function_return_type(const struct declarator_type *dt) {
  46   if(dt) switch(dt->type) {
  47   case dt_array:
  48     inputerror(&dt->where, "function returns an array");
  49     break;
  50   case dt_function:
  51   case dt_old_function:
  52     inputerror(&dt->where, "function returns a function");
  53     break;
  54   case dt_pointer:
  55     break;
  56   }
  57 }
  58
  59 int is_void_args(const struct declarator_type *dt) {
  60   const struct declaration *args;
  61   const struct declarator *d;
  62   const struct declaration_specifiers *ds;
  63
  64   if(dt->u.function.variadic) return 0;
  65   args = dt->u.function.args;
  66   if(!args || args->next) return 0;
  67   d = args->declarator_list;
  68   if(d->name || d->declarator_type) return 0;
  69   ds = d->declaration_specifiers;
  70   if(ds->storage_class_specifiers
  71      || ds->type_qualifiers
  72      || ds->type_specifiers != TS_VOID)
  73     return 0;
  74   return 1;
  75 }
  76
  77 static int valid_bitfield_type(const struct declaration_specifiers *ds,
  78                                const struct declarator_type *dt) {
  79   if(dt) return 0;
  80   switch(ds->type_specifiers) {
  81   case TS_INT:
  82   case TS_SIGNED|TS_INT:
  83   case TS_UNSIGNED|TS_INT:
  84   case TS_SIGNED:
  85   case TS_UNSIGNED:
  86   case TS_BOOL:
  87     return 1;
  88   default:
  89     return 0;
  90   }
  91 }
  92
  93 void declaration_constraints(const struct declaration *decl,
  94                              enum declarator_context context) {
  95   const struct declarator *d;
  96
  97   /* C99 6.7.2 need at least one type specifier */
  98   if(!decl->declaration_specifiers->type_specifiers)
  99     inputerror(&decl->where, "no type specifiers in declaration");
 100
 101   for(d = decl->declarator_list; d; d = d->next)
 102     declarator_constraints(d->declaration_specifiers,
 103                            d, context, 0);
 104 }
 105
 106 void declarator_constraints(const struct declaration_specifiers *ds,
 107                             const struct declarator *d,
 108                             enum declarator_context context,
 109                             int argno) {
 110   const struct declarator_type *dt = d->declarator_type;
 111   const struct location *declloc = dt ? &dt->where : &d->where;
 112
 113   switch(context) {
 114   case dc_function_definition:
 115     if(ds->storage_class_specifiers & ~(SCS_EXTERN|SCS_STATIC))
 116       inputerror(&d->where, "invalid storage class specifiers for a function");
 117     if(!dt || (dt->type != dt_function
 118                && dt->type != dt_old_function)) {
 119       if(d->name)
 120         inputerror(&d->where,
 121                    "function definition of '%s' requires a function declarator",
 122                    d->name);
 123       else
 124         inputerror(&d->where,
 125                    "function definition requires a function declarator");
 126     }
 127     break;
 128
 129   case dc_function_definition_parameter:
 130     if(!d->name)
 131       inputerror(declloc, "parameter %d has no name", argno);
 132   case dc_function_parameter:
 133     if(ds->storage_class_specifiers & (~SCS_REGISTER)) {
 134       if(d->name)
 135         inputerror(&d->where, "parameter '%s' has invalid storage class",
 136                    d->name);
 137       else
 138         inputerror(&d->where, "parameter %d has invalid storage class",
 139                    argno);
 140     }
 141     switch(get_type_category(ds, dt)) {
 142     case tc_incomplete:
 143       if(context == dc_function_definition_parameter) {
 144         /* arrays of completely-typed objects are allowed */
 145         if(!(dt
 146              && dt->type == dt_array
 147              && get_type_category(ds, dt->next) == tc_complete)) {
 148           if(d->name)
 149             inputerror(declloc, "parameter '%s' has incomplete type",
 150                        d->name);
 151           /* if no name, will already have reported an error */
 152         }
 153       }
 154       break;
 155     case tc_function:
 156       if(d->name)
 157         inputerror(declloc, "parameter '%s' has function type", d->name);
 158       else
 159         inputerror(declloc, "parameter %d has function type", argno);
 160       break;
 161     case tc_complete:
 162       break;
 163     }
 164     break;
 165
 166   case dc_struct_member:
 167     if(d->bits) {
 168       if(!valid_bitfield_type(ds, dt)) {
 169         if(d->name)
 170           inputerror(&d->where, "member '%s' has invalid type for a bit field");
 171         else
 172           inputerror(&d->where, "member has invalid type for a bit field");
 173       }
 174       /* XXX field size must be integral */
 175     } else {
 176       switch(get_type_category(ds, dt)) {
 177       case tc_function:
 178         inputerror(declloc, "member '%s' has function type", d->name);
 179         break;
 180       case tc_incomplete:
 181         if(dt
 182            && dt->type == dt_array
 183            && !dt->u.array.size
 184            && !dt->u.array.flags)
 185           inputwarning(declloc, warn_compat,
 186                        "member '%s' is a GNU C flexible array", d->name);
 187         else
 188           inputerror(declloc, "member '%s' has incomplete type", d->name);
 189         break;
 190       case tc_complete:
 191         break;
 192       }
 193     }
 194     break;
 195
 196   case dc_cast:
 197     switch(get_type_category(ds, dt)) {
 198     case tc_function:
 199       inputerror(declloc, "cannot convert to function type");
 200       break;
 201     case tc_incomplete:
 202       if(ds->type_specifiers != TS_VOID)
 203         inputerror(declloc, "cannot convert to incomplete type");
 204       break;
 205     case tc_complete:
 206       switch(ds->type_specifiers & TS__BASIC) {
 207       case TS_STRUCT:
 208       case TS_UNION:
 209         if(dt == 0) {
 210           /* XXX and some typedefs */
 211           inputerror(declloc, "cannot convert to aggregate type");
 212         } else switch(dt->type) {
 213         case dt_array:
 214           inputerror(declloc, "cannot convert to array type");
 215           break;
 216         case dt_function:
 217         case dt_old_function:
 218           inputerror(declloc, "cannot convert to function type");
 219           break;
 220         case dt_pointer:
 221           /* pointers are OK */
 222           break;
 223         }
 224         break;
 225       }
 226       break;
 227     }
 228     break;
 229
 230   case dc_compound_literal:
 231     switch(get_type_category(ds, dt)) {
 232     case tc_function:
 233       inputerror(declloc, "compound literals cannot have incomplete type");
 234       break;
 235     case tc_incomplete:
 236       inputerror(declloc, "compound literals cannot have incomplete type");
 237       break;
 238     case tc_complete:
 239       break;
 240     }
 241     break;
 242
 243   case dc_sizeof:
 244     switch(get_type_category(ds, dt)) {
 245     case tc_function:
 246       inputerror(declloc, "cannot take size of function type");
 247       break;
 248     case tc_incomplete:
 249       inputerror(declloc, "cannot take size of incomplete type");
 250       break;
 251     case tc_complete:
 252       break;
 253     }
 254     break;
 255
 256   case dc_file_scope:
 257   case dc_block_scope:
 258     break;
 259   }
 260   for(dt = d->declarator_type; dt; dt = dt->next) {
 261     switch(dt->type) {
 262     case dt_pointer:
 263       break;
 264
 265       /* C99 6.7.5.2 array declarators */
 266
 267     case dt_array:
 268       if((dt->storage_class_specifiers
 269           || dt->type_qualifiers)
 270          && !(dt == d->declarator_type
 271               && (context == dc_function_parameter
 272                   || context == dc_function_definition_parameter)))
 273         inputerror(&dt->where, "invalid array declarator");
 274       switch(get_type_category(ds, dt->next)) {
 275       case tc_complete:
 276         break;
 277       case tc_function:
 278         inputerror(&dt->where, "array element type has function type");
 279         break;
 280       case tc_incomplete:
 281         inputerror(&dt->where, "array element type has incomplete type");
 282         break;
 283       }
 284       /* XXX size must have integral type */
 285       break;
 286
 287       /* C99 6.7.5.3 function declarators */
 288
 289     case dt_old_function:
 290       check_function_return_type(dt->next);
 291       if(dt->u.old_function.args) {
 292         if(!(dt == d->declarator_type && context == dc_function_definition))
 293           inputerror(&dt->where,
 294                      "non-empty identifier-list in function declarator");
 295         else {
 296           /* check for duplicates */
 297           struct dict *dict = dict_new();
 298           struct identifier_list *i;
 299
 300           for(i = dt->u.old_function.args; i; i = i->next) {
 301             if(dict_get(dict, i->id)) {
 302               inputerror(&dt->where, "duplicate '%s' in function parameters",
 303                          i->id);
 304               break;
 305             }
 306             dict_add(dict, i->id, i->id);
 307           }
 308         }
 309       }
 310       break;
 311
 312     case dt_function:
 313       check_function_return_type(dt->next);
 314       if(!is_void_args(dt)) {
 315         /* recursively check arguments */
 316         int n = 1;
 317         const struct declaration *a;
 318
 319         for(a = dt->u.function.args; a; a = a->next)
 320           declarator_constraints(a->declaration_specifiers,
 321                                  a->declarator_list,
 322                                  context == dc_function_definition
 323                                  ? dc_function_definition_parameter
 324                                  : dc_function_parameter,
 325                                  n++);
 326       }
 327       break;
 328     }
 329   }
 330 }
 331
 332 /*
 333 Local Variables:
 334 c-basic-offset:2
 335 comment-column:40
 336 End:
 337 */