git.m6w6.name Git - m6w6/ext-psi/blob - src/types/decl_arg.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 <assert.h>
  28
  29 #include "data.h"
  30
  31 struct psi_decl_arg *psi_decl_arg_init(struct psi_decl_type *type,
  32                 struct psi_decl_var *var)
  33 {
  34         struct psi_decl_arg *arg = calloc(1, sizeof(*arg));
  35         arg->token = var->token;
  36         arg->type = type;
  37         arg->var = var;
  38         var->arg = arg;
  39         return arg;
  40 }
  41
  42 void psi_decl_arg_free(struct psi_decl_arg **arg_ptr)
  43 {
  44         if (*arg_ptr) {
  45                 struct psi_decl_arg *arg = *arg_ptr;
  46
  47                 *arg_ptr = NULL;
  48                 if (arg->token && arg->token != arg->var->token) {
  49                         psi_token_free(&arg->token);
  50                 }
  51                 psi_decl_type_free(&arg->type);
  52                 psi_decl_var_free(&arg->var);
  53                 if (arg->layout) {
  54                         psi_layout_free(&arg->layout);
  55                 }
  56                 free(arg);
  57         }
  58 }
  59
  60 void psi_decl_arg_dump(int fd, struct psi_decl_arg *arg, unsigned level)
  61 {
  62         if (arg->type->type == PSI_T_FUNCTION) {
  63                 psi_decl_type_dump(fd, arg->type->real.func->func->type, level);
  64                 if (arg->type->real.func->func->type->type == PSI_T_FUNCTION) {
  65                         dprintf(fd, "(");
  66                 }
  67                 dprintf(fd, " %s(*%s)",
  68                                 psi_t_indirection(arg->var->pointer_level - !! arg->var->array_size),
  69                                 arg->var->name->val);
  70                 dprintf(fd, "(");
  71                 if (arg->type->real.func->args) {
  72                         size_t j = 0;
  73                         struct psi_decl_arg *farg;
  74
  75                         ++level;
  76                         while (psi_plist_get(arg->type->real.func->args, j++, &farg)) {
  77                                 if (j > 1) {
  78                                         dprintf(fd, ", ");
  79                                 }
  80                                 psi_decl_arg_dump(fd, farg, level);
  81                         }
  82                         --level;
  83                         if (arg->type->real.func->varargs) {
  84                                 dprintf(fd, ", ...");
  85                         }
  86                 }
  87                 dprintf(fd, ")");
  88                 if (arg->type->real.func->func->type->type == PSI_T_FUNCTION) {
  89                         struct psi_decl *decl = arg->type->real.func->func->type->real.func;
  90
  91                         dprintf(fd, "(");
  92                         if (decl->args) {
  93                                 size_t i;
  94                                 struct psi_decl_arg *arg;
  95
  96                                 for (i = 0; psi_plist_get(decl->args, i, &arg); ++i) {
  97                                         if (i) {
  98                                                 dprintf(fd, ", ");
  99                                         }
 100                                         psi_decl_arg_dump(fd, arg, 0);
 101                                 }
 102                                 if (decl->varargs) {
 103                                         dprintf(fd, ", ...");
 104                                 }
 105                         }
 106                         dprintf(fd, "))");
 107                 }
 108         } else {
 109                 psi_decl_type_dump(fd, arg->type, level);
 110                 dprintf(fd, " ");
 111                 psi_decl_var_dump(fd, arg->var);
 112         }
 113 }
 114
 115 bool psi_decl_arg_validate(struct psi_data *data, struct psi_decl_arg *arg,
 116                 struct psi_validate_scope *scope)
 117 {
 118         if (!psi_decl_type_validate(data, arg->type, NULL, scope)) {
 119                  if (!arg->var->pointer_level) {
 120                         data->error(data, arg->type->token, PSI_WARNING,
 121                                         "Cannot use '%s' as type for '%s'%s%s",
 122                                         arg->type->name->val,
 123                                         arg->var->name->val,
 124                                         *data->last_error ? ": " : "", data->last_error);
 125                         return false;
 126                  }
 127         }
 128         return true;
 129 }
 130
 131 bool psi_decl_arg_validate_typedef(struct psi_data *data,
 132                 struct psi_decl_arg *def, struct psi_validate_scope *scope)
 133 {
 134         if (psi_validate_scope_has_type(scope, def->var->name)) {
 135                 return true;
 136         }
 137         psi_validate_scope_add_type(scope, def->var->name, def);
 138
 139         if (def->type->type == PSI_T_VOID) {
 140                 if (def->var->pointer_level) {
 141                         def->type->type = PSI_T_POINTER;
 142                 } else {
 143                         data->error(data, def->token, PSI_WARNING,
 144                                         "Type '%s' cannot be aliased to 'void'",
 145                                         def->type->name->val);
 146                         return false;
 147                 }
 148         } else if (!psi_decl_type_validate(data, def->type, def, scope)) {
 149                 const char *pre;
 150
 151                 switch (def->type->type) {
 152                 case PSI_T_STRUCT:
 153                         pre = "struct ";
 154                         break;
 155                 case PSI_T_UNION:
 156                         pre = "union ";
 157                         break;
 158                 case PSI_T_ENUM:
 159                         pre = "enum ";
 160                         break;
 161                 default:
 162                         pre = "";
 163                         break;
 164                 }
 165                 data->error(data, def->token, PSI_WARNING,
 166                                 "Type '%s' cannot be aliased to '%s%s'%s%s",
 167                                 def->var->name->val, pre,
 168                                 def->type->name->val,
 169                                 *data->last_error ? ": " : "", data->last_error);
 170                 return false;
 171         }
 172
 173         return true;
 174 }
 175
 176 bool psi_decl_arg_is_pointer(struct psi_decl_arg *darg)
 177 {
 178         if (darg->var->pointer_level) {
 179                 if (darg->var->array_size) {
 180                         return darg->var->pointer_level > 1;
 181                 }
 182                 return true;
 183         } else if (psi_decl_type_is_weak(darg->type) && darg->type->real.def) {
 184                 return psi_decl_arg_is_pointer(darg->type->real.def);
 185         }
 186         return false;
 187 }
 188
 189 size_t psi_decl_arg_align(struct psi_decl_arg *darg, size_t *pos, size_t *len)
 190 {
 191         size_t align = psi_decl_arg_get_align(darg);
 192
 193         if (align) {
 194                 *len = psi_decl_arg_get_size(darg);
 195                 *pos = psi_align(align, *pos);
 196         }
 197
 198         return align;
 199 }
 200
 201 size_t psi_decl_arg_get_align(struct psi_decl_arg *darg)
 202 {
 203         size_t align;
 204
 205         if (psi_decl_arg_is_pointer(darg)) {
 206                 align = psi_t_alignment(PSI_T_POINTER);
 207         } else {
 208                 align = psi_decl_type_get_align(darg->type);
 209         }
 210
 211         return align;
 212 }
 213
 214 size_t psi_decl_arg_get_size(struct psi_decl_arg *darg)
 215 {
 216         size_t size;
 217         struct psi_decl_type *real = psi_decl_type_get_real(darg->type);
 218
 219         if (darg->var->array_size && darg->var->pointer_level > 1) {
 220                 size = psi_t_size(PSI_T_POINTER) * darg->var->array_size;
 221         } else if (psi_decl_arg_is_pointer(darg)) {
 222                 size = psi_t_size(PSI_T_POINTER);
 223         } else {
 224                 switch (real->type) {
 225                 case PSI_T_UNION:
 226                         size = real->real.unn->size;
 227                         break;
 228                 case PSI_T_STRUCT:
 229                         size = real->real.strct->size;
 230                         break;
 231                 case PSI_T_ENUM:
 232                 default:
 233                         size = psi_t_size(real->type);
 234                         break;
 235                 }
 236
 237                 if (darg->var->array_size) {
 238                         size *= darg->var->array_size;
 239                 }
 240         }
 241
 242         return size;
 243 }
 244
 245 struct psi_decl_arg *psi_decl_arg_get_by_name(struct psi_plist *args,
 246                 zend_string *name)
 247 {
 248         size_t i = 0;
 249         struct psi_decl_arg *arg;
 250
 251         if (args)
 252                 while (psi_plist_get(args, i++, &arg)) {
 253                         if (zend_string_equals(name, arg->var->name)) {
 254                                 return arg;
 255                         }
 256                 }
 257
 258         return NULL;
 259 }
 260
 261 struct psi_decl_arg *psi_decl_arg_get_by_var(struct psi_decl_var *var,
 262                 struct psi_plist *args, struct psi_decl_arg *func)
 263 {
 264         struct psi_decl_arg *arg = psi_decl_arg_get_by_name(args, var->name);
 265
 266         if (arg) {
 267                 assert(!var->arg || var->arg == arg);
 268
 269                 return var->arg = arg;
 270         }
 271
 272         if (func && zend_string_equals(var->name, func->var->name)) {
 273                 return var->arg = func;
 274         }
 275
 276         return NULL;
 277 }