feature.h

   1 /* -*- buffer-read-only: t -*-
   2    !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
   3    This file is built by regen/feature.pl.
   4    Any changes made here will be lost!
   5  */
   6
   7
   8 #ifndef PERL_FEATURE_H_
   9 #define PERL_FEATURE_H_
  10
  11 #if defined(PERL_CORE) || defined (PERL_EXT)
  12
  13 #define HINT_FEATURE_SHIFT      26
  14
  15 #define FEATURE_BAREWORD_FILEHANDLES_BIT 0x0001
  16 #define FEATURE_BITWISE_BIT              0x0002
  17 #define FEATURE___SUB___BIT              0x0004
  18 #define FEATURE_MYREF_BIT                0x0008
  19 #define FEATURE_DEFER_BIT                0x0010
  20 #define FEATURE_EVALBYTES_BIT            0x0020
  21 #define FEATURE_FC_BIT                   0x0040
  22 #define FEATURE_INDIRECT_BIT             0x0080
  23 #define FEATURE_ISA_BIT                  0x0100
  24 #define FEATURE_MULTIDIMENSIONAL_BIT     0x0200
  25 #define FEATURE_POSTDEREF_QQ_BIT         0x0400
  26 #define FEATURE_REFALIASING_BIT          0x0800
  27 #define FEATURE_SAY_BIT                  0x1000
  28 #define FEATURE_SIGNATURES_BIT           0x2000
  29 #define FEATURE_STATE_BIT                0x4000
  30 #define FEATURE_SWITCH_BIT               0x8000
  31 #define FEATURE_TRY_BIT                  0x10000
  32 #define FEATURE_UNIEVAL_BIT              0x20000
  33 #define FEATURE_UNICODE_BIT              0x40000
  34
  35 #define FEATURE_BUNDLE_DEFAULT  0
  36 #define FEATURE_BUNDLE_510      1
  37 #define FEATURE_BUNDLE_511      2
  38 #define FEATURE_BUNDLE_515      3
  39 #define FEATURE_BUNDLE_523      4
  40 #define FEATURE_BUNDLE_527      5
  41 #define FEATURE_BUNDLE_535      6
  42 #define FEATURE_BUNDLE_CUSTOM   (HINT_FEATURE_MASK >> HINT_FEATURE_SHIFT)
  43
  44 #define CURRENT_HINTS \
  45     (PL_curcop == &PL_compiling ? PL_hints : PL_curcop->cop_hints)
  46 #define CURRENT_FEATURE_BUNDLE \
  47     ((CURRENT_HINTS & HINT_FEATURE_MASK) >> HINT_FEATURE_SHIFT)
  48
  49 #define FEATURE_IS_ENABLED_MASK(mask)                   \
  50   ((CURRENT_HINTS & HINT_LOCALIZE_HH)                \
  51     ? (PL_curcop->cop_features & (mask)) : FALSE)
  52
  53 /* The longest string we pass in.  */
  54 #define MAX_FEATURE_LEN (sizeof("bareword_filehandles")-1)
  55
  56 #define FEATURE_FC_IS_ENABLED \
  57     ( \
  58         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
  59          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
  60      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
  61          FEATURE_IS_ENABLED_MASK(FEATURE_FC_BIT)) \
  62     )
  63
  64 #define FEATURE_ISA_IS_ENABLED \
  65     ( \
  66         CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_535 \
  67      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
  68          FEATURE_IS_ENABLED_MASK(FEATURE_ISA_BIT)) \
  69     )
  70
  71 #define FEATURE_SAY_IS_ENABLED \
  72     ( \
  73         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
  74          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
  75      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
  76          FEATURE_IS_ENABLED_MASK(FEATURE_SAY_BIT)) \
  77     )
  78
  79 #define FEATURE_TRY_IS_ENABLED \
  80     ( \
  81         CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
  82          FEATURE_IS_ENABLED_MASK(FEATURE_TRY_BIT) \
  83     )
  84
  85 #define FEATURE_DEFER_IS_ENABLED \
  86     ( \
  87         CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
  88          FEATURE_IS_ENABLED_MASK(FEATURE_DEFER_BIT) \
  89     )
  90
  91 #define FEATURE_STATE_IS_ENABLED \
  92     ( \
  93         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
  94          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
  95      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
  96          FEATURE_IS_ENABLED_MASK(FEATURE_STATE_BIT)) \
  97     )
  98
  99 #define FEATURE_SWITCH_IS_ENABLED \
 100     ( \
 101         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
 102          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527) \
 103      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 104          FEATURE_IS_ENABLED_MASK(FEATURE_SWITCH_BIT)) \
 105     )
 106
 107 #define FEATURE_BITWISE_IS_ENABLED \
 108     ( \
 109         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_527 && \
 110          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
 111      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 112          FEATURE_IS_ENABLED_MASK(FEATURE_BITWISE_BIT)) \
 113     )
 114
 115 #define FEATURE_INDIRECT_IS_ENABLED \
 116     ( \
 117         CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
 118      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 119          FEATURE_IS_ENABLED_MASK(FEATURE_INDIRECT_BIT)) \
 120     )
 121
 122 #define FEATURE_EVALBYTES_IS_ENABLED \
 123     ( \
 124         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
 125          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
 126      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 127          FEATURE_IS_ENABLED_MASK(FEATURE_EVALBYTES_BIT)) \
 128     )
 129
 130 #define FEATURE_SIGNATURES_IS_ENABLED \
 131     ( \
 132         CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 133          FEATURE_IS_ENABLED_MASK(FEATURE_SIGNATURES_BIT) \
 134     )
 135
 136 #define FEATURE___SUB___IS_ENABLED \
 137     ( \
 138         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
 139          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
 140      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 141          FEATURE_IS_ENABLED_MASK(FEATURE___SUB___BIT)) \
 142     )
 143
 144 #define FEATURE_REFALIASING_IS_ENABLED \
 145     ( \
 146         CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 147          FEATURE_IS_ENABLED_MASK(FEATURE_REFALIASING_BIT) \
 148     )
 149
 150 #define FEATURE_POSTDEREF_QQ_IS_ENABLED \
 151     ( \
 152         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_523 && \
 153          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
 154      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 155          FEATURE_IS_ENABLED_MASK(FEATURE_POSTDEREF_QQ_BIT)) \
 156     )
 157
 158 #define FEATURE_UNIEVAL_IS_ENABLED \
 159     ( \
 160         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
 161          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
 162      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 163          FEATURE_IS_ENABLED_MASK(FEATURE_UNIEVAL_BIT)) \
 164     )
 165
 166 #define FEATURE_MYREF_IS_ENABLED \
 167     ( \
 168         CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 169          FEATURE_IS_ENABLED_MASK(FEATURE_MYREF_BIT) \
 170     )
 171
 172 #define FEATURE_UNICODE_IS_ENABLED \
 173     ( \
 174         (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_511 && \
 175          CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535) \
 176      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 177          FEATURE_IS_ENABLED_MASK(FEATURE_UNICODE_BIT)) \
 178     )
 179
 180 #define FEATURE_MULTIDIMENSIONAL_IS_ENABLED \
 181     ( \
 182         CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
 183      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 184          FEATURE_IS_ENABLED_MASK(FEATURE_MULTIDIMENSIONAL_BIT)) \
 185     )
 186
 187 #define FEATURE_BAREWORD_FILEHANDLES_IS_ENABLED \
 188     ( \
 189         CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
 190      || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
 191          FEATURE_IS_ENABLED_MASK(FEATURE_BAREWORD_FILEHANDLES_BIT)) \
 192     )
 193
 194
 195 #define SAVEFEATUREBITS() SAVEI32(PL_compiling.cop_features)
 196
 197 #define CLEARFEATUREBITS() (PL_compiling.cop_features = 0)
 198
 199 #define STOREFEATUREBITSHH(hh) \
 200   (hv_stores((hh), "feature/bits", newSVuv(PL_compiling.cop_features)))
 201
 202 #define FETCHFEATUREBITSHH(hh)                              \
 203   STMT_START {                                              \
 204       SV **fbsv = hv_fetchs((hh), "feature/bits", FALSE);   \
 205       PL_compiling.cop_features = fbsv ? SvUV(*fbsv) : 0;   \
 206   } STMT_END
 207
 208 #endif /* PERL_CORE or PERL_EXT */
 209
 210 #ifdef PERL_IN_OP_C
 211 PERL_STATIC_INLINE void
 212 S_enable_feature_bundle(pTHX_ SV *ver)
 213 {
 214     SV *comp_ver = sv_newmortal();
 215     PL_hints = (PL_hints &~ HINT_FEATURE_MASK)
 216              | (
 217                   (sv_setnv(comp_ver, 5.035),
 218                    vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
 219                         ? FEATURE_BUNDLE_535 :
 220                   (sv_setnv(comp_ver, 5.027),
 221                    vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
 222                         ? FEATURE_BUNDLE_527 :
 223                   (sv_setnv(comp_ver, 5.023),
 224                    vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
 225                         ? FEATURE_BUNDLE_523 :
 226                   (sv_setnv(comp_ver, 5.015),
 227                    vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
 228                         ? FEATURE_BUNDLE_515 :
 229                   (sv_setnv(comp_ver, 5.011),
 230                    vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
 231                         ? FEATURE_BUNDLE_511 :
 232                   (sv_setnv(comp_ver, 5.009005),
 233                    vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
 234                         ? FEATURE_BUNDLE_510 :
 235                           FEATURE_BUNDLE_DEFAULT
 236                ) << HINT_FEATURE_SHIFT;
 237     /* special case */
 238     assert(PL_curcop == &PL_compiling);
 239     if (FEATURE_UNICODE_IS_ENABLED) PL_hints |=  HINT_UNI_8_BIT;
 240     else                            PL_hints &= ~HINT_UNI_8_BIT;
 241 }
 242 #endif /* PERL_IN_OP_C */
 243
 244 #ifdef PERL_IN_MG_C
 245
 246 #define magic_sethint_feature(keysv, keypv, keylen, valsv, valbool) \
 247     S_magic_sethint_feature(aTHX_ (keysv), (keypv), (keylen), (valsv), (valbool))
 248 PERL_STATIC_INLINE void
 249 S_magic_sethint_feature(pTHX_ SV *keysv, const char *keypv, STRLEN keylen,
 250                         SV *valsv, bool valbool) {
 251     if (keysv)
 252       keypv = SvPV_const(keysv, keylen);
 253
 254     if (memBEGINs(keypv, keylen, "feature_")) {
 255         const char *subf = keypv + (sizeof("feature_")-1);
 256         U32 mask = 0;
 257         switch (*subf) {
 258         case '_':
 259             if (keylen == sizeof("feature___SUB__")-1
 260                  && memcmp(subf+1, "_SUB__", keylen - sizeof("feature_")) == 0) {
 261                 mask = FEATURE___SUB___BIT;
 262                 break;
 263             }
 264             return;
 265
 266         case 'b':
 267             if (keylen == sizeof("feature_bareword_filehandles")-1
 268                  && memcmp(subf+1, "areword_filehandles", keylen - sizeof("feature_")) == 0) {
 269                 mask = FEATURE_BAREWORD_FILEHANDLES_BIT;
 270                 break;
 271             }
 272             else if (keylen == sizeof("feature_bitwise")-1
 273                  && memcmp(subf+1, "itwise", keylen - sizeof("feature_")) == 0) {
 274                 mask = FEATURE_BITWISE_BIT;
 275                 break;
 276             }
 277             return;
 278
 279         case 'd':
 280             if (keylen == sizeof("feature_defer")-1
 281                  && memcmp(subf+1, "efer", keylen - sizeof("feature_")) == 0) {
 282                 mask = FEATURE_DEFER_BIT;
 283                 break;
 284             }
 285             return;
 286
 287         case 'e':
 288             if (keylen == sizeof("feature_evalbytes")-1
 289                  && memcmp(subf+1, "valbytes", keylen - sizeof("feature_")) == 0) {
 290                 mask = FEATURE_EVALBYTES_BIT;
 291                 break;
 292             }
 293             return;
 294
 295         case 'f':
 296             if (keylen == sizeof("feature_fc")-1
 297                  && memcmp(subf+1, "c", keylen - sizeof("feature_")) == 0) {
 298                 mask = FEATURE_FC_BIT;
 299                 break;
 300             }
 301             return;
 302
 303         case 'i':
 304             if (keylen == sizeof("feature_indirect")-1
 305                  && memcmp(subf+1, "ndirect", keylen - sizeof("feature_")) == 0) {
 306                 mask = FEATURE_INDIRECT_BIT;
 307                 break;
 308             }
 309             else if (keylen == sizeof("feature_isa")-1
 310                  && memcmp(subf+1, "sa", keylen - sizeof("feature_")) == 0) {
 311                 mask = FEATURE_ISA_BIT;
 312                 break;
 313             }
 314             return;
 315
 316         case 'm':
 317             if (keylen == sizeof("feature_multidimensional")-1
 318                  && memcmp(subf+1, "ultidimensional", keylen - sizeof("feature_")) == 0) {
 319                 mask = FEATURE_MULTIDIMENSIONAL_BIT;
 320                 break;
 321             }
 322             else if (keylen == sizeof("feature_myref")-1
 323                  && memcmp(subf+1, "yref", keylen - sizeof("feature_")) == 0) {
 324                 mask = FEATURE_MYREF_BIT;
 325                 break;
 326             }
 327             return;
 328
 329         case 'p':
 330             if (keylen == sizeof("feature_postderef_qq")-1
 331                  && memcmp(subf+1, "ostderef_qq", keylen - sizeof("feature_")) == 0) {
 332                 mask = FEATURE_POSTDEREF_QQ_BIT;
 333                 break;
 334             }
 335             return;
 336
 337         case 'r':
 338             if (keylen == sizeof("feature_refaliasing")-1
 339                  && memcmp(subf+1, "efaliasing", keylen - sizeof("feature_")) == 0) {
 340                 mask = FEATURE_REFALIASING_BIT;
 341                 break;
 342             }
 343             return;
 344
 345         case 's':
 346             if (keylen == sizeof("feature_say")-1
 347                  && memcmp(subf+1, "ay", keylen - sizeof("feature_")) == 0) {
 348                 mask = FEATURE_SAY_BIT;
 349                 break;
 350             }
 351             else if (keylen == sizeof("feature_signatures")-1
 352                  && memcmp(subf+1, "ignatures", keylen - sizeof("feature_")) == 0) {
 353                 mask = FEATURE_SIGNATURES_BIT;
 354                 break;
 355             }
 356             else if (keylen == sizeof("feature_state")-1
 357                  && memcmp(subf+1, "tate", keylen - sizeof("feature_")) == 0) {
 358                 mask = FEATURE_STATE_BIT;
 359                 break;
 360             }
 361             else if (keylen == sizeof("feature_switch")-1
 362                  && memcmp(subf+1, "witch", keylen - sizeof("feature_")) == 0) {
 363                 mask = FEATURE_SWITCH_BIT;
 364                 break;
 365             }
 366             return;
 367
 368         case 't':
 369             if (keylen == sizeof("feature_try")-1
 370                  && memcmp(subf+1, "ry", keylen - sizeof("feature_")) == 0) {
 371                 mask = FEATURE_TRY_BIT;
 372                 break;
 373             }
 374             return;
 375
 376         case 'u':
 377             if (keylen == sizeof("feature_unicode")-1
 378                  && memcmp(subf+1, "nicode", keylen - sizeof("feature_")) == 0) {
 379                 mask = FEATURE_UNICODE_BIT;
 380                 break;
 381             }
 382             else if (keylen == sizeof("feature_unieval")-1
 383                  && memcmp(subf+1, "nieval", keylen - sizeof("feature_")) == 0) {
 384                 mask = FEATURE_UNIEVAL_BIT;
 385                 break;
 386             }
 387             return;
 388
 389         default:
 390             return;
 391         }
 392         if (valsv ? SvTRUE(valsv) : valbool)
 393             PL_compiling.cop_features |= mask;
 394         else
 395             PL_compiling.cop_features &= ~mask;
 396     }
 397 }
 398 #endif /* PERL_IN_MG_C */
 399
 400 #endif /* PERL_FEATURE_H_ */
 401
 402 /* ex: set ro: */