git.m6w6.name Git - m6w6/ext-psi/blob - src/types/decl_type.c

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8  * Redistributions of source code must retain the above copyright notice,
   9  this list of conditions and the following disclaimer.
  10  * Redistributions in binary form must reproduce the above copyright
  11  notice, this list of conditions and the following disclaimer in the
  12  documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *******************************************************************************/
  25
  26 #include "php_psi_stdinc.h"
  27 #include "token.h"
  28 #include "data.h"
  29
  30 #define PSI_STD_TYPES
  31 #include "php_psi_posix.h"
  32
  33 struct psi_decl_type *psi_decl_type_init(token_t type, const char *name)
  34 {
  35         struct psi_decl_type *t = calloc(1, sizeof(*t));
  36         t->type = type;
  37         t->name = strdup(name);
  38         return t;
  39 }
  40
  41 void psi_decl_type_free(struct psi_decl_type **type_ptr)
  42 {
  43         if (*type_ptr) {
  44                 struct psi_decl_type *type = *type_ptr;
  45
  46                 *type_ptr = NULL;
  47                 if (type->token) {
  48                         free(type->token);
  49                 }
  50                 if (type->type == PSI_T_FUNCTION) {
  51                         psi_decl_free(&type->real.func);
  52                 }
  53                 free(type->name);
  54                 free(type);
  55         }
  56 }
  57
  58 struct psi_decl_type *psi_decl_type_copy(struct psi_decl_type *src)
  59 {
  60         struct psi_decl_type *dst = calloc(1, sizeof(*dst));
  61
  62         dst->type = src->type;
  63         if (src->name) {
  64                 dst->name = strdup(src->name);
  65         }
  66         if (src->token) {
  67                 dst->token = psi_token_copy(src->token);
  68         }
  69         return dst;
  70 }
  71
  72 struct psi_plist *psi_decl_type_get_args(struct psi_decl_type *dtyp,
  73                 struct psi_decl_type **real_typ_ptr)
  74 {
  75         struct psi_decl_type *var_typ;
  76
  77         var_typ = psi_decl_type_get_real(dtyp);
  78         if (real_typ_ptr) {
  79                 *real_typ_ptr = var_typ;
  80         }
  81
  82         switch (var_typ->type) {
  83         case PSI_T_STRUCT:
  84                 return var_typ->real.strct->args;
  85         case PSI_T_UNION:
  86                 return var_typ->real.unn->args;
  87         default:
  88                 return NULL;
  89         }
  90 }
  91
  92 size_t psi_decl_type_get_size(struct psi_decl_type *dtyp,
  93                 struct psi_decl_type **real_typ_ptr)
  94 {
  95         struct psi_decl_type *var_typ;
  96
  97         var_typ = psi_decl_type_get_real(dtyp);
  98         if (real_typ_ptr) {
  99                 *real_typ_ptr = var_typ;
 100         }
 101
 102         switch (var_typ->type) {
 103         case PSI_T_STRUCT:
 104                 return var_typ->real.strct->size;
 105         case PSI_T_UNION:
 106                 return var_typ->real.unn->size;
 107         default:
 108                 return psi_t_size(var_typ->type);
 109         }
 110 }
 111
 112 bool psi_decl_type_get_alias(struct psi_decl_type *type, struct psi_plist *defs)
 113 {
 114         size_t i = 0;
 115         struct psi_std_type *stdtyp;
 116         struct psi_decl_arg *def;
 117
 118         if (type->real.def) {
 119                 return true;
 120         }
 121         if (defs)
 122                 while (psi_plist_get(defs, i++, &def)) {
 123                         if (def->type->type != type->type
 124                                         && !strcmp(def->var->name, type->name)) {
 125                                 type->real.def = def;
 126                                 return true;
 127                         }
 128                 }
 129         for (stdtyp = &psi_std_types[0]; stdtyp->type_tag; ++stdtyp) {
 130                 if (!strcmp(type->name, stdtyp->alias ?: stdtyp->type_name)) {
 131                         type->type = stdtyp->type_tag;
 132                         return true;
 133                 }
 134         }
 135
 136         return false;
 137 }
 138
 139 bool psi_decl_type_get_struct(struct psi_decl_type *type, struct psi_plist *structs)
 140 {
 141         size_t i = 0;
 142         struct psi_decl_struct *s;
 143
 144         if (type->real.strct) {
 145                 return true;
 146         }
 147         if (structs) {
 148                 while (psi_plist_get(structs, i++, &s)) {
 149                         if (!strcmp(s->name, type->name)) {
 150                                 type->real.strct = s;
 151                                 return true;
 152                         }
 153                 }
 154         }
 155         return false;
 156 }
 157
 158 bool psi_decl_type_get_union(struct psi_decl_type *type, struct psi_plist *unions)
 159 {
 160         size_t i = 0;
 161         struct psi_decl_union *u;
 162
 163         if (type->real.unn) {
 164                 return true;
 165         }
 166         if (unions) {
 167                 while (psi_plist_get(unions, i++, &u)) {
 168                         if (!strcmp(u->name, type->name)) {
 169                                 type->real.unn = u;
 170                                 return true;
 171                         }
 172                 }
 173         }
 174         return false;
 175 }
 176
 177 bool psi_decl_type_get_enum(struct psi_decl_type *type, struct psi_plist *enums)
 178 {
 179         size_t i = 0;
 180         struct psi_decl_enum *e;
 181
 182         if (type->real.enm) {
 183                 return true;
 184         }
 185         if (enums) {
 186                 while (psi_plist_get(enums, i++, &e)) {
 187                         if (!strcmp(e->name, type->name)) {
 188                                 type->real.enm = e;
 189                                 return true;
 190                         }
 191                 }
 192         }
 193         return false;
 194 }
 195
 196 bool psi_decl_type_get_decl(struct psi_decl_type *type, struct psi_plist *decls)
 197 {
 198         size_t i = 0;
 199         struct psi_decl *decl;
 200
 201         if (type->real.func) {
 202                 return true;
 203         }
 204         if (decls) {
 205                 while (psi_plist_get(decls, i++, &decl)) {
 206                         if (!strcmp(decl->func->var->name, type->name)) {
 207                                 type->real.func = decl;
 208                                 return true;
 209                         }
 210                 }
 211         }
 212         return false;
 213 }
 214
 215 bool psi_decl_type_validate(struct psi_data *data, struct psi_decl_type *type,
 216                 struct psi_decl_arg *def)
 217 {
 218         if (psi_decl_type_is_weak(type)) {
 219                 if (!psi_decl_type_get_alias(type, data->types)) {
 220                         return false;
 221                 }
 222                 if (type->real.def) {
 223                         return psi_decl_type_validate(data, type->real.def->type,
 224                                         type->real.def);
 225                 }
 226                 return true;
 227         }
 228
 229         switch (type->type) {
 230         case PSI_T_STRUCT:
 231                 if (!psi_decl_type_get_struct(type, data->structs) && !def) {
 232                         data->error(data, type->token, PSI_WARNING,
 233                                         "Unknown struct '%s'", type->name);
 234                         return false;
 235                 }
 236                 break;
 237         case PSI_T_UNION:
 238                 if (!psi_decl_type_get_union(type, data->unions) && !def) {
 239                         data->error(data, type->token, PSI_WARNING,
 240                                         "Unknown union '%s'", type->name);
 241                         return false;
 242                 }
 243                 break;
 244         case PSI_T_ENUM:
 245                 if (!psi_decl_type_get_enum(type, data->enums) && !def) {
 246                         data->error(data, type->token, PSI_WARNING,
 247                                         "Unknown enum '%s'", type->name);
 248                         return false;
 249                 }
 250                 break;
 251         case PSI_T_FUNCTION:
 252                 if (!psi_decl_type_get_decl(type, data->decls)) {
 253                         data->error(data, type->token, PSI_WARNING,
 254                                         "Unknown decl '%s'", type->name);
 255                         return false;
 256                 }
 257                 if (!psi_decl_validate_nodl(data, type->real.func)) {
 258                         return false;
 259                 }
 260                 break;
 261         }
 262         return true;
 263 }
 264
 265 void psi_decl_type_dump_args_with_layout(int fd, struct psi_plist *args,
 266                 unsigned level)
 267 {
 268         size_t i = 0;
 269
 270         dprintf(fd, " {\n");
 271         if (args) {
 272                 struct psi_decl_arg *sarg;
 273
 274                 ++level;
 275                 while (psi_plist_get(args, i++, &sarg)) {
 276                         dprintf(fd, "%s", psi_t_indent(level));
 277                         psi_decl_arg_dump(fd, sarg, level);
 278                         dprintf(fd, "::(%zu, %zu);\n", sarg->layout->pos,
 279                                         sarg->layout->len);
 280                 }
 281                 --level;
 282         }
 283         dprintf(fd, "%s", psi_t_indent(level));
 284         dprintf(fd, "}");
 285 }
 286
 287 void psi_decl_type_dump(int fd, struct psi_decl_type *t, unsigned level)
 288 {
 289         switch (t->type) {
 290         case PSI_T_POINTER:
 291                 dprintf(fd, "%s *", t->name);
 292                 return;
 293
 294         case PSI_T_ENUM:
 295                 dprintf(fd, "enum ");
 296                 if (psi_decl_type_is_anon(t->name, "enum")) {
 297                         size_t i = 0, c = psi_plist_count(t->real.enm->items);
 298                         struct psi_decl_enum_item *item;
 299
 300                         dprintf(fd, "{\n");
 301                         ++level;
 302                         while (psi_plist_get(t->real.enm->items, i++, &item)) {
 303                                 dprintf(fd, "%s", psi_t_indent(level));
 304                                 psi_decl_enum_item_dump(fd, item);
 305                                 if (i < c) {
 306                                         dprintf(fd, "%s\n", i < c ? "," : "");
 307                                 }
 308                         }
 309                         --level;
 310                         dprintf(fd, "%s} ", psi_t_indent(level));
 311                         return;
 312                 }
 313                 break;
 314
 315         case PSI_T_STRUCT:
 316                 dprintf(fd, "struct ");
 317                 if (psi_decl_type_is_anon(t->name, "struct")) {
 318                         psi_decl_type_dump_args_with_layout(fd, t->real.strct->args, level);
 319                         return;
 320                 }
 321                 break;
 322
 323         case PSI_T_UNION:
 324                 dprintf(fd, "union ");
 325                 if (psi_decl_type_is_anon(t->name, "union")) {
 326                         psi_decl_type_dump_args_with_layout(fd, t->real.unn->args, level);
 327                         return;
 328                 }
 329                 break;
 330         }
 331         dprintf(fd, "%s", t->name);
 332 }
 333
 334 int psi_decl_type_is_weak(struct psi_decl_type *type)
 335 {
 336         switch (type->type) {
 337         case PSI_T_CHAR:
 338         case PSI_T_SHORT:
 339         case PSI_T_INT:
 340         case PSI_T_LONG:
 341         case PSI_T_UNSIGNED:
 342         case PSI_T_SIGNED:
 343         case PSI_T_NAME:
 344                 return type->type;
 345         default:
 346                 return 0;
 347         }
 348 }
 349
 350 struct psi_decl_type *psi_decl_type_get_real(struct psi_decl_type *type)
 351 {
 352         while (psi_decl_type_is_weak(type) && type->real.def) {
 353                 type = type->real.def->type;
 354         }
 355         return type;
 356 }
 357
 358 size_t psi_decl_type_get_align(struct psi_decl_type *t)
 359 {
 360         struct psi_decl_type *real = psi_decl_type_get_real(t);
 361         size_t align;
 362
 363         switch (real->type) {
 364         case PSI_T_STRUCT:
 365                 align = psi_decl_struct_get_align(real->real.strct);
 366                 break;
 367         case PSI_T_UNION:
 368                 align = psi_decl_union_get_align(real->real.unn);
 369                 break;
 370         case PSI_T_ENUM:
 371         default:
 372                 align = psi_t_alignment(real->type);
 373         }
 374
 375         return align;
 376 }
 377
 378 size_t psi_decl_type_get_args_align(struct psi_plist *args)
 379 {
 380         size_t i = 0, maxalign = 0;
 381         struct psi_decl_arg *darg;
 382
 383         while (psi_plist_get(args, i++, &darg)) {
 384                 size_t align = psi_decl_arg_get_align(darg);
 385
 386                 if (align > maxalign) {
 387                         maxalign = align;
 388                 }
 389         }
 390
 391         return maxalign;
 392 }
 393