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