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