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                         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                 dprintf(fd, " %s(*%s)",
  65                                 psi_t_indirection(arg->var->pointer_level - !! arg->var->array_size),
  66                                 arg->var->name);
  67                 dprintf(fd, "(");
  68                 if (arg->type->real.func->args) {
  69                         size_t j = 0;
  70                         struct psi_decl_arg *farg;
  71
  72                         ++level;
  73                         while (psi_plist_get(arg->type->real.func->args, j++, &farg)) {
  74                                 if (j > 1) {
  75                                         dprintf(fd, ", ");
  76                                 }
  77                                 psi_decl_arg_dump(fd, farg, level);
  78                         }
  79                         --level;
  80                         if (arg->type->real.func->varargs) {
  81                                 dprintf(fd, ", ...");
  82                         }
  83                 }
  84                 dprintf(fd, ")");
  85                 if (arg->var->array_size) {
  86                         dprintf(fd, "[%u]", arg->var->array_size);
  87                 }
  88         } else {
  89                 psi_decl_type_dump(fd, arg->type, level);
  90                 dprintf(fd, " ");
  91                 psi_decl_var_dump(fd, arg->var);
  92         }
  93 }
  94
  95 bool psi_decl_arg_validate(struct psi_data *data, struct psi_decl_arg *arg,
  96                 struct psi_validate_stack *type_stack)
  97 {
  98         if (!psi_decl_type_validate(data, arg->type, arg->var->pointer_level, type_stack)) {
  99                  if (!arg->var->pointer_level) {
 100                         data->error(data, arg->type->token, PSI_WARNING,
 101                                         "Cannot use '%s' as type for '%s'%s%s", arg->type->name,
 102                                         arg->var->name, *data->last_error ? ": " : "", data->last_error);
 103                         return false;
 104                  }
 105         }
 106         return true;
 107 }
 108
 109 bool psi_decl_arg_validate_typedef(struct psi_data *data,
 110                 struct psi_decl_arg *def, struct psi_validate_stack *type_stack)
 111 {
 112         if (psi_validate_stack_has_type(type_stack, def->var->name)) {
 113                 return true;
 114         }
 115         psi_validate_stack_add_type(type_stack, def->var->name, def);
 116
 117         if (def->type->type == PSI_T_VOID) {
 118                 if (def->var->pointer_level) {
 119                         def->type->type = PSI_T_POINTER;
 120                 } else {
 121                         data->error(data, def->token, PSI_WARNING,
 122                                         "Type '%s' cannot be aliased to 'void'", def->type->name);
 123                         return false;
 124                 }
 125         } else if (!psi_decl_type_validate(data, def->type, def->var->pointer_level, type_stack)) {
 126                 const char *pre;
 127
 128                 switch (def->type->type) {
 129                 case PSI_T_STRUCT:
 130                         pre = "struct ";
 131                         break;
 132                 case PSI_T_UNION:
 133                         pre = "union ";
 134                         break;
 135                 case PSI_T_ENUM:
 136                         pre = "enum ";
 137                         break;
 138                 default:
 139                         pre = "";
 140                         break;
 141                 }
 142                 data->error(data, def->token, PSI_WARNING,
 143                                 "Type '%s' cannot be aliased to '%s%s'%s%s", def->var->name, pre,
 144                                 def->type->name, *data->last_error ? ": " : "", data->last_error);
 145                 return false;
 146         }
 147
 148         return true;
 149 }
 150
 151 size_t psi_decl_arg_align(struct psi_decl_arg *darg, size_t *pos, size_t *len)
 152 {
 153         size_t align = psi_decl_arg_get_align(darg);
 154
 155         if (align) {
 156                 *len = psi_decl_arg_get_size(darg);
 157                 *pos = psi_align(align, *pos);
 158         }
 159
 160         return align;
 161 }
 162
 163 size_t psi_decl_arg_get_align(struct psi_decl_arg *darg)
 164 {
 165         size_t align;
 166
 167         if (darg->var->pointer_level
 168                         && (!darg->var->array_size || darg->var->pointer_level > 1)) {
 169                 align = psi_t_alignment(PSI_T_POINTER);
 170         } else {
 171                 align = psi_decl_type_get_align(darg->type);
 172         }
 173
 174         return align;
 175 }
 176
 177 size_t psi_decl_arg_get_size(struct psi_decl_arg *darg)
 178 {
 179         size_t size;
 180         struct psi_decl_type *real = psi_decl_type_get_real(darg->type);
 181
 182         if (darg->var->array_size) {
 183                 if (darg->var->pointer_level > 1) {
 184                         size = psi_t_size(PSI_T_POINTER) * darg->var->array_size;
 185                 } else {
 186                         size = psi_t_size(real->type) * darg->var->array_size;
 187                 }
 188         } else if (darg->var->pointer_level) {
 189                 size = psi_t_size(PSI_T_POINTER);
 190         } else {
 191                 switch (real->type) {
 192                 case PSI_T_UNION:
 193                         size = real->real.unn->size;
 194                         break;
 195                 case PSI_T_STRUCT:
 196                         size = real->real.strct->size;
 197                         break;
 198                 case PSI_T_ENUM:
 199                 default:
 200                         size = psi_t_size(real->type);
 201                         break;
 202                 }
 203         }
 204
 205         return size;
 206 }
 207
 208 struct psi_decl_arg *psi_decl_arg_get_by_name(struct psi_plist *args,
 209                 const char *name)
 210 {
 211         size_t i = 0;
 212         struct psi_decl_arg *arg;
 213
 214         if (args)
 215                 while (psi_plist_get(args, i++, &arg)) {
 216                         if (!strcmp(name, arg->var->name)) {
 217                                 return arg;
 218                         }
 219                 }
 220
 221         return NULL;
 222 }
 223
 224 struct psi_decl_arg *psi_decl_arg_get_by_var(struct psi_decl_var *var,
 225                 struct psi_plist *args, struct psi_decl_arg *func)
 226 {
 227         struct psi_decl_arg *arg = psi_decl_arg_get_by_name(args, var->name);
 228
 229         if (arg) {
 230                 assert(!var->arg || var->arg == arg);
 231
 232                 return var->arg = arg;
 233         }
 234
 235         if (func && !strcmp(var->name, func->var->name)) {
 236                 return var->arg = func;
 237         }
 238
 239         return NULL;
 240 }