git.m6w6.name Git - m6w6/ext-psi/blob - src/types/cpp_exp.c

   1 /*******************************************************************************
   2  Copyright (c) 2017, 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
  28 #include <assert.h>
  29
  30 #include "data.h"
  31 #include "cpp.h"
  32
  33 struct psi_cpp_exp *psi_cpp_exp_init(token_t type, void *data)
  34 {
  35         struct psi_cpp_exp *exp = calloc(1, sizeof(*exp));
  36
  37         switch ((exp->type = type)) {
  38         case PSI_T_WARNING:
  39         case PSI_T_ERROR:
  40         case PSI_T_UNDEF:
  41         case PSI_T_IFDEF:
  42         case PSI_T_IFNDEF:
  43         case PSI_T_IMPORT:
  44         case PSI_T_INCLUDE:
  45         case PSI_T_INCLUDE_NEXT:
  46                 exp->data.tok = data;
  47                 break;
  48         case PSI_T_DEFINE:
  49                 exp->data.decl = data;
  50                 break;
  51         case PSI_T_IF:
  52         case PSI_T_ELIF:
  53                 exp->data.num = data;
  54                 break;
  55         case PSI_T_ENDIF:
  56         case PSI_T_ELSE:
  57         case PSI_T_ONCE:
  58                 break;
  59         default:
  60                 assert(0);
  61                 break;
  62         }
  63
  64         return exp;
  65 }
  66
  67 void psi_cpp_exp_free(struct psi_cpp_exp **exp_ptr)
  68 {
  69         if (*exp_ptr) {
  70                 struct psi_cpp_exp *exp = *exp_ptr;
  71
  72                 *exp_ptr = NULL;
  73                 switch (exp->type) {
  74                 case PSI_T_WARNING:
  75                 case PSI_T_ERROR:
  76                         if (!exp->data.tok) {
  77                                 break;
  78                         }
  79                         /* no break */
  80                 case PSI_T_UNDEF:
  81                 case PSI_T_IFDEF:
  82                 case PSI_T_IFNDEF:
  83                 case PSI_T_IMPORT:
  84                 case PSI_T_INCLUDE:
  85                 case PSI_T_INCLUDE_NEXT:
  86                         free(exp->data.tok);
  87                         exp->data.tok = NULL;
  88                         break;
  89                 case PSI_T_DEFINE:
  90                         psi_cpp_macro_decl_free(&exp->data.decl);
  91                         break;
  92                 case PSI_T_IF:
  93                 case PSI_T_ELIF:
  94                         psi_num_exp_free(&exp->data.num);
  95                         break;
  96                 case PSI_T_ENDIF:
  97                 case PSI_T_ELSE:
  98                 case PSI_T_ONCE:
  99                         break;
 100                 default:
 101                         assert(0);
 102                         break;
 103                 }
 104                 if (exp->token) {
 105                         free(exp->token);
 106                 }
 107                 free(exp);
 108         }
 109 }
 110
 111 void psi_cpp_exp_dump(int fd, struct psi_cpp_exp *exp)
 112 {
 113         dprintf(fd, "#%s ", exp->token->text);
 114         switch (exp->type) {
 115         case PSI_T_WARNING:
 116         case PSI_T_ERROR:
 117                 if (!exp->data.tok) {
 118                         break;
 119                 }
 120                 /* no break */
 121         case PSI_T_UNDEF:
 122         case PSI_T_IFDEF:
 123         case PSI_T_IFNDEF:
 124         case PSI_T_IMPORT:
 125         case PSI_T_INCLUDE:
 126         case PSI_T_INCLUDE_NEXT:
 127                 dprintf(fd, "%s", exp->data.tok->text);
 128                 break;
 129         case PSI_T_DEFINE:
 130                 psi_cpp_macro_decl_dump(fd, exp->data.decl);
 131                 break;
 132         case PSI_T_IF:
 133         case PSI_T_ELIF:
 134                 psi_num_exp_dump(fd, exp->data.num);
 135                 break;
 136         case PSI_T_ENDIF:
 137         case PSI_T_ELSE:
 138         case PSI_T_ONCE:
 139                 break;
 140         default:
 141                 assert(0);
 142                 break;
 143         }
 144         dprintf(fd, "\n");
 145 }
 146
 147
 148 static inline bool psi_cpp_level_skipped(struct psi_cpp *cpp)
 149 {
 150         return cpp->skip == cpp->level;
 151 }
 152
 153 static inline void psi_cpp_level_skip(struct psi_cpp *cpp)
 154 {
 155         assert(!cpp->skip);
 156         cpp->skip = cpp->level;
 157 }
 158
 159 static inline void psi_cpp_level_unskip(struct psi_cpp *cpp)
 160 {
 161         if (psi_cpp_level_skipped(cpp)) {
 162                 cpp->skip = 0;
 163         }
 164 }
 165
 166 static inline bool psi_cpp_level_masked(struct psi_cpp *cpp)
 167 {
 168         return cpp->seen & (1 << cpp->level);
 169 }
 170
 171 static inline void psi_cpp_level_mask(struct psi_cpp *cpp)
 172 {
 173         assert(!psi_cpp_level_masked(cpp));
 174         cpp->seen |= (1 << cpp->level);
 175 }
 176
 177 static inline void psi_cpp_level_unmask(struct psi_cpp *cpp)
 178 {
 179         cpp->seen &= ~(1 << cpp->level);
 180 }
 181
 182 void psi_cpp_exp_exec(struct psi_cpp_exp *exp, struct psi_cpp *cpp, struct psi_data *D)
 183 {
 184         PSI_DEBUG_PRINT(D, "PSI: CPP EVAL < %s (level=%u, skip=%u)\n",
 185                         exp->token->text, cpp->level, cpp->skip);
 186
 187 #if PSI_CPP_DEBUG
 188         psi_cpp_exp_dump(2, exp);
 189 #endif
 190
 191         switch (exp->type) {
 192         case PSI_T_ERROR:
 193                 if (!cpp->skip) {
 194                         D->error(D, exp->token, PSI_ERROR, "%s",
 195                                         exp->data.tok ? exp->data.tok->text : "");
 196                 }
 197                 break;
 198         case PSI_T_WARNING:
 199                 if (!cpp->skip) {
 200                         D->error(D, exp->token, PSI_WARNING, "%s",
 201                                         exp->data.tok ? exp->data.tok->text : "");
 202                 }
 203                 break;
 204         case PSI_T_UNDEF:
 205                 if (!cpp->skip) {
 206                         psi_cpp_undef(cpp, exp->data.tok);
 207                 }
 208                 break;
 209         case PSI_T_DEFINE:
 210                 if (!cpp->skip) {
 211                         psi_cpp_define(cpp, exp->data.decl);
 212                         /* FIXME: copy */
 213                         exp->data.decl = NULL;
 214                 }
 215                 break;
 216         case PSI_T_IFDEF:
 217                 ++cpp->level;
 218                 if (!cpp->skip) {
 219                         if (psi_cpp_defined(cpp, exp->data.tok)) {
 220                                 psi_cpp_level_mask(cpp);
 221                         } else {
 222                                 psi_cpp_level_skip(cpp);
 223                         }
 224                 }
 225                 break;
 226         case PSI_T_IFNDEF:
 227                 ++cpp->level;
 228                 if (!cpp->skip) {
 229                         if (psi_cpp_defined(cpp, exp->data.tok)) {
 230                                 psi_cpp_level_skip(cpp);
 231                         } else {
 232                                 psi_cpp_level_mask(cpp);
 233                         }
 234                 }
 235                 break;
 236         case PSI_T_IF:
 237                 ++cpp->level;
 238                 if (!cpp->skip) {
 239                         if (psi_cpp_if(cpp, exp)) {
 240                                 psi_cpp_level_mask(cpp);
 241                         } else {
 242                                 psi_cpp_level_skip(cpp);
 243                         }
 244                 }
 245                 break;
 246         case PSI_T_ENDIF:
 247                 if (!cpp->level) {
 248                         D->error(D, exp->token, PSI_WARNING, "Ingoring lone #endif");
 249                 } else {
 250                         psi_cpp_level_unskip(cpp);
 251                         psi_cpp_level_unmask(cpp);
 252                         --cpp->level;
 253                 }
 254                 break;
 255         case PSI_T_ELSE:
 256                 /* FIXME: catch "else" after "else" */
 257                 if (!cpp->level) {
 258                         D->error(D, exp->token, PSI_WARNING, "Ingoring lone #else");
 259                 } else if (psi_cpp_level_skipped(cpp) && !psi_cpp_level_masked(cpp)) {
 260                         /*
 261                          * if skip is set on this level and the level has
 262                          * not been masked yet, then unskip and mask this level
 263                          */
 264                         psi_cpp_level_unskip(cpp);
 265                         psi_cpp_level_mask(cpp);
 266                 } else if (!cpp->skip && psi_cpp_level_masked(cpp)) {
 267                         /*
 268                          * previous block masked this level
 269                          */
 270                         psi_cpp_level_skip(cpp);
 271                 } else {
 272                         assert(cpp->skip <= cpp->level);
 273                 }
 274                 break;
 275         case PSI_T_ELIF:
 276                 if (!cpp->level) {
 277                         D->error(D, exp->token, PSI_WARNING, "Ingoring lone #elif");
 278                 } else if (psi_cpp_level_skipped(cpp) && !psi_cpp_level_masked(cpp)) {
 279                         /*
 280                          * if skip is set on this level and the level has
 281                          * not been masked yet, then unskip and mask this
 282                          * level, if the condition evals truthy
 283                          */
 284                         if (psi_cpp_if(cpp, exp)) {
 285                                 psi_cpp_level_unskip(cpp);
 286                                 psi_cpp_level_mask(cpp);
 287                         }
 288                 } else if (!cpp->skip && psi_cpp_level_masked(cpp)) {
 289                         /*
 290                          * previous block masked this level
 291                          */
 292                         psi_cpp_level_skip(cpp);
 293                 } else {
 294                         assert(cpp->skip <= cpp->level);
 295                 }
 296                 break;
 297         case PSI_T_INCLUDE:
 298                 if (!cpp->skip) {
 299                         if (!psi_cpp_include(cpp, exp->data.tok->text, PSI_CPP_INCLUDE)) {
 300                                 D->error(D, exp->token, PSI_WARNING, "Failed to include %s", exp->data.tok->text);
 301                         }
 302                 }
 303                 break;
 304         case PSI_T_INCLUDE_NEXT:
 305                 if (!cpp->skip) {
 306                         if (!psi_cpp_include(cpp, exp->data.tok->text, PSI_CPP_INCLUDE_NEXT)) {
 307                                 D->error(D, exp->token, PSI_WARNING, "Failed to include %s", exp->data.tok->text);
 308                         }
 309                 }
 310                 break;
 311         case PSI_T_IMPORT:
 312                 if (!cpp->skip) {
 313                         if (!psi_cpp_include(cpp, exp->data.tok->text, PSI_CPP_INCLUDE_ONCE)) {
 314                                 D->error(D, exp->token, PSI_WARNING, "Failed to include %s", exp->data.tok->text);
 315                         }
 316                 }
 317         case PSI_T_ONCE:
 318                 if (!cpp->skip) {
 319                         zend_hash_str_add_empty_element(&cpp->once, exp->token->file, strlen(exp->token->file));
 320                 }
 321                 break;
 322         default:
 323                 assert(0);
 324                 break;
 325         }
 326
 327         PSI_DEBUG_PRINT(D, "PSI: CPP EVAL > %s (level=%u, skip=%u)\n",
 328                         exp->token->text, cpp->level, cpp->skip);
 329 }