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", arg->type->name,
 122                                         arg->var->name, *data->last_error ? ": " : "", data->last_error);
 123                         return false;
 124                  }
 125         }
 126         return true;
 127 }
 128
 129 bool psi_decl_arg_validate_typedef(struct psi_data *data,
 130                 struct psi_decl_arg *def, struct psi_validate_scope *scope)
 131 {
 132         if (psi_validate_scope_has_type(scope, def->var->name)) {
 133                 return true;
 134         }
 135         psi_validate_scope_add_type(scope, def->var->name, def);
 136
 137         if (def->type->type == PSI_T_VOID) {
 138                 if (def->var->pointer_level) {
 139                         def->type->type = PSI_T_POINTER;
 140                 } else {
 141                         data->error(data, def->token, PSI_WARNING,
 142                                         "Type '%s' cannot be aliased to 'void'",
 143                                         def->type->name->val);
 144                         return false;
 145                 }
 146         } else if (!psi_decl_type_validate(data, def->type, def, scope)) {
 147                 const char *pre;
 148
 149                 switch (def->type->type) {
 150                 case PSI_T_STRUCT:
 151                         pre = "struct ";
 152                         break;
 153                 case PSI_T_UNION:
 154                         pre = "union ";
 155                         break;
 156                 case PSI_T_ENUM:
 157                         pre = "enum ";
 158                         break;
 159                 default:
 160                         pre = "";
 161                         break;
 162                 }
 163                 data->error(data, def->token, PSI_WARNING,
 164                                 "Type '%s' cannot be aliased to '%s%s'%s%s",
 165                                 def->var->name->val, pre,
 166                                 def->type->name->val,
 167                                 *data->last_error ? ": " : "", data->last_error);
 168                 return false;
 169         }
 170
 171         return true;
 172 }
 173
 174 bool psi_decl_arg_is_pointer(struct psi_decl_arg *darg)
 175 {
 176         if (darg->var->pointer_level) {
 177                 if (darg->var->array_size) {
 178                         return darg->var->pointer_level > 1;
 179                 }
 180                 return true;
 181         } else if (psi_decl_type_is_weak(darg->type) && darg->type->real.def) {
 182                 return psi_decl_arg_is_pointer(darg->type->real.def);
 183         }
 184         return false;
 185 }
 186
 187 size_t psi_decl_arg_align(struct psi_decl_arg *darg, size_t *pos, size_t *len)
 188 {
 189         size_t align = psi_decl_arg_get_align(darg);
 190
 191         if (align) {
 192                 *len = psi_decl_arg_get_size(darg);
 193                 *pos = psi_align(align, *pos);
 194         }
 195
 196         return align;
 197 }
 198
 199 size_t psi_decl_arg_get_align(struct psi_decl_arg *darg)
 200 {
 201         size_t align;
 202
 203         if (psi_decl_arg_is_pointer(darg)) {
 204                 align = psi_t_alignment(PSI_T_POINTER);
 205         } else {
 206                 align = psi_decl_type_get_align(darg->type);
 207         }
 208
 209         return align;
 210 }
 211
 212 size_t psi_decl_arg_get_size(struct psi_decl_arg *darg)
 213 {
 214         size_t size;
 215         struct psi_decl_type *real = psi_decl_type_get_real(darg->type);
 216
 217         if (darg->var->array_size && darg->var->pointer_level > 1) {
 218                 size = psi_t_size(PSI_T_POINTER) * darg->var->array_size;
 219         } else if (psi_decl_arg_is_pointer(darg)) {
 220                 size = psi_t_size(PSI_T_POINTER);
 221         } else {
 222                 switch (real->type) {
 223                 case PSI_T_UNION:
 224                         size = real->real.unn->size;
 225                         break;
 226                 case PSI_T_STRUCT:
 227                         size = real->real.strct->size;
 228                         break;
 229                 case PSI_T_ENUM:
 230                 default:
 231                         size = psi_t_size(real->type);
 232                         break;
 233                 }
 234
 235                 if (darg->var->array_size) {
 236                         size *= darg->var->array_size;
 237                 }
 238         }
 239
 240         return size;
 241 }
 242
 243 struct psi_decl_arg *psi_decl_arg_get_by_name(struct psi_plist *args,
 244                 zend_string *name)
 245 {
 246         size_t i = 0;
 247         struct psi_decl_arg *arg;
 248
 249         if (args)
 250                 while (psi_plist_get(args, i++, &arg)) {
 251                         if (zend_string_equals(name, arg->var->name)) {
 252                                 return arg;
 253                         }
 254                 }
 255
 256         return NULL;
 257 }
 258
 259 struct psi_decl_arg *psi_decl_arg_get_by_var(struct psi_decl_var *var,
 260                 struct psi_plist *args, struct psi_decl_arg *func)
 261 {
 262         struct psi_decl_arg *arg = psi_decl_arg_get_by_name(args, var->name);
 263
 264         if (arg) {
 265                 assert(!var->arg || var->arg == arg);
 266
 267                 return var->arg = arg;
 268         }
 269
 270         if (func && zend_string_equals(var->name, func->var->name)) {
 271                 return var->arg = func;
 272         }
 273
 274         return NULL;
 275 }