git.m6w6.name Git - m6w6/ext-psi/blob - src/types/impl_def_val.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 "data.h"
  28
  29 #include <assert.h>
  30 #include <math.h>
  31
  32 #define PSI_IMPL_DEF_VAL_DEBUG 0
  33
  34 struct psi_impl_def_val *psi_impl_def_val_init(token_t t, void *data)
  35 {
  36         struct psi_impl_def_val *def = pecalloc(1, sizeof(*def), 1);
  37
  38         switch ((def->type = t)) {
  39         case PSI_T_TRUE:
  40         case PSI_T_FALSE:
  41         case PSI_T_NULL:
  42                 break;
  43         case PSI_T_QUOTED_STRING:
  44                 /* immediate upgrade */
  45                 def->type = PSI_T_STRING;
  46                 /* no break */
  47         case PSI_T_STRING:
  48                 if (data) {
  49                         def->ival.zend.str = zend_string_copy(data);
  50                 }
  51                 break;
  52
  53         case PSI_T_NUMBER:
  54                 def->data.num = data;
  55                 break;
  56
  57         default:
  58                 assert(0);
  59         }
  60
  61         return def;
  62 }
  63
  64 void psi_impl_def_val_free(struct psi_impl_def_val **def_ptr)
  65 {
  66         if (*def_ptr) {
  67                 struct psi_impl_def_val *def = *def_ptr;
  68
  69                 *def_ptr = NULL;
  70                 psi_token_free(&def->token);
  71                 switch (def->type) {
  72                 case PSI_T_NUMBER:
  73                         psi_num_exp_free(&def->data.num);
  74                         break;
  75
  76                 case PSI_T_STRING:
  77                         if (def->ival.zend.str) {
  78                                 zend_string_release(def->ival.zend.str);
  79                         }
  80                         break;
  81                 default:
  82                         break;
  83                 }
  84                 free(def);
  85         }
  86 }
  87
  88 bool psi_impl_def_val_validate(struct psi_data *data,
  89                 struct psi_impl_def_val *val, struct psi_impl_type *type,
  90                 struct psi_validate_scope *scope)
  91 {
  92         if (val->type == PSI_T_NULL) {
  93                 return true;
  94         } else if (val->type == PSI_T_NUMBER) {
  95                 if (!psi_num_exp_validate(data, val->data.num, scope)) {
  96                         return false;
  97                 }
  98         }
  99
 100         switch (type ? type->type : PSI_T_MIXED) {
 101         case PSI_T_BOOL:
 102                 val->ival.zend.bval = val->type == PSI_T_TRUE ? 1 : 0;
 103                 return true;
 104                 break;
 105
 106         /* macros */
 107         case PSI_T_NUMBER:
 108                 if (val->type == PSI_T_NUMBER) {
 109                         token_t typ = psi_num_exp_exec(val->data.num, &val->ival, NULL, scope->cpp);
 110
 111                         switch (typ) {
 112                         case PSI_T_FLOAT:
 113                                 val->ival.dval = val->ival.fval;
 114                                 /* no break */
 115                         case PSI_T_DOUBLE:
 116                                 val->type = PSI_T_FLOAT;
 117                                 type->type = PSI_T_FLOAT;
 118                                 zend_string_release(type->name);
 119                                 type->name = zend_string_init_interned(ZEND_STRL("float"), 1);
 120                                 break;
 121                         case PSI_T_UINT64:
 122                                 if (val->ival.u64 > ZEND_LONG_MAX) {
 123                                         data->error(data, val->token, PSI_WARNING,
 124                                                         "Integer too big for signed representation: '%" PRIu64 "'",
 125                                                         val->ival.u64);
 126                                 }
 127                         default:
 128                                 /* FIXME big integers */
 129                                 val->type = PSI_T_INT;
 130                                 type->type = PSI_T_INT;
 131                                 zend_string_release(type->name);
 132                                 type->name = zend_string_init_interned(ZEND_STRL("int"), 1);
 133                                 break;
 134                         }
 135                         psi_num_exp_free(&val->data.num);
 136                         return true;
 137                 }
 138                 break;
 139
 140         case PSI_T_INT:
 141                 if (val->type == PSI_T_NUMBER) {
 142                         val->type = PSI_T_INT;
 143                         val->ival.zend.lval = psi_num_exp_get_long(val->data.num, NULL, scope->cpp);
 144 #if PSI_IMPL_DEF_VAL_DEBUG
 145                         PSI_DEBUG_PRINT(data, "PSI: NUMBER (long) %" PRIi64 " from ", val->ival.zend.lval);
 146                         PSI_DEBUG_DUMP(data, psi_num_exp_dump, val->data.num);
 147                         PSI_DEBUG_PRINT(data, "\n");
 148 #endif
 149                         psi_num_exp_free(&val->data.num);
 150                 }
 151                 if (val->type == PSI_T_INT) {
 152                         return true;
 153                 }
 154                 break;
 155
 156         case PSI_T_FLOAT:
 157         case PSI_T_DOUBLE:
 158                 if (val->type == PSI_T_NUMBER) {
 159                         val->type = PSI_T_DOUBLE;
 160                         val->ival.dval = psi_num_exp_get_double(val->data.num, NULL, scope->cpp);
 161 #if PSI_IMPL_DEF_VAL_DEBUG
 162                         PSI_DEBUG_PRINT(data, "PSI: NUMBER (double) %" PRIdval " from ", val->ival.dval);
 163                         PSI_DEBUG_DUMP(data, psi_num_exp_dump, val->data.num);
 164                         PSI_DEBUG_PRINT(data, "\n");
 165 #endif
 166                         psi_num_exp_free(&val->data.num);
 167                 }
 168                 if (val->type == PSI_T_DOUBLE) {
 169                         return true;
 170                 }
 171                 break;
 172
 173         case PSI_T_STRING:
 174                 if (val->type == PSI_T_STRING) {
 175                         return true;
 176                 }
 177                 break;
 178
 179         case PSI_T_MIXED:
 180                 switch (val->type) {
 181                 case PSI_T_TRUE:
 182                 case PSI_T_FALSE:
 183                 case PSI_T_NULL:
 184                 case PSI_T_STRING:
 185                 case PSI_T_FLOAT:
 186                 case PSI_T_DOUBLE:
 187                 case PSI_T_INT:
 188                         return true;
 189                 default:
 190                         break;
 191                 }
 192                 if (val->type == PSI_T_NUMBER) {
 193                         token_t typ = psi_num_exp_exec(val->data.num, &val->ival, NULL, scope->cpp);
 194
 195                         switch (typ) {
 196                         case PSI_T_FLOAT:
 197 #if HAVE_LONG_DOUBLE
 198                         case PSI_T_LONG_DOUBLE:
 199 #endif
 200                         promote_double: ;
 201                                 psi_calc_cast(typ, &val->ival, PSI_T_DOUBLE, &val->ival);
 202                                 /* no break */
 203                         case PSI_T_DOUBLE:
 204                                 val->type = PSI_T_DOUBLE;
 205                                 return true;
 206                         case PSI_T_UINT64:
 207                                 if (val->ival.u64 > (uint64_t) ZEND_LONG_MAX) {
 208                                         if (val->ival.u64 > (1LU<<53)) {
 209                                                 char buf[0x20];
 210
 211                                                 /* convert to string */
 212                                                 char *res = zend_print_ulong_to_buf(buf + sizeof(buf) - 1, val->ival.u64);
 213                                                 val->type = PSI_T_STRING;
 214                                                 val->ival.zend.str = zend_string_init(res, buf + sizeof(buf) - 1 - res, 1);
 215
 216                                                 return true;
 217                                         }
 218                                         goto promote_double;
 219                                 }
 220                                 /* no break */
 221                         default:
 222                                 psi_calc_cast(typ, &val->ival, PSI_T_INT64, &val->ival);
 223                                 /* no break */
 224                         case PSI_T_INT64:
 225                                 val->type = PSI_T_INT;
 226                                 return true;
 227                         }
 228                 }
 229                 /* no break */
 230         default:
 231                 data->error(data, val->token, PSI_WARNING,
 232                                 "Invalid default value type '%s', "
 233                                 "expected one of bool, int, float, string.",
 234                                 type ? type->name->val : "mixed");
 235         }
 236
 237         return false;
 238 }
 239
 240 void psi_impl_def_val_dump(int fd, struct psi_impl_def_val *val) {
 241         switch (val->type) {
 242         case PSI_T_NULL:
 243                 dprintf(fd, "NULL");
 244                 break;
 245         case PSI_T_TRUE:
 246                 dprintf(fd, "true");
 247                 break;
 248         case PSI_T_FALSE:
 249                 dprintf(fd, "false");
 250                 break;
 251         case PSI_T_BOOL:
 252                 dprintf(fd, "%s", val->ival.zend.bval ? "true" : "false");
 253                 break;
 254         case PSI_T_INT:
 255                 dprintf(fd, ZEND_LONG_FMT, val->ival.zend.lval);
 256                 break;
 257         case PSI_T_FLOAT:
 258         case PSI_T_DOUBLE:
 259                 if (isinf(val->ival.dval)) {
 260                         dprintf(fd, "\\INF");
 261                 } else if (isnan(val->ival.dval)) {
 262                         dprintf(fd, "\\NAN");
 263                 } else {
 264                         dprintf(fd, "%" PRIdval, val->ival.dval);
 265                 }
 266                 break;
 267         case PSI_T_STRING:
 268                 dprintf(fd, "\"%s\"", val->ival.zend.str->val);
 269                 break;
 270         case PSI_T_NUMBER:
 271                 psi_num_exp_dump(fd, val->data.num);
 272                 break;
 273         default:
 274                 assert(0);
 275         }
 276 }