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