toke.c: factor out static yyl_key_core() and yyl_word_or_keyword()

1 files changed, 947 insertions, 945 deletions

diff --git a/toke.c b/toke.c
index e6fb322006..7c398e7611 100644
--- a/toke.c
+++ b/toke.c
@@ -7465,6 +7465,947 @@ yyl_just_a_word(pTHX_ char *s, STRLEN len, I32 key, I32 orig_keyword,
 }
 
 static int
+yyl_word_or_keyword(pTHX_ char *s, STRLEN len, I32 key, I32 orig_keyword,
+                    struct code c, bool bof, const bool saw_infix_sigil)
+{
+    switch (key) {
+    default:			/* not a keyword */
+        return yyl_just_a_word(aTHX_ s, len, key, orig_keyword,
+                               c, saw_infix_sigil);
+
+    case KEY___FILE__:
+        FUN0OP( newSVOP(OP_CONST, 0, newSVpv(CopFILE(PL_curcop),0)) );
+
+    case KEY___LINE__:
+        FUN0OP(
+            newSVOP(OP_CONST, 0,
+                Perl_newSVpvf(aTHX_ "%" IVdf, (IV)CopLINE(PL_curcop)))
+        );
+
+    case KEY___PACKAGE__:
+        FUN0OP(
+            newSVOP(OP_CONST, 0, (PL_curstash
+                                     ? newSVhek(HvNAME_HEK(PL_curstash))
+                                     : &PL_sv_undef))
+        );
+
+    case KEY___DATA__:
+    case KEY___END__:
+        if (PL_rsfp && (!PL_in_eval || PL_tokenbuf[2] == 'D'))
+            yyl_data_handle(aTHX);
+        return yyl_fake_eof(aTHX_ LEX_FAKE_EOF, bof, s, len);
+
+    case KEY___SUB__:
+        FUN0OP(CvCLONE(PL_compcv)
+                    ? newOP(OP_RUNCV, 0)
+                    : newPVOP(OP_RUNCV,0,NULL));
+
+    case KEY_AUTOLOAD:
+    case KEY_DESTROY:
+    case KEY_BEGIN:
+    case KEY_UNITCHECK:
+    case KEY_CHECK:
+    case KEY_INIT:
+    case KEY_END:
+        if (PL_expect == XSTATE)
+            return yyl_sub(aTHX_ PL_bufptr, key);
+        return yyl_just_a_word(aTHX_ s, len, key, orig_keyword,
+                               c, saw_infix_sigil);
+
+    case KEY_abs:
+        UNI(OP_ABS);
+
+    case KEY_alarm:
+        UNI(OP_ALARM);
+
+    case KEY_accept:
+        LOP(OP_ACCEPT,XTERM);
+
+    case KEY_and:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_LOWLOGIC)
+            return REPORT(0);
+        OPERATOR(ANDOP);
+
+    case KEY_atan2:
+        LOP(OP_ATAN2,XTERM);
+
+    case KEY_bind:
+        LOP(OP_BIND,XTERM);
+
+    case KEY_binmode:
+        LOP(OP_BINMODE,XTERM);
+
+    case KEY_bless:
+        LOP(OP_BLESS,XTERM);
+
+    case KEY_break:
+        FUN0(OP_BREAK);
+
+    case KEY_chop:
+        UNI(OP_CHOP);
+
+    case KEY_continue:
+        /* We have to disambiguate the two senses of
+          "continue". If the next token is a '{' then
+          treat it as the start of a continue block;
+          otherwise treat it as a control operator.
+         */
+        s = skipspace(s);
+        if (*s == '{')
+            PREBLOCK(CONTINUE);
+        else
+            FUN0(OP_CONTINUE);
+
+    case KEY_chdir:
+        /* may use HOME */
+        (void)gv_fetchpvs("ENV", GV_ADD|GV_NOTQUAL, SVt_PVHV);
+        UNI(OP_CHDIR);
+
+    case KEY_close:
+        UNI(OP_CLOSE);
+
+    case KEY_closedir:
+        UNI(OP_CLOSEDIR);
+
+    case KEY_cmp:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Eop(OP_SCMP);
+
+    case KEY_caller:
+        UNI(OP_CALLER);
+
+    case KEY_crypt:
+#ifdef FCRYPT
+        if (!PL_cryptseen) {
+            PL_cryptseen = TRUE;
+            init_des();
+        }
+#endif
+        LOP(OP_CRYPT,XTERM);
+
+    case KEY_chmod:
+        LOP(OP_CHMOD,XTERM);
+
+    case KEY_chown:
+        LOP(OP_CHOWN,XTERM);
+
+    case KEY_connect:
+        LOP(OP_CONNECT,XTERM);
+
+    case KEY_chr:
+        UNI(OP_CHR);
+
+    case KEY_cos:
+        UNI(OP_COS);
+
+    case KEY_chroot:
+        UNI(OP_CHROOT);
+
+    case KEY_default:
+        PREBLOCK(DEFAULT);
+
+    case KEY_do:
+        return yyl_do(aTHX_ s, orig_keyword);
+
+    case KEY_die:
+        PL_hints |= HINT_BLOCK_SCOPE;
+        LOP(OP_DIE,XTERM);
+
+    case KEY_defined:
+        UNI(OP_DEFINED);
+
+    case KEY_delete:
+        UNI(OP_DELETE);
+
+    case KEY_dbmopen:
+        Perl_populate_isa(aTHX_ STR_WITH_LEN("AnyDBM_File::ISA"),
+                          STR_WITH_LEN("NDBM_File::"),
+                          STR_WITH_LEN("DB_File::"),
+                          STR_WITH_LEN("GDBM_File::"),
+                          STR_WITH_LEN("SDBM_File::"),
+                          STR_WITH_LEN("ODBM_File::"),
+                          NULL);
+        LOP(OP_DBMOPEN,XTERM);
+
+    case KEY_dbmclose:
+        UNI(OP_DBMCLOSE);
+
+    case KEY_dump:
+        LOOPX(OP_DUMP);
+
+    case KEY_else:
+        PREBLOCK(ELSE);
+
+    case KEY_elsif:
+        pl_yylval.ival = CopLINE(PL_curcop);
+        OPERATOR(ELSIF);
+
+    case KEY_eq:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Eop(OP_SEQ);
+
+    case KEY_exists:
+        UNI(OP_EXISTS);
+
+    case KEY_exit:
+        UNI(OP_EXIT);
+
+    case KEY_eval:
+        s = skipspace(s);
+        if (*s == '{') { /* block eval */
+            PL_expect = XTERMBLOCK;
+            UNIBRACK(OP_ENTERTRY);
+        }
+        else { /* string eval */
+            PL_expect = XTERM;
+            UNIBRACK(OP_ENTEREVAL);
+        }
+
+    case KEY_evalbytes:
+        PL_expect = XTERM;
+        UNIBRACK(-OP_ENTEREVAL);
+
+    case KEY_eof:
+        UNI(OP_EOF);
+
+    case KEY_exp:
+        UNI(OP_EXP);
+
+    case KEY_each:
+        UNI(OP_EACH);
+
+    case KEY_exec:
+        LOP(OP_EXEC,XREF);
+
+    case KEY_endhostent:
+        FUN0(OP_EHOSTENT);
+
+    case KEY_endnetent:
+        FUN0(OP_ENETENT);
+
+    case KEY_endservent:
+        FUN0(OP_ESERVENT);
+
+    case KEY_endprotoent:
+        FUN0(OP_EPROTOENT);
+
+    case KEY_endpwent:
+        FUN0(OP_EPWENT);
+
+    case KEY_endgrent:
+        FUN0(OP_EGRENT);
+
+    case KEY_for:
+    case KEY_foreach:
+        return yyl_foreach(aTHX_ s);
+
+    case KEY_formline:
+        LOP(OP_FORMLINE,XTERM);
+
+    case KEY_fork:
+        FUN0(OP_FORK);
+
+    case KEY_fc:
+        UNI(OP_FC);
+
+    case KEY_fcntl:
+        LOP(OP_FCNTL,XTERM);
+
+    case KEY_fileno:
+        UNI(OP_FILENO);
+
+    case KEY_flock:
+        LOP(OP_FLOCK,XTERM);
+
+    case KEY_gt:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Rop(OP_SGT);
+
+    case KEY_ge:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Rop(OP_SGE);
+
+    case KEY_grep:
+        LOP(OP_GREPSTART, XREF);
+
+    case KEY_goto:
+        LOOPX(OP_GOTO);
+
+    case KEY_gmtime:
+        UNI(OP_GMTIME);
+
+    case KEY_getc:
+        UNIDOR(OP_GETC);
+
+    case KEY_getppid:
+        FUN0(OP_GETPPID);
+
+    case KEY_getpgrp:
+        UNI(OP_GETPGRP);
+
+    case KEY_getpriority:
+        LOP(OP_GETPRIORITY,XTERM);
+
+    case KEY_getprotobyname:
+        UNI(OP_GPBYNAME);
+
+    case KEY_getprotobynumber:
+        LOP(OP_GPBYNUMBER,XTERM);
+
+    case KEY_getprotoent:
+        FUN0(OP_GPROTOENT);
+
+    case KEY_getpwent:
+        FUN0(OP_GPWENT);
+
+    case KEY_getpwnam:
+        UNI(OP_GPWNAM);
+
+    case KEY_getpwuid:
+        UNI(OP_GPWUID);
+
+    case KEY_getpeername:
+        UNI(OP_GETPEERNAME);
+
+    case KEY_gethostbyname:
+        UNI(OP_GHBYNAME);
+
+    case KEY_gethostbyaddr:
+        LOP(OP_GHBYADDR,XTERM);
+
+    case KEY_gethostent:
+        FUN0(OP_GHOSTENT);
+
+    case KEY_getnetbyname:
+        UNI(OP_GNBYNAME);
+
+    case KEY_getnetbyaddr:
+        LOP(OP_GNBYADDR,XTERM);
+
+    case KEY_getnetent:
+        FUN0(OP_GNETENT);
+
+    case KEY_getservbyname:
+        LOP(OP_GSBYNAME,XTERM);
+
+    case KEY_getservbyport:
+        LOP(OP_GSBYPORT,XTERM);
+
+    case KEY_getservent:
+        FUN0(OP_GSERVENT);
+
+    case KEY_getsockname:
+        UNI(OP_GETSOCKNAME);
+
+    case KEY_getsockopt:
+        LOP(OP_GSOCKOPT,XTERM);
+
+    case KEY_getgrent:
+        FUN0(OP_GGRENT);
+
+    case KEY_getgrnam:
+        UNI(OP_GGRNAM);
+
+    case KEY_getgrgid:
+        UNI(OP_GGRGID);
+
+    case KEY_getlogin:
+        FUN0(OP_GETLOGIN);
+
+    case KEY_given:
+        pl_yylval.ival = CopLINE(PL_curcop);
+        Perl_ck_warner_d(aTHX_ packWARN(WARN_EXPERIMENTAL__SMARTMATCH),
+                         "given is experimental");
+        OPERATOR(GIVEN);
+
+    case KEY_glob:
+        LOP( orig_keyword==KEY_glob ? -OP_GLOB : OP_GLOB, XTERM );
+
+    case KEY_hex:
+        UNI(OP_HEX);
+
+    case KEY_if:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
+            return REPORT(0);
+        pl_yylval.ival = CopLINE(PL_curcop);
+        OPERATOR(IF);
+
+    case KEY_index:
+        LOP(OP_INDEX,XTERM);
+
+    case KEY_int:
+        UNI(OP_INT);
+
+    case KEY_ioctl:
+        LOP(OP_IOCTL,XTERM);
+
+    case KEY_join:
+        LOP(OP_JOIN,XTERM);
+
+    case KEY_keys:
+        UNI(OP_KEYS);
+
+    case KEY_kill:
+        LOP(OP_KILL,XTERM);
+
+    case KEY_last:
+        LOOPX(OP_LAST);
+
+    case KEY_lc:
+        UNI(OP_LC);
+
+    case KEY_lcfirst:
+        UNI(OP_LCFIRST);
+
+    case KEY_local:
+        OPERATOR(LOCAL);
+
+    case KEY_length:
+        UNI(OP_LENGTH);
+
+    case KEY_lt:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Rop(OP_SLT);
+
+    case KEY_le:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Rop(OP_SLE);
+
+    case KEY_localtime:
+        UNI(OP_LOCALTIME);
+
+    case KEY_log:
+        UNI(OP_LOG);
+
+    case KEY_link:
+        LOP(OP_LINK,XTERM);
+
+    case KEY_listen:
+        LOP(OP_LISTEN,XTERM);
+
+    case KEY_lock:
+        UNI(OP_LOCK);
+
+    case KEY_lstat:
+        UNI(OP_LSTAT);
+
+    case KEY_m:
+        s = scan_pat(s,OP_MATCH);
+        TERM(sublex_start());
+
+    case KEY_map:
+        LOP(OP_MAPSTART, XREF);
+
+    case KEY_mkdir:
+        LOP(OP_MKDIR,XTERM);
+
+    case KEY_msgctl:
+        LOP(OP_MSGCTL,XTERM);
+
+    case KEY_msgget:
+        LOP(OP_MSGGET,XTERM);
+
+    case KEY_msgrcv:
+        LOP(OP_MSGRCV,XTERM);
+
+    case KEY_msgsnd:
+        LOP(OP_MSGSND,XTERM);
+
+    case KEY_our:
+    case KEY_my:
+    case KEY_state:
+        return yyl_my(aTHX_ s, key);
+
+    case KEY_next:
+        LOOPX(OP_NEXT);
+
+    case KEY_ne:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
+            return REPORT(0);
+        Eop(OP_SNE);
+
+    case KEY_no:
+        s = tokenize_use(0, s);
+        TOKEN(USE);
+
+    case KEY_not:
+        if (*s == '(' || (s = skipspace(s), *s == '('))
+            FUN1(OP_NOT);
+        else {
+            if (!PL_lex_allbrackets && PL_lex_fakeeof > LEX_FAKEEOF_LOWLOGIC)
+                PL_lex_fakeeof = LEX_FAKEEOF_LOWLOGIC;
+            OPERATOR(NOTOP);
+        }
+
+    case KEY_open:
+        s = skipspace(s);
+        if (isIDFIRST_lazy_if_safe(s, PL_bufend, UTF)) {
+            const char *t;
+            char *d = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len);
+            for (t=d; isSPACE(*t);)
+                t++;
+            if ( *t && strchr("|&*+-=!?:.", *t) && ckWARN_d(WARN_PRECEDENCE)
+                /* [perl #16184] */
+                && !(t[0] == '=' && t[1] == '>')
+                && !(t[0] == ':' && t[1] == ':')
+                && !keyword(s, d-s, 0)
+            ) {
+                Perl_warner(aTHX_ packWARN(WARN_PRECEDENCE),
+                   "Precedence problem: open %" UTF8f " should be open(%" UTF8f ")",
+                    UTF8fARG(UTF, d-s, s), UTF8fARG(UTF, d-s, s));
+            }
+        }
+        LOP(OP_OPEN,XTERM);
+
+    case KEY_or:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_LOWLOGIC)
+            return REPORT(0);
+        pl_yylval.ival = OP_OR;
+        OPERATOR(OROP);
+
+    case KEY_ord:
+        UNI(OP_ORD);
+
+    case KEY_oct:
+        UNI(OP_OCT);
+
+    case KEY_opendir:
+        LOP(OP_OPEN_DIR,XTERM);
+
+    case KEY_print:
+        checkcomma(s,PL_tokenbuf,"filehandle");
+        LOP(OP_PRINT,XREF);
+
+    case KEY_printf:
+        checkcomma(s,PL_tokenbuf,"filehandle");
+        LOP(OP_PRTF,XREF);
+
+    case KEY_prototype:
+        UNI(OP_PROTOTYPE);
+
+    case KEY_push:
+        LOP(OP_PUSH,XTERM);
+
+    case KEY_pop:
+        UNIDOR(OP_POP);
+
+    case KEY_pos:
+        UNIDOR(OP_POS);
+
+    case KEY_pack:
+        LOP(OP_PACK,XTERM);
+
+    case KEY_package:
+        s = force_word(s,BAREWORD,FALSE,TRUE);
+        s = skipspace(s);
+        s = force_strict_version(s);
+        PREBLOCK(PACKAGE);
+
+    case KEY_pipe:
+        LOP(OP_PIPE_OP,XTERM);
+
+    case KEY_q:
+        s = scan_str(s,FALSE,FALSE,FALSE,NULL);
+        if (!s)
+            missingterm(NULL, 0);
+        COPLINE_SET_FROM_MULTI_END;
+        pl_yylval.ival = OP_CONST;
+        TERM(sublex_start());
+
+    case KEY_quotemeta:
+        UNI(OP_QUOTEMETA);
+
+    case KEY_qw:
+        return yyl_qw(aTHX_ s, len);
+
+    case KEY_qq:
+        s = scan_str(s,FALSE,FALSE,FALSE,NULL);
+        if (!s)
+            missingterm(NULL, 0);
+        pl_yylval.ival = OP_STRINGIFY;
+        if (SvIVX(PL_lex_stuff) == '\'')
+            SvIV_set(PL_lex_stuff, 0);	/* qq'$foo' should interpolate */
+        TERM(sublex_start());
+
+    case KEY_qr:
+        s = scan_pat(s,OP_QR);
+        TERM(sublex_start());
+
+    case KEY_qx:
+        s = scan_str(s,FALSE,FALSE,FALSE,NULL);
+        if (!s)
+            missingterm(NULL, 0);
+        pl_yylval.ival = OP_BACKTICK;
+        TERM(sublex_start());
+
+    case KEY_return:
+        OLDLOP(OP_RETURN);
+
+    case KEY_require:
+        return yyl_require(aTHX_ s, orig_keyword);
+
+    case KEY_reset:
+        UNI(OP_RESET);
+
+    case KEY_redo:
+        LOOPX(OP_REDO);
+
+    case KEY_rename:
+        LOP(OP_RENAME,XTERM);
+
+    case KEY_rand:
+        UNI(OP_RAND);
+
+    case KEY_rmdir:
+        UNI(OP_RMDIR);
+
+    case KEY_rindex:
+        LOP(OP_RINDEX,XTERM);
+
+    case KEY_read:
+        LOP(OP_READ,XTERM);
+
+    case KEY_readdir:
+        UNI(OP_READDIR);
+
+    case KEY_readline:
+        UNIDOR(OP_READLINE);
+
+    case KEY_readpipe:
+        UNIDOR(OP_BACKTICK);
+
+    case KEY_rewinddir:
+        UNI(OP_REWINDDIR);
+
+    case KEY_recv:
+        LOP(OP_RECV,XTERM);
+
+    case KEY_reverse:
+        LOP(OP_REVERSE,XTERM);
+
+    case KEY_readlink:
+        UNIDOR(OP_READLINK);
+
+    case KEY_ref:
+        UNI(OP_REF);
+
+    case KEY_s:
+        s = scan_subst(s);
+        if (pl_yylval.opval)
+            TERM(sublex_start());
+        else
+            TOKEN(1);	/* force error */
+
+    case KEY_say:
+        checkcomma(s,PL_tokenbuf,"filehandle");
+        LOP(OP_SAY,XREF);
+
+    case KEY_chomp:
+        UNI(OP_CHOMP);
+
+    case KEY_scalar:
+        UNI(OP_SCALAR);
+
+    case KEY_select:
+        LOP(OP_SELECT,XTERM);
+
+    case KEY_seek:
+        LOP(OP_SEEK,XTERM);
+
+    case KEY_semctl:
+        LOP(OP_SEMCTL,XTERM);
+
+    case KEY_semget:
+        LOP(OP_SEMGET,XTERM);
+
+    case KEY_semop:
+        LOP(OP_SEMOP,XTERM);
+
+    case KEY_send:
+        LOP(OP_SEND,XTERM);
+
+    case KEY_setpgrp:
+        LOP(OP_SETPGRP,XTERM);
+
+    case KEY_setpriority:
+        LOP(OP_SETPRIORITY,XTERM);
+
+    case KEY_sethostent:
+        UNI(OP_SHOSTENT);
+
+    case KEY_setnetent:
+        UNI(OP_SNETENT);
+
+    case KEY_setservent:
+        UNI(OP_SSERVENT);
+
+    case KEY_setprotoent:
+        UNI(OP_SPROTOENT);
+
+    case KEY_setpwent:
+        FUN0(OP_SPWENT);
+
+    case KEY_setgrent:
+        FUN0(OP_SGRENT);
+
+    case KEY_seekdir:
+        LOP(OP_SEEKDIR,XTERM);
+
+    case KEY_setsockopt:
+        LOP(OP_SSOCKOPT,XTERM);
+
+    case KEY_shift:
+        UNIDOR(OP_SHIFT);
+
+    case KEY_shmctl:
+        LOP(OP_SHMCTL,XTERM);
+
+    case KEY_shmget:
+        LOP(OP_SHMGET,XTERM);
+
+    case KEY_shmread:
+        LOP(OP_SHMREAD,XTERM);
+
+    case KEY_shmwrite:
+        LOP(OP_SHMWRITE,XTERM);
+
+    case KEY_shutdown:
+        LOP(OP_SHUTDOWN,XTERM);
+
+    case KEY_sin:
+        UNI(OP_SIN);
+
+    case KEY_sleep:
+        UNI(OP_SLEEP);
+
+    case KEY_socket:
+        LOP(OP_SOCKET,XTERM);
+
+    case KEY_socketpair:
+        LOP(OP_SOCKPAIR,XTERM);
+
+    case KEY_sort:
+        checkcomma(s,PL_tokenbuf,"subroutine name");
+        s = skipspace(s);
+        PL_expect = XTERM;
+        s = force_word(s,BAREWORD,TRUE,TRUE);
+        LOP(OP_SORT,XREF);
+
+    case KEY_split:
+        LOP(OP_SPLIT,XTERM);
+
+    case KEY_sprintf:
+        LOP(OP_SPRINTF,XTERM);
+
+    case KEY_splice:
+        LOP(OP_SPLICE,XTERM);
+
+    case KEY_sqrt:
+        UNI(OP_SQRT);
+
+    case KEY_srand:
+        UNI(OP_SRAND);
+
+    case KEY_stat:
+        UNI(OP_STAT);
+
+    case KEY_study:
+        UNI(OP_STUDY);
+
+    case KEY_substr:
+        LOP(OP_SUBSTR,XTERM);
+
+    case KEY_format:
+    case KEY_sub:
+        return yyl_sub(aTHX_ s, key);
+
+    case KEY_system:
+        LOP(OP_SYSTEM,XREF);
+
+    case KEY_symlink:
+        LOP(OP_SYMLINK,XTERM);
+
+    case KEY_syscall:
+        LOP(OP_SYSCALL,XTERM);
+
+    case KEY_sysopen:
+        LOP(OP_SYSOPEN,XTERM);
+
+    case KEY_sysseek:
+        LOP(OP_SYSSEEK,XTERM);
+
+    case KEY_sysread:
+        LOP(OP_SYSREAD,XTERM);
+
+    case KEY_syswrite:
+        LOP(OP_SYSWRITE,XTERM);
+
+    case KEY_tr:
+    case KEY_y:
+        s = scan_trans(s);
+        TERM(sublex_start());
+
+    case KEY_tell:
+        UNI(OP_TELL);
+
+    case KEY_telldir:
+        UNI(OP_TELLDIR);
+
+    case KEY_tie:
+        LOP(OP_TIE,XTERM);
+
+    case KEY_tied:
+        UNI(OP_TIED);
+
+    case KEY_time:
+        FUN0(OP_TIME);
+
+    case KEY_times:
+        FUN0(OP_TMS);
+
+    case KEY_truncate:
+        LOP(OP_TRUNCATE,XTERM);
+
+    case KEY_uc:
+        UNI(OP_UC);
+
+    case KEY_ucfirst:
+        UNI(OP_UCFIRST);
+
+    case KEY_untie:
+        UNI(OP_UNTIE);
+
+    case KEY_until:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
+            return REPORT(0);
+        pl_yylval.ival = CopLINE(PL_curcop);
+        OPERATOR(UNTIL);
+
+    case KEY_unless:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
+            return REPORT(0);
+        pl_yylval.ival = CopLINE(PL_curcop);
+        OPERATOR(UNLESS);
+
+    case KEY_unlink:
+        LOP(OP_UNLINK,XTERM);
+
+    case KEY_undef:
+        UNIDOR(OP_UNDEF);
+
+    case KEY_unpack:
+        LOP(OP_UNPACK,XTERM);
+
+    case KEY_utime:
+        LOP(OP_UTIME,XTERM);
+
+    case KEY_umask:
+        UNIDOR(OP_UMASK);
+
+    case KEY_unshift:
+        LOP(OP_UNSHIFT,XTERM);
+
+    case KEY_use:
+        s = tokenize_use(1, s);
+        TOKEN(USE);
+
+    case KEY_values:
+        UNI(OP_VALUES);
+
+    case KEY_vec:
+        LOP(OP_VEC,XTERM);
+
+    case KEY_when:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
+            return REPORT(0);
+        pl_yylval.ival = CopLINE(PL_curcop);
+        Perl_ck_warner_d(aTHX_
+            packWARN(WARN_EXPERIMENTAL__SMARTMATCH),
+            "when is experimental");
+        OPERATOR(WHEN);
+
+    case KEY_while:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
+            return REPORT(0);
+        pl_yylval.ival = CopLINE(PL_curcop);
+        OPERATOR(WHILE);
+
+    case KEY_warn:
+        PL_hints |= HINT_BLOCK_SCOPE;
+        LOP(OP_WARN,XTERM);
+
+    case KEY_wait:
+        FUN0(OP_WAIT);
+
+    case KEY_waitpid:
+        LOP(OP_WAITPID,XTERM);
+
+    case KEY_wantarray:
+        FUN0(OP_WANTARRAY);
+
+    case KEY_write:
+        /* Make sure $^L is defined. 0x0C is CTRL-L on ASCII platforms, and
+         * we use the same number on EBCDIC */
+        gv_fetchpvs("\x0C", GV_ADD|GV_NOTQUAL, SVt_PV);
+        UNI(OP_ENTERWRITE);
+
+    case KEY_x:
+        if (PL_expect == XOPERATOR) {
+            if (*s == '=' && !PL_lex_allbrackets
+                && PL_lex_fakeeof >= LEX_FAKEEOF_ASSIGN)
+            {
+                return REPORT(0);
+            }
+            Mop(OP_REPEAT);
+        }
+        check_uni();
+        return yyl_just_a_word(aTHX_ s, len, key, orig_keyword,
+                               c, saw_infix_sigil);
+
+    case KEY_xor:
+        if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_LOWLOGIC)
+            return REPORT(0);
+        pl_yylval.ival = OP_XOR;
+        OPERATOR(OROP);
+    }
+}
+
+static int
+yyl_key_core(pTHX_ char *s, STRLEN len, I32 key, I32 orig_keyword,
+             struct code c, bool bof, const bool saw_infix_sigil)
+{
+    STRLEN olen = len;
+    char *d = s;
+    s += 2;
+    s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len);
+    if ((*s == ':' && s[1] == ':')
+        || (!(key = keyword(PL_tokenbuf, len, 1)) && *s == '\''))
+    {
+        Copy(PL_bufptr, PL_tokenbuf, olen, char);
+        return yyl_just_a_word(aTHX_ d, olen, key, orig_keyword, c, saw_infix_sigil);
+    }
+    if (!key)
+        Perl_croak(aTHX_ "CORE::%" UTF8f " is not a keyword",
+                          UTF8fARG(UTF, len, PL_tokenbuf));
+    if (key < 0)
+        key = -key;
+    else if (key == KEY_require || key == KEY_do
+          || key == KEY_glob)
+        /* that's a way to remember we saw "CORE::" */
+        orig_keyword = key;
+
+    /* Known to be a reserved word at this point */
+    return yyl_word_or_keyword(aTHX_ s, len, key, orig_keyword, c,
+                               bof, saw_infix_sigil);
+}
+
+static int
 yyl_try(pTHX_ char initial_state, char *s, STRLEN len,
         U8 formbrack, const bool saw_infix_sigil)
 {
@@ -7950,8 +8891,10 @@ yyl_try(pTHX_ char initial_state, char *s, STRLEN len,
 
 	/* x::* is just a word, unless x is "CORE" */
 	if (!anydelim && *s == ':' && s[1] == ':') {
-	    if (memEQs(PL_tokenbuf, len, "CORE")) goto case_KEY_CORE;
-            return yyl_just_a_word(aTHX_ s, len, 0, orig_keyword, MAKE_CODE(FALSE), saw_infix_sigil);
+            struct code c = MAKE_CODE(FALSE);
+            if (memEQs(PL_tokenbuf, len, "CORE"))
+                return yyl_key_core(aTHX_ s, len, tmp, orig_keyword, c, bof, saw_infix_sigil);
+            return yyl_just_a_word(aTHX_ s, len, 0, orig_keyword, c, saw_infix_sigil);
 	}
 
 	d = s;
@@ -8058,949 +9001,8 @@ yyl_try(pTHX_ char initial_state, char *s, STRLEN len,
                 return yyl_fatcomma(aTHX_ s, len);
 	}
 
-      reserved_word:
-	switch (tmp) {
-	default:			/* not a keyword */
-            return yyl_just_a_word(aTHX_ s, len, tmp, orig_keyword,
-                                   MAKE_CODE(FALSE), saw_infix_sigil);
-
-	case KEY___FILE__:
-	    FUN0OP(
-                newSVOP(OP_CONST, 0, newSVpv(CopFILE(PL_curcop),0))
-	    );
-
-	case KEY___LINE__:
-	    FUN0OP(
-                newSVOP(OP_CONST, 0,
-		    Perl_newSVpvf(aTHX_ "%" IVdf, (IV)CopLINE(PL_curcop)))
-	    );
-
-	case KEY___PACKAGE__:
-	    FUN0OP(
-                newSVOP(OP_CONST, 0,
-					(PL_curstash
-					 ? newSVhek(HvNAME_HEK(PL_curstash))
-					 : &PL_sv_undef))
-	    );
-
-	case KEY___DATA__:
-	case KEY___END__:
-            if (PL_rsfp && (!PL_in_eval || PL_tokenbuf[2] == 'D'))
-                yyl_data_handle(aTHX);
-            return yyl_fake_eof(aTHX_ LEX_FAKE_EOF, bof, s, len);
-
-	case KEY___SUB__:
-	    FUN0OP(CvCLONE(PL_compcv)
-			? newOP(OP_RUNCV, 0)
-			: newPVOP(OP_RUNCV,0,NULL));
-
-	case KEY_AUTOLOAD:
-	case KEY_DESTROY:
-	case KEY_BEGIN:
-	case KEY_UNITCHECK:
-	case KEY_CHECK:
-	case KEY_INIT:
-	case KEY_END:
-	    if (PL_expect == XSTATE)
-		return yyl_sub(aTHX_ PL_bufptr, tmp);
-            return yyl_just_a_word(aTHX_ s, len, tmp, orig_keyword,
-                                   MAKE_CODE(FALSE), saw_infix_sigil);
-
-	case_KEY_CORE:
-	    {
-		STRLEN olen = len;
-		d = s;
-		s += 2;
-		s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len);
-		if ((*s == ':' && s[1] == ':')
-		 || (!(tmp = keyword(PL_tokenbuf, len, 1)) && *s == '\''))
-		{
-		    Copy(PL_bufptr, PL_tokenbuf, olen, char);
-                    return yyl_just_a_word(aTHX_ d, olen, tmp, orig_keyword,
-                                           MAKE_CODE(FALSE), saw_infix_sigil);
-		}
-		if (!tmp)
-		    Perl_croak(aTHX_ "CORE::%" UTF8f " is not a keyword",
-				      UTF8fARG(UTF, len, PL_tokenbuf));
-		if (tmp < 0)
-		    tmp = -tmp;
-		else if (tmp == KEY_require || tmp == KEY_do
-		      || tmp == KEY_glob)
-		    /* that's a way to remember we saw "CORE::" */
-		    orig_keyword = tmp;
-		goto reserved_word;
-	    }
-
-	case KEY_abs:
-	    UNI(OP_ABS);
-
-	case KEY_alarm:
-	    UNI(OP_ALARM);
-
-	case KEY_accept:
-	    LOP(OP_ACCEPT,XTERM);
-
-	case KEY_and:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_LOWLOGIC)
-		return REPORT(0);
-	    OPERATOR(ANDOP);
-
-	case KEY_atan2:
-	    LOP(OP_ATAN2,XTERM);
-
-	case KEY_bind:
-	    LOP(OP_BIND,XTERM);
-
-	case KEY_binmode:
-	    LOP(OP_BINMODE,XTERM);
-
-	case KEY_bless:
-	    LOP(OP_BLESS,XTERM);
-
-	case KEY_break:
-	    FUN0(OP_BREAK);
-
-	case KEY_chop:
-	    UNI(OP_CHOP);
-
-	case KEY_continue:
-		    /* We have to disambiguate the two senses of
-		      "continue". If the next token is a '{' then
-		      treat it as the start of a continue block;
-		      otherwise treat it as a control operator.
-		     */
-		    s = skipspace(s);
-		    if (*s == '{')
-	    PREBLOCK(CONTINUE);
-		    else
-			FUN0(OP_CONTINUE);
-
-	case KEY_chdir:
-	    /* may use HOME */
-	    (void)gv_fetchpvs("ENV", GV_ADD|GV_NOTQUAL, SVt_PVHV);
-	    UNI(OP_CHDIR);
-
-	case KEY_close:
-	    UNI(OP_CLOSE);
-
-	case KEY_closedir:
-	    UNI(OP_CLOSEDIR);
-
-	case KEY_cmp:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Eop(OP_SCMP);
-
-	case KEY_caller:
-	    UNI(OP_CALLER);
-
-	case KEY_crypt:
-#ifdef FCRYPT
-	    if (!PL_cryptseen) {
-		PL_cryptseen = TRUE;
-		init_des();
-	    }
-#endif
-	    LOP(OP_CRYPT,XTERM);
-
-	case KEY_chmod:
-	    LOP(OP_CHMOD,XTERM);
-
-	case KEY_chown:
-	    LOP(OP_CHOWN,XTERM);
-
-	case KEY_connect:
-	    LOP(OP_CONNECT,XTERM);
-
-	case KEY_chr:
-	    UNI(OP_CHR);
-
-	case KEY_cos:
-	    UNI(OP_COS);
-
-	case KEY_chroot:
-	    UNI(OP_CHROOT);
-
-	case KEY_default:
-	    PREBLOCK(DEFAULT);
-
-	case KEY_do:
-            return yyl_do(aTHX_ s, orig_keyword);
-
-	case KEY_die:
-	    PL_hints |= HINT_BLOCK_SCOPE;
-	    LOP(OP_DIE,XTERM);
-
-	case KEY_defined:
-	    UNI(OP_DEFINED);
-
-	case KEY_delete:
-	    UNI(OP_DELETE);
-
-	case KEY_dbmopen:
-	    Perl_populate_isa(aTHX_ STR_WITH_LEN("AnyDBM_File::ISA"),
-			      STR_WITH_LEN("NDBM_File::"),
-			      STR_WITH_LEN("DB_File::"),
-			      STR_WITH_LEN("GDBM_File::"),
-			      STR_WITH_LEN("SDBM_File::"),
-			      STR_WITH_LEN("ODBM_File::"),
-			      NULL);
-	    LOP(OP_DBMOPEN,XTERM);
-
-	case KEY_dbmclose:
-	    UNI(OP_DBMCLOSE);
-
-	case KEY_dump:
-	    LOOPX(OP_DUMP);
-
-	case KEY_else:
-	    PREBLOCK(ELSE);
-
-	case KEY_elsif:
-	    pl_yylval.ival = CopLINE(PL_curcop);
-	    OPERATOR(ELSIF);
-
-	case KEY_eq:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Eop(OP_SEQ);
-
-	case KEY_exists:
-	    UNI(OP_EXISTS);
-
-	case KEY_exit:
-	    UNI(OP_EXIT);
-
-	case KEY_eval:
-	    s = skipspace(s);
-	    if (*s == '{') { /* block eval */
-		PL_expect = XTERMBLOCK;
-		UNIBRACK(OP_ENTERTRY);
-	    }
-	    else { /* string eval */
-		PL_expect = XTERM;
-		UNIBRACK(OP_ENTEREVAL);
-	    }
-
-	case KEY_evalbytes:
-	    PL_expect = XTERM;
-	    UNIBRACK(-OP_ENTEREVAL);
-
-	case KEY_eof:
-	    UNI(OP_EOF);
-
-	case KEY_exp:
-	    UNI(OP_EXP);
-
-	case KEY_each:
-	    UNI(OP_EACH);
-
-	case KEY_exec:
-	    LOP(OP_EXEC,XREF);
-
-	case KEY_endhostent:
-	    FUN0(OP_EHOSTENT);
-
-	case KEY_endnetent:
-	    FUN0(OP_ENETENT);
-
-	case KEY_endservent:
-	    FUN0(OP_ESERVENT);
-
-	case KEY_endprotoent:
-	    FUN0(OP_EPROTOENT);
-
-	case KEY_endpwent:
-	    FUN0(OP_EPWENT);
-
-	case KEY_endgrent:
-	    FUN0(OP_EGRENT);
-
-	case KEY_for:
-	case KEY_foreach:
-            return yyl_foreach(aTHX_ s);
-
-	case KEY_formline:
-	    LOP(OP_FORMLINE,XTERM);
-
-	case KEY_fork:
-	    FUN0(OP_FORK);
-
-	case KEY_fc:
-	    UNI(OP_FC);
-
-	case KEY_fcntl:
-	    LOP(OP_FCNTL,XTERM);
-
-	case KEY_fileno:
-	    UNI(OP_FILENO);
-
-	case KEY_flock:
-	    LOP(OP_FLOCK,XTERM);
-
-	case KEY_gt:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Rop(OP_SGT);
-
-	case KEY_ge:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Rop(OP_SGE);
-
-	case KEY_grep:
-	    LOP(OP_GREPSTART, XREF);
-
-	case KEY_goto:
-	    LOOPX(OP_GOTO);
-
-	case KEY_gmtime:
-	    UNI(OP_GMTIME);
-
-	case KEY_getc:
-	    UNIDOR(OP_GETC);
-
-	case KEY_getppid:
-	    FUN0(OP_GETPPID);
-
-	case KEY_getpgrp:
-	    UNI(OP_GETPGRP);
-
-	case KEY_getpriority:
-	    LOP(OP_GETPRIORITY,XTERM);
-
-	case KEY_getprotobyname:
-	    UNI(OP_GPBYNAME);
-
-	case KEY_getprotobynumber:
-	    LOP(OP_GPBYNUMBER,XTERM);
-
-	case KEY_getprotoent:
-	    FUN0(OP_GPROTOENT);
-
-	case KEY_getpwent:
-	    FUN0(OP_GPWENT);
-
-	case KEY_getpwnam:
-	    UNI(OP_GPWNAM);
-
-	case KEY_getpwuid:
-	    UNI(OP_GPWUID);
-
-	case KEY_getpeername:
-	    UNI(OP_GETPEERNAME);
-
-	case KEY_gethostbyname:
-	    UNI(OP_GHBYNAME);
-
-	case KEY_gethostbyaddr:
-	    LOP(OP_GHBYADDR,XTERM);
-
-	case KEY_gethostent:
-	    FUN0(OP_GHOSTENT);
-
-	case KEY_getnetbyname:
-	    UNI(OP_GNBYNAME);
-
-	case KEY_getnetbyaddr:
-	    LOP(OP_GNBYADDR,XTERM);
-
-	case KEY_getnetent:
-	    FUN0(OP_GNETENT);
-
-	case KEY_getservbyname:
-	    LOP(OP_GSBYNAME,XTERM);
-
-	case KEY_getservbyport:
-	    LOP(OP_GSBYPORT,XTERM);
-
-	case KEY_getservent:
-	    FUN0(OP_GSERVENT);
-
-	case KEY_getsockname:
-	    UNI(OP_GETSOCKNAME);
-
-	case KEY_getsockopt:
-	    LOP(OP_GSOCKOPT,XTERM);
-
-	case KEY_getgrent:
-	    FUN0(OP_GGRENT);
-
-	case KEY_getgrnam:
-	    UNI(OP_GGRNAM);
-
-	case KEY_getgrgid:
-	    UNI(OP_GGRGID);
-
-	case KEY_getlogin:
-	    FUN0(OP_GETLOGIN);
-
-	case KEY_given:
-	    pl_yylval.ival = CopLINE(PL_curcop);
-            Perl_ck_warner_d(aTHX_
-                packWARN(WARN_EXPERIMENTAL__SMARTMATCH),
-                "given is experimental");
-	    OPERATOR(GIVEN);
-
-	case KEY_glob:
-	    LOP(
-	     orig_keyword==KEY_glob ? -OP_GLOB : OP_GLOB,
-	     XTERM
-	    );
-
-	case KEY_hex:
-	    UNI(OP_HEX);
-
-	case KEY_if:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
-		return REPORT(0);
-	    pl_yylval.ival = CopLINE(PL_curcop);
-	    OPERATOR(IF);
-
-	case KEY_index:
-	    LOP(OP_INDEX,XTERM);
-
-	case KEY_int:
-	    UNI(OP_INT);
-
-	case KEY_ioctl:
-	    LOP(OP_IOCTL,XTERM);
-
-	case KEY_join:
-	    LOP(OP_JOIN,XTERM);
-
-	case KEY_keys:
-	    UNI(OP_KEYS);
-
-	case KEY_kill:
-	    LOP(OP_KILL,XTERM);
-
-	case KEY_last:
-	    LOOPX(OP_LAST);
-
-	case KEY_lc:
-	    UNI(OP_LC);
-
-	case KEY_lcfirst:
-	    UNI(OP_LCFIRST);
-
-	case KEY_local:
-	    OPERATOR(LOCAL);
-
-	case KEY_length:
-	    UNI(OP_LENGTH);
-
-	case KEY_lt:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Rop(OP_SLT);
-
-	case KEY_le:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Rop(OP_SLE);
-
-	case KEY_localtime:
-	    UNI(OP_LOCALTIME);
-
-	case KEY_log:
-	    UNI(OP_LOG);
-
-	case KEY_link:
-	    LOP(OP_LINK,XTERM);
-
-	case KEY_listen:
-	    LOP(OP_LISTEN,XTERM);
-
-	case KEY_lock:
-	    UNI(OP_LOCK);
-
-	case KEY_lstat:
-	    UNI(OP_LSTAT);
-
-	case KEY_m:
-	    s = scan_pat(s,OP_MATCH);
-	    TERM(sublex_start());
-
-	case KEY_map:
-	    LOP(OP_MAPSTART, XREF);
-
-	case KEY_mkdir:
-	    LOP(OP_MKDIR,XTERM);
-
-	case KEY_msgctl:
-	    LOP(OP_MSGCTL,XTERM);
-
-	case KEY_msgget:
-	    LOP(OP_MSGGET,XTERM);
-
-	case KEY_msgrcv:
-	    LOP(OP_MSGRCV,XTERM);
-
-	case KEY_msgsnd:
-	    LOP(OP_MSGSND,XTERM);
-
-	case KEY_our:
-	case KEY_my:
-	case KEY_state:
-            return yyl_my(aTHX_ s, tmp);
-
-	case KEY_next:
-	    LOOPX(OP_NEXT);
-
-	case KEY_ne:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_COMPARE)
-		return REPORT(0);
-	    Eop(OP_SNE);
-
-	case KEY_no:
-	    s = tokenize_use(0, s);
-	    TOKEN(USE);
-
-	case KEY_not:
-	    if (*s == '(' || (s = skipspace(s), *s == '('))
-		FUN1(OP_NOT);
-	    else {
-		if (!PL_lex_allbrackets
-                    && PL_lex_fakeeof > LEX_FAKEEOF_LOWLOGIC)
-                {
-		    PL_lex_fakeeof = LEX_FAKEEOF_LOWLOGIC;
-                }
-		OPERATOR(NOTOP);
-	    }
-
-	case KEY_open:
-	    s = skipspace(s);
-            if (isIDFIRST_lazy_if_safe(s, PL_bufend, UTF)) {
-                const char *t;
-                d = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE,
-                              &len);
-		for (t=d; isSPACE(*t);)
-		    t++;
-		if ( *t && strchr("|&*+-=!?:.", *t) && ckWARN_d(WARN_PRECEDENCE)
-		    /* [perl #16184] */
-		    && !(t[0] == '=' && t[1] == '>')
-		    && !(t[0] == ':' && t[1] == ':')
-		    && !keyword(s, d-s, 0)
-		) {
-		    Perl_warner(aTHX_ packWARN(WARN_PRECEDENCE),
-		       "Precedence problem: open %" UTF8f " should be open(%" UTF8f ")",
-			UTF8fARG(UTF, d-s, s), UTF8fARG(UTF, d-s, s));
-		}
-	    }
-	    LOP(OP_OPEN,XTERM);
-
-	case KEY_or:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_LOWLOGIC)
-		return REPORT(0);
-	    pl_yylval.ival = OP_OR;
-	    OPERATOR(OROP);
-
-	case KEY_ord:
-	    UNI(OP_ORD);
-
-	case KEY_oct:
-	    UNI(OP_OCT);
-
-	case KEY_opendir:
-	    LOP(OP_OPEN_DIR,XTERM);
-
-	case KEY_print:
-	    checkcomma(s,PL_tokenbuf,"filehandle");
-	    LOP(OP_PRINT,XREF);
-
-	case KEY_printf:
-	    checkcomma(s,PL_tokenbuf,"filehandle");
-	    LOP(OP_PRTF,XREF);
-
-	case KEY_prototype:
-	    UNI(OP_PROTOTYPE);
-
-	case KEY_push:
-	    LOP(OP_PUSH,XTERM);
-
-	case KEY_pop:
-	    UNIDOR(OP_POP);
-
-	case KEY_pos:
-	    UNIDOR(OP_POS);
-
-	case KEY_pack:
-	    LOP(OP_PACK,XTERM);
-
-	case KEY_package:
-	    s = force_word(s,BAREWORD,FALSE,TRUE);
-	    s = skipspace(s);
-	    s = force_strict_version(s);
-	    PREBLOCK(PACKAGE);
-
-	case KEY_pipe:
-	    LOP(OP_PIPE_OP,XTERM);
-
-	case KEY_q:
-	    s = scan_str(s,FALSE,FALSE,FALSE,NULL);
-	    if (!s)
-		missingterm(NULL, 0);
-	    COPLINE_SET_FROM_MULTI_END;
-	    pl_yylval.ival = OP_CONST;
-	    TERM(sublex_start());
-
-	case KEY_quotemeta:
-	    UNI(OP_QUOTEMETA);
-
-	case KEY_qw:
-            return yyl_qw(aTHX_ s, len);
-
-	case KEY_qq:
-	    s = scan_str(s,FALSE,FALSE,FALSE,NULL);
-	    if (!s)
-		missingterm(NULL, 0);
-	    pl_yylval.ival = OP_STRINGIFY;
-	    if (SvIVX(PL_lex_stuff) == '\'')
-		SvIV_set(PL_lex_stuff, 0);	/* qq'$foo' should interpolate */
-	    TERM(sublex_start());
-
-	case KEY_qr:
-	    s = scan_pat(s,OP_QR);
-	    TERM(sublex_start());
-
-	case KEY_qx:
-	    s = scan_str(s,FALSE,FALSE,FALSE,NULL);
-	    if (!s)
-		missingterm(NULL, 0);
-	    pl_yylval.ival = OP_BACKTICK;
-	    TERM(sublex_start());
-
-	case KEY_return:
-	    OLDLOP(OP_RETURN);
-
-	case KEY_require:
-            return yyl_require(aTHX_ s, orig_keyword);
-
-	case KEY_reset:
-	    UNI(OP_RESET);
-
-	case KEY_redo:
-	    LOOPX(OP_REDO);
-
-	case KEY_rename:
-	    LOP(OP_RENAME,XTERM);
-
-	case KEY_rand:
-	    UNI(OP_RAND);
-
-	case KEY_rmdir:
-	    UNI(OP_RMDIR);
-
-	case KEY_rindex:
-	    LOP(OP_RINDEX,XTERM);
-
-	case KEY_read:
-	    LOP(OP_READ,XTERM);
-
-	case KEY_readdir:
-	    UNI(OP_READDIR);
-
-	case KEY_readline:
-	    UNIDOR(OP_READLINE);
-
-	case KEY_readpipe:
-	    UNIDOR(OP_BACKTICK);
-
-	case KEY_rewinddir:
-	    UNI(OP_REWINDDIR);
-
-	case KEY_recv:
-	    LOP(OP_RECV,XTERM);
-
-	case KEY_reverse:
-	    LOP(OP_REVERSE,XTERM);
-
-	case KEY_readlink:
-	    UNIDOR(OP_READLINK);
-
-	case KEY_ref:
-	    UNI(OP_REF);
-
-	case KEY_s:
-	    s = scan_subst(s);
-	    if (pl_yylval.opval)
-		TERM(sublex_start());
-	    else
-		TOKEN(1);	/* force error */
-
-	case KEY_say:
-	    checkcomma(s,PL_tokenbuf,"filehandle");
-	    LOP(OP_SAY,XREF);
-
-	case KEY_chomp:
-	    UNI(OP_CHOMP);
-
-	case KEY_scalar:
-	    UNI(OP_SCALAR);
-
-	case KEY_select:
-	    LOP(OP_SELECT,XTERM);
-
-	case KEY_seek:
-	    LOP(OP_SEEK,XTERM);
-
-	case KEY_semctl:
-	    LOP(OP_SEMCTL,XTERM);
-
-	case KEY_semget:
-	    LOP(OP_SEMGET,XTERM);
-
-	case KEY_semop:
-	    LOP(OP_SEMOP,XTERM);
-
-	case KEY_send:
-	    LOP(OP_SEND,XTERM);
-
-	case KEY_setpgrp:
-	    LOP(OP_SETPGRP,XTERM);
-
-	case KEY_setpriority:
-	    LOP(OP_SETPRIORITY,XTERM);
-
-	case KEY_sethostent:
-	    UNI(OP_SHOSTENT);
-
-	case KEY_setnetent:
-	    UNI(OP_SNETENT);
-
-	case KEY_setservent:
-	    UNI(OP_SSERVENT);
-
-	case KEY_setprotoent:
-	    UNI(OP_SPROTOENT);
-
-	case KEY_setpwent:
-	    FUN0(OP_SPWENT);
-
-	case KEY_setgrent:
-	    FUN0(OP_SGRENT);
-
-	case KEY_seekdir:
-	    LOP(OP_SEEKDIR,XTERM);
-
-	case KEY_setsockopt:
-	    LOP(OP_SSOCKOPT,XTERM);
-
-	case KEY_shift:
-	    UNIDOR(OP_SHIFT);
-
-	case KEY_shmctl:
-	    LOP(OP_SHMCTL,XTERM);
-
-	case KEY_shmget:
-	    LOP(OP_SHMGET,XTERM);
-
-	case KEY_shmread:
-	    LOP(OP_SHMREAD,XTERM);
-
-	case KEY_shmwrite:
-	    LOP(OP_SHMWRITE,XTERM);
-
-	case KEY_shutdown:
-	    LOP(OP_SHUTDOWN,XTERM);
-
-	case KEY_sin:
-	    UNI(OP_SIN);
-
-	case KEY_sleep:
-	    UNI(OP_SLEEP);
-
-	case KEY_socket:
-	    LOP(OP_SOCKET,XTERM);
-
-	case KEY_socketpair:
-	    LOP(OP_SOCKPAIR,XTERM);
-
-	case KEY_sort:
-	    checkcomma(s,PL_tokenbuf,"subroutine name");
-	    s = skipspace(s);
-	    PL_expect = XTERM;
-	    s = force_word(s,BAREWORD,TRUE,TRUE);
-	    LOP(OP_SORT,XREF);
-
-	case KEY_split:
-	    LOP(OP_SPLIT,XTERM);
-
-	case KEY_sprintf:
-	    LOP(OP_SPRINTF,XTERM);
-
-	case KEY_splice:
-	    LOP(OP_SPLICE,XTERM);
-
-	case KEY_sqrt:
-	    UNI(OP_SQRT);
-
-	case KEY_srand:
-	    UNI(OP_SRAND);
-
-	case KEY_stat:
-	    UNI(OP_STAT);
-
-	case KEY_study:
-	    UNI(OP_STUDY);
-
-	case KEY_substr:
-	    LOP(OP_SUBSTR,XTERM);
-
-	case KEY_format:
-	case KEY_sub:
-            return yyl_sub(aTHX_ s, tmp);
-
-	case KEY_system:
-	    LOP(OP_SYSTEM,XREF);
-
-	case KEY_symlink:
-	    LOP(OP_SYMLINK,XTERM);
-
-	case KEY_syscall:
-	    LOP(OP_SYSCALL,XTERM);
-
-	case KEY_sysopen:
-	    LOP(OP_SYSOPEN,XTERM);
-
-	case KEY_sysseek:
-	    LOP(OP_SYSSEEK,XTERM);
-
-	case KEY_sysread:
-	    LOP(OP_SYSREAD,XTERM);
-
-	case KEY_syswrite:
-	    LOP(OP_SYSWRITE,XTERM);
-
-	case KEY_tr:
-	case KEY_y:
-	    s = scan_trans(s);
-	    TERM(sublex_start());
-
-	case KEY_tell:
-	    UNI(OP_TELL);
-
-	case KEY_telldir:
-	    UNI(OP_TELLDIR);
-
-	case KEY_tie:
-	    LOP(OP_TIE,XTERM);
-
-	case KEY_tied:
-	    UNI(OP_TIED);
-
-	case KEY_time:
-	    FUN0(OP_TIME);
-
-	case KEY_times:
-	    FUN0(OP_TMS);
-
-	case KEY_truncate:
-	    LOP(OP_TRUNCATE,XTERM);
-
-	case KEY_uc:
-	    UNI(OP_UC);
-
-	case KEY_ucfirst:
-	    UNI(OP_UCFIRST);
-
-	case KEY_untie:
-	    UNI(OP_UNTIE);
-
-	case KEY_until:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
-		return REPORT(0);
-	    pl_yylval.ival = CopLINE(PL_curcop);
-	    OPERATOR(UNTIL);
-
-	case KEY_unless:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
-		return REPORT(0);
-	    pl_yylval.ival = CopLINE(PL_curcop);
-	    OPERATOR(UNLESS);
-
-	case KEY_unlink:
-	    LOP(OP_UNLINK,XTERM);
-
-	case KEY_undef:
-	    UNIDOR(OP_UNDEF);
-
-	case KEY_unpack:
-	    LOP(OP_UNPACK,XTERM);
-
-	case KEY_utime:
-	    LOP(OP_UTIME,XTERM);
-
-	case KEY_umask:
-	    UNIDOR(OP_UMASK);
-
-	case KEY_unshift:
-	    LOP(OP_UNSHIFT,XTERM);
-
-	case KEY_use:
-	    s = tokenize_use(1, s);
-	    TOKEN(USE);
-
-	case KEY_values:
-	    UNI(OP_VALUES);
-
-	case KEY_vec:
-	    LOP(OP_VEC,XTERM);
-
-	case KEY_when:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
-		return REPORT(0);
-	    pl_yylval.ival = CopLINE(PL_curcop);
-            Perl_ck_warner_d(aTHX_
-                packWARN(WARN_EXPERIMENTAL__SMARTMATCH),
-                "when is experimental");
-	    OPERATOR(WHEN);
-
-	case KEY_while:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_NONEXPR)
-		return REPORT(0);
-	    pl_yylval.ival = CopLINE(PL_curcop);
-	    OPERATOR(WHILE);
-
-	case KEY_warn:
-	    PL_hints |= HINT_BLOCK_SCOPE;
-	    LOP(OP_WARN,XTERM);
-
-	case KEY_wait:
-	    FUN0(OP_WAIT);
-
-	case KEY_waitpid:
-	    LOP(OP_WAITPID,XTERM);
-
-	case KEY_wantarray:
-	    FUN0(OP_WANTARRAY);
-
-	case KEY_write:
-            /* Make sure $^L is defined. 0x0C is CTRL-L on ASCII platforms, and
-             * we use the same number on EBCDIC */
-	    gv_fetchpvs("\x0C", GV_ADD|GV_NOTQUAL, SVt_PV);
-	    UNI(OP_ENTERWRITE);
-
-	case KEY_x:
-	    if (PL_expect == XOPERATOR) {
-		if (*s == '=' && !PL_lex_allbrackets
-                    && PL_lex_fakeeof >= LEX_FAKEEOF_ASSIGN)
-                {
-		    return REPORT(0);
-                }
-		Mop(OP_REPEAT);
-	    }
-	    check_uni();
-            return yyl_just_a_word(aTHX_ s, len, tmp, orig_keyword,
-                                   MAKE_CODE(FALSE), saw_infix_sigil);
-
-	case KEY_xor:
-	    if (!PL_lex_allbrackets && PL_lex_fakeeof >= LEX_FAKEEOF_LOWLOGIC)
-		return REPORT(0);
-	    pl_yylval.ival = OP_XOR;
-	    OPERATOR(OROP);
-	}
+        return yyl_word_or_keyword(aTHX_ s, len, tmp, orig_keyword,
+                                   MAKE_CODE(FALSE), bof, saw_infix_sigil);
     }}
 }