Move compiler OP class information into opcode.pl.

p4raw-id: //depot/perl@186

3 files changed, 708 insertions, 666 deletions

diff --git a/op.h b/op.h
index f9dad977ef..ad208cfabb 100644
--- a/op.h
+++ b/op.h
@@ -271,7 +271,24 @@ struct loop {
 #define OA_DANGEROUS 64
 #define OA_DEFGV 128
 
-#define OASHIFT 8
+/* The next 4 bits encode op class information */
+#define OA_BASEOP (0 << 8)
+#define OA_UNOP (1 << 8)
+#define OA_BINOP (2 << 8)
+#define OA_LOGOP (3 << 8)
+#define OA_CONDOP (4 << 8)
+#define OA_LISTOP (5 << 8)
+#define OA_PMOP (6 << 8)
+#define OA_SVOP (7 << 8)
+#define OA_GVOP (8 << 8)
+#define OA_PVOP (9 << 8)
+#define OA_LOOP (10 << 8)
+#define OA_COP (11 << 8)
+#define OA_BASEOP_OR_UNOP (12 << 8)
+#define OA_FILESTATOP (13 << 8)
+#define OA_LOOPEXOP (14 << 8)
+
+#define OASHIFT 12
 
 /* Remaining nybbles of opargs */
 #define OA_SCALAR 1
diff --git a/opcode.h b/opcode.h
index 1b465ddb30..3f2a5c290b 100644
--- a/opcode.h
+++ b/opcode.h
@@ -2147,348 +2147,348 @@ EXT U32 opargs[];
 EXT U32 opargs[] = {
 	0x00000000,	/* null */
 	0x00000000,	/* stub */
-	0x00000104,	/* scalar */
+	0x00001c04,	/* scalar */
 	0x00000004,	/* pushmark */
 	0x00000014,	/* wantarray */
-	0x00000004,	/* const */
-	0x00000044,	/* gvsv */
-	0x00000044,	/* gv */
-	0x00001140,	/* gelem */
+	0x00000704,	/* const */
+	0x00000844,	/* gvsv */
+	0x00000844,	/* gv */
+	0x00011240,	/* gelem */
 	0x00000044,	/* padsv */
 	0x00000040,	/* padav */
 	0x00000040,	/* padhv */
 	0x00000040,	/* padany */
-	0x00000000,	/* pushre */
-	0x00000044,	/* rv2gv */
-	0x00000044,	/* rv2sv */
-	0x00000014,	/* av2arylen */
-	0x00000040,	/* rv2cv */
-	0x00000000,	/* anoncode */
-	0x00000104,	/* prototype */
-	0x00000201,	/* refgen */
-	0x00000106,	/* srefgen */
-	0x0000098c,	/* ref */
-	0x00009104,	/* bless */
-	0x00000008,	/* backtick */
-	0x00009908,	/* glob */
-	0x00000008,	/* readline */
-	0x00000008,	/* rcatline */
-	0x00000104,	/* regcmaybe */
-	0x00000104,	/* regcomp */
-	0x00000040,	/* match */
-	0x00000154,	/* subst */
-	0x00000054,	/* substcont */
-	0x00000114,	/* trans */
+	0x00000600,	/* pushre */
+	0x00000144,	/* rv2gv */
+	0x00000144,	/* rv2sv */
+	0x00000114,	/* av2arylen */
+	0x00000140,	/* rv2cv */
+	0x00000700,	/* anoncode */
+	0x00001c04,	/* prototype */
+	0x00002001,	/* refgen */
+	0x00001006,	/* srefgen */
+	0x00009c8c,	/* ref */
+	0x00091504,	/* bless */
+	0x00000c08,	/* backtick */
+	0x00099508,	/* glob */
+	0x00000c08,	/* readline */
+	0x00000c08,	/* rcatline */
+	0x00001104,	/* regcmaybe */
+	0x00001304,	/* regcomp */
+	0x00000640,	/* match */
+	0x00001654,	/* subst */
+	0x00000354,	/* substcont */
+	0x00001914,	/* trans */
 	0x00000004,	/* sassign */
-	0x00002208,	/* aassign */
-	0x0000020d,	/* chop */
-	0x0000098c,	/* schop */
-	0x0000020d,	/* chomp */
-	0x0000098c,	/* schomp */
-	0x00000994,	/* defined */
-	0x00000904,	/* undef */
-	0x00000984,	/* study */
-	0x0000098c,	/* pos */
-	0x00000164,	/* preinc */
-	0x00000154,	/* i_preinc */
-	0x00000164,	/* predec */
-	0x00000154,	/* i_predec */
-	0x0000016c,	/* postinc */
-	0x0000015c,	/* i_postinc */
-	0x0000016c,	/* postdec */
-	0x0000015c,	/* i_postdec */
-	0x0000110e,	/* pow */
-	0x0000112e,	/* multiply */
-	0x0000111e,	/* i_multiply */
-	0x0000112e,	/* divide */
-	0x0000111e,	/* i_divide */
-	0x0000113e,	/* modulo */
-	0x0000111e,	/* i_modulo */
-	0x00001209,	/* repeat */
-	0x0000112e,	/* add */
-	0x0000111e,	/* i_add */
-	0x0000112e,	/* subtract */
-	0x0000111e,	/* i_subtract */
-	0x0000110e,	/* concat */
-	0x0000010e,	/* stringify */
-	0x0000110e,	/* left_shift */
-	0x0000110e,	/* right_shift */
-	0x00001136,	/* lt */
-	0x00001116,	/* i_lt */
-	0x00001136,	/* gt */
-	0x00001116,	/* i_gt */
-	0x00001136,	/* le */
-	0x00001116,	/* i_le */
-	0x00001136,	/* ge */
-	0x00001116,	/* i_ge */
-	0x00001136,	/* eq */
-	0x00001116,	/* i_eq */
-	0x00001136,	/* ne */
-	0x00001116,	/* i_ne */
-	0x0000113e,	/* ncmp */
-	0x0000111e,	/* i_ncmp */
-	0x00001116,	/* slt */
-	0x00001116,	/* sgt */
-	0x00001116,	/* sle */
-	0x00001116,	/* sge */
-	0x00001116,	/* seq */
-	0x00001116,	/* sne */
-	0x0000111e,	/* scmp */
-	0x0000110e,	/* bit_and */
-	0x0000110e,	/* bit_xor */
-	0x0000110e,	/* bit_or */
-	0x0000012e,	/* negate */
-	0x0000011e,	/* i_negate */
-	0x00000116,	/* not */
-	0x0000010e,	/* complement */
-	0x0000110e,	/* atan2 */
-	0x0000098e,	/* sin */
-	0x0000098e,	/* cos */
-	0x0000090c,	/* rand */
-	0x00000904,	/* srand */
-	0x0000098e,	/* exp */
-	0x0000098e,	/* log */
-	0x0000098e,	/* sqrt */
-	0x0000098e,	/* int */
-	0x0000098e,	/* hex */
-	0x0000098e,	/* oct */
-	0x0000098e,	/* abs */
-	0x0000099c,	/* length */
-	0x0009110c,	/* substr */
-	0x0001111c,	/* vec */
-	0x0009111c,	/* index */
-	0x0009111c,	/* rindex */
-	0x0000210f,	/* sprintf */
-	0x00002105,	/* formline */
-	0x0000099e,	/* ord */
-	0x0000098e,	/* chr */
-	0x0000110e,	/* crypt */
-	0x0000098e,	/* ucfirst */
-	0x0000098e,	/* lcfirst */
-	0x0000098e,	/* uc */
-	0x0000098e,	/* lc */
-	0x0000098e,	/* quotemeta */
-	0x00000048,	/* rv2av */
-	0x00001304,	/* aelemfast */
-	0x00001304,	/* aelem */
-	0x00002301,	/* aslice */
-	0x00000408,	/* each */
-	0x00000408,	/* values */
-	0x00000408,	/* keys */
-	0x00000100,	/* delete */
-	0x00000114,	/* exists */
-	0x00000048,	/* rv2hv */
-	0x00001404,	/* helem */
-	0x00002401,	/* hslice */
-	0x00001100,	/* unpack */
-	0x0000210d,	/* pack */
-	0x00011108,	/* split */
-	0x0000210d,	/* join */
-	0x00000201,	/* list */
-	0x00022400,	/* lslice */
-	0x00000205,	/* anonlist */
-	0x00000205,	/* anonhash */
-	0x00299301,	/* splice */
-	0x0000231d,	/* push */
-	0x00000304,	/* pop */
-	0x00000304,	/* shift */
-	0x0000231d,	/* unshift */
-	0x00002d01,	/* sort */
-	0x00000209,	/* reverse */
-	0x00002541,	/* grepstart */
-	0x00000048,	/* grepwhile */
-	0x00002541,	/* mapstart */
-	0x00000048,	/* mapwhile */
-	0x00001100,	/* range */
-	0x00001100,	/* flip */
-	0x00000000,	/* flop */
-	0x00000000,	/* and */
-	0x00000000,	/* or */
-	0x00001106,	/* xor */
-	0x00000040,	/* cond_expr */
-	0x00000004,	/* andassign */
-	0x00000004,	/* orassign */
-	0x00000040,	/* method */
-	0x00000249,	/* entersub */
-	0x00000000,	/* leavesub */
-	0x00000908,	/* caller */
-	0x0000021d,	/* warn */
-	0x0000025d,	/* die */
-	0x00000914,	/* reset */
-	0x00000000,	/* lineseq */
-	0x00000004,	/* nextstate */
-	0x00000004,	/* dbstate */
+	0x00022208,	/* aassign */
+	0x00002c0d,	/* chop */
+	0x00009c8c,	/* schop */
+	0x00002c0d,	/* chomp */
+	0x00009c8c,	/* schomp */
+	0x00009c94,	/* defined */
+	0x00009c04,	/* undef */
+	0x00009c84,	/* study */
+	0x00009c8c,	/* pos */
+	0x00001164,	/* preinc */
+	0x00001154,	/* i_preinc */
+	0x00001164,	/* predec */
+	0x00001154,	/* i_predec */
+	0x0000116c,	/* postinc */
+	0x0000115c,	/* i_postinc */
+	0x0000116c,	/* postdec */
+	0x0000115c,	/* i_postdec */
+	0x0001120e,	/* pow */
+	0x0001122e,	/* multiply */
+	0x0001121e,	/* i_multiply */
+	0x0001122e,	/* divide */
+	0x0001121e,	/* i_divide */
+	0x0001123e,	/* modulo */
+	0x0001121e,	/* i_modulo */
+	0x00012209,	/* repeat */
+	0x0001122e,	/* add */
+	0x0001121e,	/* i_add */
+	0x0001122e,	/* subtract */
+	0x0001121e,	/* i_subtract */
+	0x0001120e,	/* concat */
+	0x0000150e,	/* stringify */
+	0x0001120e,	/* left_shift */
+	0x0001120e,	/* right_shift */
+	0x00011236,	/* lt */
+	0x00011216,	/* i_lt */
+	0x00011236,	/* gt */
+	0x00011216,	/* i_gt */
+	0x00011236,	/* le */
+	0x00011216,	/* i_le */
+	0x00011236,	/* ge */
+	0x00011216,	/* i_ge */
+	0x00011236,	/* eq */
+	0x00011216,	/* i_eq */
+	0x00011236,	/* ne */
+	0x00011216,	/* i_ne */
+	0x0001123e,	/* ncmp */
+	0x0001121e,	/* i_ncmp */
+	0x00011216,	/* slt */
+	0x00011216,	/* sgt */
+	0x00011216,	/* sle */
+	0x00011216,	/* sge */
+	0x00011216,	/* seq */
+	0x00011216,	/* sne */
+	0x0001121e,	/* scmp */
+	0x0001120e,	/* bit_and */
+	0x0001120e,	/* bit_xor */
+	0x0001120e,	/* bit_or */
+	0x0000112e,	/* negate */
+	0x0000111e,	/* i_negate */
+	0x00001116,	/* not */
+	0x0000110e,	/* complement */
+	0x0001150e,	/* atan2 */
+	0x00009c8e,	/* sin */
+	0x00009c8e,	/* cos */
+	0x00009c0c,	/* rand */
+	0x00009c04,	/* srand */
+	0x00009c8e,	/* exp */
+	0x00009c8e,	/* log */
+	0x00009c8e,	/* sqrt */
+	0x00009c8e,	/* int */
+	0x00009c8e,	/* hex */
+	0x00009c8e,	/* oct */
+	0x00009c8e,	/* abs */
+	0x00009c9c,	/* length */
+	0x0091150c,	/* substr */
+	0x0011151c,	/* vec */
+	0x0091151c,	/* index */
+	0x0091151c,	/* rindex */
+	0x0002150f,	/* sprintf */
+	0x00021505,	/* formline */
+	0x00009c9e,	/* ord */
+	0x00009c8e,	/* chr */
+	0x0001150e,	/* crypt */
+	0x00009c8e,	/* ucfirst */
+	0x00009c8e,	/* lcfirst */
+	0x00009c8e,	/* uc */
+	0x00009c8e,	/* lc */
+	0x00009c8e,	/* quotemeta */
+	0x00000148,	/* rv2av */
+	0x00013804,	/* aelemfast */
+	0x00013204,	/* aelem */
+	0x00023501,	/* aslice */
+	0x00004c08,	/* each */
+	0x00004c08,	/* values */
+	0x00004c08,	/* keys */
+	0x00001c00,	/* delete */
+	0x00001c14,	/* exists */
+	0x00000148,	/* rv2hv */
+	0x00014204,	/* helem */
+	0x00024501,	/* hslice */
+	0x00011500,	/* unpack */
+	0x0002150d,	/* pack */
+	0x00111508,	/* split */
+	0x0002150d,	/* join */
+	0x00002501,	/* list */
+	0x00224200,	/* lslice */
+	0x00002505,	/* anonlist */
+	0x00002505,	/* anonhash */
+	0x02993501,	/* splice */
+	0x0002351d,	/* push */
+	0x00003c14,	/* pop */
+	0x00003c04,	/* shift */
+	0x0002351d,	/* unshift */
+	0x0002d501,	/* sort */
+	0x00002509,	/* reverse */
+	0x00025541,	/* grepstart */
+	0x00000348,	/* grepwhile */
+	0x00025541,	/* mapstart */
+	0x00000348,	/* mapwhile */
+	0x00011400,	/* range */
+	0x00011100,	/* flip */
+	0x00000100,	/* flop */
+	0x00000300,	/* and */
+	0x00000300,	/* or */
+	0x00011306,	/* xor */
+	0x00000440,	/* cond_expr */
+	0x00000304,	/* andassign */
+	0x00000304,	/* orassign */
+	0x00000140,	/* method */
+	0x00002149,	/* entersub */
+	0x00000100,	/* leavesub */
+	0x00009c08,	/* caller */
+	0x0000251d,	/* warn */
+	0x0000255d,	/* die */
+	0x00009c14,	/* reset */
+	0x00000500,	/* lineseq */
+	0x00000b04,	/* nextstate */
+	0x00000b04,	/* dbstate */
 	0x00000004,	/* unstack */
 	0x00000000,	/* enter */
-	0x00000000,	/* leave */
-	0x00000000,	/* scope */
-	0x00000040,	/* enteriter */
+	0x00000500,	/* leave */
+	0x00000500,	/* scope */
+	0x00000a40,	/* enteriter */
 	0x00000000,	/* iter */
-	0x00000040,	/* enterloop */
-	0x00000000,	/* leaveloop */
-	0x00000241,	/* return */
-	0x00000044,	/* last */
-	0x00000044,	/* next */
-	0x00000044,	/* redo */
-	0x00000044,	/* dump */
-	0x00000044,	/* goto */
-	0x00000944,	/* exit */
-	0x0000961c,	/* open */
-	0x00000e14,	/* close */
-	0x00006614,	/* pipe_op */
-	0x0000061c,	/* fileno */
-	0x0000091c,	/* umask */
-	0x00000604,	/* binmode */
-	0x00021755,	/* tie */
-	0x00000714,	/* untie */
-	0x00000704,	/* tied */
-	0x00011414,	/* dbmopen */
-	0x00000414,	/* dbmclose */
-	0x00111108,	/* sselect */
-	0x00000e0c,	/* select */
-	0x00000e0c,	/* getc */
-	0x0091761d,	/* read */
-	0x00000e54,	/* enterwrite */
-	0x00000000,	/* leavewrite */
-	0x00002e15,	/* prtf */
-	0x00002e15,	/* print */
-	0x00911604,	/* sysopen */
-	0x00011604,	/* sysseek */
-	0x0091761d,	/* sysread */
-	0x0091161d,	/* syswrite */
-	0x0091161d,	/* send */
-	0x0011761d,	/* recv */
-	0x00000e14,	/* eof */
-	0x00000e0c,	/* tell */
-	0x00011604,	/* seek */
-	0x00001114,	/* truncate */
-	0x0001160c,	/* fcntl */
-	0x0001160c,	/* ioctl */
-	0x0000161c,	/* flock */
-	0x00111614,	/* socket */
-	0x01116614,	/* sockpair */
-	0x00001614,	/* bind */
-	0x00001614,	/* connect */
-	0x00001614,	/* listen */
-	0x0000661c,	/* accept */
-	0x0000161c,	/* shutdown */
-	0x00011614,	/* gsockopt */
-	0x00111614,	/* ssockopt */
-	0x00000614,	/* getsockname */
-	0x00000614,	/* getpeername */
-	0x00000680,	/* lstat */
-	0x00000680,	/* stat */
-	0x00000694,	/* ftrread */
-	0x00000694,	/* ftrwrite */
-	0x00000694,	/* ftrexec */
-	0x00000694,	/* fteread */
-	0x00000694,	/* ftewrite */
-	0x00000694,	/* fteexec */
-	0x00000694,	/* ftis */
-	0x00000694,	/* fteowned */
-	0x00000694,	/* ftrowned */
-	0x00000694,	/* ftzero */
-	0x0000069c,	/* ftsize */
-	0x0000068c,	/* ftmtime */
-	0x0000068c,	/* ftatime */
-	0x0000068c,	/* ftctime */
-	0x00000694,	/* ftsock */
-	0x00000694,	/* ftchr */
-	0x00000694,	/* ftblk */
-	0x00000694,	/* ftfile */
-	0x00000694,	/* ftdir */
-	0x00000694,	/* ftpipe */
-	0x00000694,	/* ftlink */
-	0x00000694,	/* ftsuid */
-	0x00000694,	/* ftsgid */
-	0x00000694,	/* ftsvtx */
-	0x00000614,	/* fttty */
-	0x00000694,	/* fttext */
-	0x00000694,	/* ftbinary */
-	0x0000091c,	/* chdir */
-	0x0000021d,	/* chown */
-	0x0000099c,	/* chroot */
-	0x0000029d,	/* unlink */
-	0x0000021d,	/* chmod */
-	0x0000021d,	/* utime */
-	0x0000111c,	/* rename */
-	0x0000111c,	/* link */
-	0x0000111c,	/* symlink */
-	0x0000098c,	/* readlink */
-	0x0000111c,	/* mkdir */
-	0x0000099c,	/* rmdir */
-	0x00001614,	/* open_dir */
-	0x00000600,	/* readdir */
-	0x0000060c,	/* telldir */
-	0x00001604,	/* seekdir */
-	0x00000604,	/* rewinddir */
-	0x00000614,	/* closedir */
+	0x00000a40,	/* enterloop */
+	0x00000200,	/* leaveloop */
+	0x00002541,	/* return */
+	0x00000e44,	/* last */
+	0x00000e44,	/* next */
+	0x00000e44,	/* redo */
+	0x00000e44,	/* dump */
+	0x00000e44,	/* goto */
+	0x00009c44,	/* exit */
+	0x0009651c,	/* open */
+	0x0000ec14,	/* close */
+	0x00066514,	/* pipe_op */
+	0x00006c1c,	/* fileno */
+	0x00009c1c,	/* umask */
+	0x00006c04,	/* binmode */
+	0x00217555,	/* tie */
+	0x00007c14,	/* untie */
+	0x00007c04,	/* tied */
+	0x00114514,	/* dbmopen */
+	0x00004c14,	/* dbmclose */
+	0x01111508,	/* sselect */
+	0x0000e50c,	/* select */
+	0x0000ec0c,	/* getc */
+	0x0917651d,	/* read */
+	0x0000ec54,	/* enterwrite */
+	0x00000100,	/* leavewrite */
+	0x0002e515,	/* prtf */
+	0x0002e515,	/* print */
+	0x09116504,	/* sysopen */
+	0x00116504,	/* sysseek */
+	0x0917651d,	/* sysread */
+	0x0911651d,	/* syswrite */
+	0x0911651d,	/* send */
+	0x0117651d,	/* recv */
+	0x0000ec14,	/* eof */
+	0x0000ec0c,	/* tell */
+	0x00116504,	/* seek */
+	0x00011514,	/* truncate */
+	0x0011650c,	/* fcntl */
+	0x0011650c,	/* ioctl */
+	0x0001651c,	/* flock */
+	0x01116514,	/* socket */
+	0x11166514,	/* sockpair */
+	0x00016514,	/* bind */
+	0x00016514,	/* connect */
+	0x00016514,	/* listen */
+	0x0006651c,	/* accept */
+	0x0001651c,	/* shutdown */
+	0x00116514,	/* gsockopt */
+	0x01116514,	/* ssockopt */
+	0x00006c14,	/* getsockname */
+	0x00006c14,	/* getpeername */
+	0x00006d80,	/* lstat */
+	0x00006d80,	/* stat */
+	0x00006d94,	/* ftrread */
+	0x00006d94,	/* ftrwrite */
+	0x00006d94,	/* ftrexec */
+	0x00006d94,	/* fteread */
+	0x00006d94,	/* ftewrite */
+	0x00006d94,	/* fteexec */
+	0x00006d94,	/* ftis */
+	0x00006d94,	/* fteowned */
+	0x00006d94,	/* ftrowned */
+	0x00006d94,	/* ftzero */
+	0x00006d9c,	/* ftsize */
+	0x00006d8c,	/* ftmtime */
+	0x00006d8c,	/* ftatime */
+	0x00006d8c,	/* ftctime */
+	0x00006d94,	/* ftsock */
+	0x00006d94,	/* ftchr */
+	0x00006d94,	/* ftblk */
+	0x00006d94,	/* ftfile */
+	0x00006d94,	/* ftdir */
+	0x00006d94,	/* ftpipe */
+	0x00006d94,	/* ftlink */
+	0x00006d94,	/* ftsuid */
+	0x00006d94,	/* ftsgid */
+	0x00006d94,	/* ftsvtx */
+	0x00006d14,	/* fttty */
+	0x00006d94,	/* fttext */
+	0x00006d94,	/* ftbinary */
+	0x00009c1c,	/* chdir */
+	0x0000251d,	/* chown */
+	0x00009c9c,	/* chroot */
+	0x0000259d,	/* unlink */
+	0x0000251d,	/* chmod */
+	0x0000251d,	/* utime */
+	0x0001151c,	/* rename */
+	0x0001151c,	/* link */
+	0x0001151c,	/* symlink */
+	0x00009c8c,	/* readlink */
+	0x0001151c,	/* mkdir */
+	0x00009c9c,	/* rmdir */
+	0x00016514,	/* open_dir */
+	0x00006c00,	/* readdir */
+	0x00006c0c,	/* telldir */
+	0x00016504,	/* seekdir */
+	0x00006c04,	/* rewinddir */
+	0x00006c14,	/* closedir */
 	0x0000001c,	/* fork */
 	0x0000001c,	/* wait */
-	0x0000111c,	/* waitpid */
-	0x0000291d,	/* system */
-	0x0000295d,	/* exec */
-	0x0000025d,	/* kill */
+	0x0001151c,	/* waitpid */
+	0x0002951d,	/* system */
+	0x0002955d,	/* exec */
+	0x0000255d,	/* kill */
 	0x0000001c,	/* getppid */
-	0x0000091c,	/* getpgrp */
-	0x0000991c,	/* setpgrp */
-	0x0000111c,	/* getpriority */
-	0x0001111c,	/* setpriority */
+	0x00009c1c,	/* getpgrp */
+	0x0009951c,	/* setpgrp */
+	0x0001151c,	/* getpriority */
+	0x0011151c,	/* setpriority */
 	0x0000001c,	/* time */
 	0x00000000,	/* tms */
-	0x00000908,	/* localtime */
-	0x00000908,	/* gmtime */
-	0x0000099c,	/* alarm */
-	0x0000091c,	/* sleep */
-	0x0001111d,	/* shmget */
-	0x0001111d,	/* shmctl */
-	0x0011111d,	/* shmread */
-	0x0011111d,	/* shmwrite */
-	0x0000111d,	/* msgget */
-	0x0001111d,	/* msgctl */
-	0x0001111d,	/* msgsnd */
-	0x0111111d,	/* msgrcv */
-	0x0001111d,	/* semget */
-	0x0011111d,	/* semctl */
-	0x0000111d,	/* semop */
-	0x000009c0,	/* require */
-	0x00000140,	/* dofile */
-	0x00000140,	/* entereval */
-	0x00000100,	/* leaveeval */
-	0x00000000,	/* entertry */
-	0x00000000,	/* leavetry */
-	0x00000100,	/* ghbyname */
-	0x00001100,	/* ghbyaddr */
+	0x00009c08,	/* localtime */
+	0x00009c08,	/* gmtime */
+	0x00009c9c,	/* alarm */
+	0x00009c1c,	/* sleep */
+	0x0011151d,	/* shmget */
+	0x0011151d,	/* shmctl */
+	0x0111151d,	/* shmread */
+	0x0111151d,	/* shmwrite */
+	0x0001151d,	/* msgget */
+	0x0011151d,	/* msgctl */
+	0x0011151d,	/* msgsnd */
+	0x1111151d,	/* msgrcv */
+	0x0011151d,	/* semget */
+	0x0111151d,	/* semctl */
+	0x0001151d,	/* semop */
+	0x00009cc0,	/* require */
+	0x00001140,	/* dofile */
+	0x00001c40,	/* entereval */
+	0x00001100,	/* leaveeval */
+	0x00000300,	/* entertry */
+	0x00000500,	/* leavetry */
+	0x00001c00,	/* ghbyname */
+	0x00011500,	/* ghbyaddr */
 	0x00000000,	/* ghostent */
-	0x00000100,	/* gnbyname */
-	0x00001100,	/* gnbyaddr */
+	0x00001c00,	/* gnbyname */
+	0x00011500,	/* gnbyaddr */
 	0x00000000,	/* gnetent */
-	0x00000100,	/* gpbyname */
-	0x00000100,	/* gpbynumber */
+	0x00001c00,	/* gpbyname */
+	0x00001500,	/* gpbynumber */
 	0x00000000,	/* gprotoent */
-	0x00001100,	/* gsbyname */
-	0x00001100,	/* gsbyport */
+	0x00011500,	/* gsbyname */
+	0x00011500,	/* gsbyport */
 	0x00000000,	/* gservent */
-	0x00000114,	/* shostent */
-	0x00000114,	/* snetent */
-	0x00000114,	/* sprotoent */
-	0x00000114,	/* sservent */
+	0x00001c14,	/* shostent */
+	0x00001c14,	/* snetent */
+	0x00001c14,	/* sprotoent */
+	0x00001c14,	/* sservent */
 	0x00000014,	/* ehostent */
 	0x00000014,	/* enetent */
 	0x00000014,	/* eprotoent */
 	0x00000014,	/* eservent */
-	0x00000100,	/* gpwnam */
-	0x00000100,	/* gpwuid */
+	0x00001c00,	/* gpwnam */
+	0x00001c00,	/* gpwuid */
 	0x00000000,	/* gpwent */
 	0x00000014,	/* spwent */
 	0x00000014,	/* epwent */
-	0x00000100,	/* ggrnam */
-	0x00000100,	/* ggrgid */
+	0x00001c00,	/* ggrnam */
+	0x00001c00,	/* ggrgid */
 	0x00000000,	/* ggrent */
 	0x00000014,	/* sgrent */
 	0x00000014,	/* egrent */
 	0x0000000c,	/* getlogin */
-	0x0000211d,	/* syscall */
-	0x00000104,	/* lock */
+	0x0002151d,	/* syscall */
+	0x00001c04,	/* lock */
 };
 #endif
diff --git a/opcode.pl b/opcode.pl
index f8a7bb7787..1ef36f2fad 100755
--- a/opcode.pl
+++ b/opcode.pl
@@ -88,7 +88,7 @@ for (sort keys %ckname) {
 print "\n";
 
 for (@ops) {
-    print "OP *\t", &tab(3, "pp_\L$_"), "_((ARGSproto));\n";
+    print "OP *\t", &tab(3, "pp_$_"), "_((ARGSproto));\n";
 }
 
 # Emit ppcode switch array.
@@ -102,7 +102,7 @@ EXT OP * (*ppaddr[])() = {
 END
 
 for (@ops) {
-    print "\tpp_\L$_,\n";
+    print "\tpp_$_,\n";
 }
 
 print <<END;
@@ -121,7 +121,7 @@ EXT OP * (*check[]) _((OP *op)) = {
 END
 
 for (@ops) {
-    print "\t", &tab(3, "$check{$_},"), "/* \L$_ */\n";
+    print "\t", &tab(3, "$check{$_},"), "/* $_ */\n";
 }
 
 print <<END;
@@ -149,6 +149,24 @@ END
     R,	7,		# scalar reference
 );
 
+%opclass = (
+    '0',  0,		# baseop
+    '1',  1,		# unop
+    '2',  2,		# binop
+    '|',  3,		# logop
+    '?',  4,		# condop
+    '@',  5,		# listop
+    '/',  6,		# pmop
+    '$',  7,		# svop
+    '*',  8,		# gvop
+    '"',  9,		# pvop
+    '{',  10,		# loop
+    ';',  11,		# cop
+    '%',  12,		# baseop_or_unop
+    '-',  13,		# filestatop
+    '}',  14,		# loopexop
+);
+
 for (@ops) {
     $argsum = 0;
     $flags = $flags{$_};
@@ -160,15 +178,21 @@ for (@ops) {
     $argsum |= 32 if $flags =~ /I/;		# has corresponding int op
     $argsum |= 64 if $flags =~ /d/;		# danger, unknown side effects
     $argsum |= 128 if $flags =~ /u/;		# defaults to $_
-    $mul = 256;
+
+    $flags =~ /([^a-zA-Z])/ or die qq[Opcode "$_" has no class indicator];
+    printf STDERR "op $_, class $1 => 0x%x, argsum 0x%x",
+	$opclass{$1}, $argsum; # debug
+    $argsum |= $opclass{$1} << 8;
+    $mul = 4096;				# 2 ^ OASHIFT
     for $arg (split(' ',$args{$_})) {
 	$argnum = ($arg =~ s/\?//) ? 8 : 0;
 	$argnum += $argnum{$arg};
 	$argsum += $argnum * $mul;
 	$mul <<= 4;
     }
+    printf STDERR ", argsum now 0x%x\n", $argsum; # debug
     $argsum = sprintf("0x%08x", $argsum);
-    print "\t", &tab(3, "$argsum,"), "/* \L$_ */\n";
+    print "\t", &tab(3, "$argsum,"), "/* $_ */\n";
 }
 
 print <<END;
@@ -189,469 +213,470 @@ __END__
 
 null		null operation		ck_null		0	
 stub		stub			ck_null		0
-scalar		scalar			ck_fun		s	S
+scalar		scalar			ck_fun		s%	S
 
 # Pushy stuff.
 
-pushmark	pushmark		ck_null		s	
-wantarray	wantarray		ck_null		is	
+pushmark	pushmark		ck_null		s0	
+wantarray	wantarray		ck_null		is0	
 
-const		constant item		ck_svconst	s	
+const		constant item		ck_svconst	s$	
 
-gvsv		scalar variable		ck_null		ds	
-gv		glob value		ck_null		ds	
-gelem		glob elem		ck_null		d	S S
-padsv		private variable	ck_null		ds
-padav		private array		ck_null		d
-padhv		private hash		ck_null		d
-padany		private something	ck_null		d
+gvsv		scalar variable		ck_null		ds*	
+gv		glob value		ck_null		ds*	
+gelem		glob elem		ck_null		d2	S S
+padsv		private variable	ck_null		ds0
+padav		private array		ck_null		d0
+padhv		private hash		ck_null		d0
+padany		private something	ck_null		d0
 
-pushre		push regexp		ck_null		0
+pushre		push regexp		ck_null		/
 
 # References and stuff.
 
-rv2gv		ref-to-glob cast	ck_rvconst	ds	
-rv2sv		scalar deref		ck_rvconst	ds	
-av2arylen	array length		ck_null		is	
-rv2cv		subroutine deref	ck_rvconst	d
-anoncode	anonymous subroutine	ck_anoncode	0	
-prototype	subroutine prototype	ck_null		s	S
-refgen		reference constructor	ck_spair	m	L
-srefgen		scalar ref constructor	ck_null		fs	S
-ref		reference-type operator	ck_fun		stu	S?
-bless		bless			ck_fun		s	S S?
+rv2gv		ref-to-glob cast	ck_rvconst	ds1	
+rv2sv		scalar deref		ck_rvconst	ds1	
+av2arylen	array length		ck_null		is1	
+rv2cv		subroutine deref	ck_rvconst	d1
+anoncode	anonymous subroutine	ck_anoncode	$	
+prototype	subroutine prototype	ck_null		s%	S
+refgen		reference constructor	ck_spair	m0	L
+srefgen		scalar ref constructor	ck_null		fs0	S
+ref		reference-type operator	ck_fun		stu%	S?
+bless		bless			ck_fun		s@	S S?
 
 # Pushy I/O.
 
-backtick	backticks		ck_null		t	
+backtick	backticks		ck_null		t%	
 # glob defaults its first arg to $_
-glob		glob			ck_glob		t	S? S?
-readline	<HANDLE>		ck_null		t	
-rcatline	append I/O operator	ck_null		t	
+glob		glob			ck_glob		t@	S? S?
+readline	<HANDLE>		ck_null		t%	
+rcatline	append I/O operator	ck_null		t%	
 
 # Bindable operators.
 
-regcmaybe	regexp comp once	ck_fun		s	S
-regcomp		regexp compilation	ck_null		s	S
-match		pattern match		ck_match	d
-subst		substitution		ck_null		dis	S
-substcont	substitution cont	ck_null		dis	
-trans		character translation	ck_null		is	S
+regcmaybe	regexp comp once	ck_fun		s1	S
+regcomp		regexp compilation	ck_null		s|	S
+match		pattern match		ck_match	d/
+subst		substitution		ck_null		dis/	S
+substcont	substitution cont	ck_null		dis|	
+trans		character translation	ck_null		is"	S
 
 # Lvalue operators.
-
-sassign		scalar assignment	ck_null		s
-aassign		list assignment		ck_null		t	L L
-
-chop		chop			ck_spair	mts	L
-schop		scalar chop		ck_null		stu	S?
-chomp		safe chop		ck_spair	mts	L
-schomp		scalar safe chop	ck_null		stu	S?
-defined		defined operator	ck_rfun		isu	S?
-undef		undef operator		ck_lfun		s	S?
-study		study			ck_fun		su	S?
-pos		match position		ck_lfun		stu	S?
-
-preinc		preincrement		ck_lfun		dIs	S
-i_preinc	integer preincrement	ck_lfun		dis	S
-predec		predecrement		ck_lfun		dIs	S
-i_predec	integer predecrement	ck_lfun		dis	S
-postinc		postincrement		ck_lfun		dIst	S
-i_postinc	integer postincrement	ck_lfun		dist	S
-postdec		postdecrement		ck_lfun		dIst	S
-i_postdec	integer postdecrement	ck_lfun		dist	S
+# sassign is special-cased for op class
+
+sassign		scalar assignment	ck_null		s0
+aassign		list assignment		ck_null		t2	L L
+
+chop		chop			ck_spair	mts%	L
+schop		scalar chop		ck_null		stu%	S?
+chomp		safe chop		ck_spair	mts%	L
+schomp		scalar safe chop	ck_null		stu%	S?
+defined		defined operator	ck_rfun		isu%	S?
+undef		undef operator		ck_lfun		s%	S?
+study		study			ck_fun		su%	S?
+pos		match position		ck_lfun		stu%	S?
+
+preinc		preincrement		ck_lfun		dIs1	S
+i_preinc	integer preincrement	ck_lfun		dis1	S
+predec		predecrement		ck_lfun		dIs1	S
+i_predec	integer predecrement	ck_lfun		dis1	S
+postinc		postincrement		ck_lfun		dIst1	S
+i_postinc	integer postincrement	ck_lfun		dist1	S
+postdec		postdecrement		ck_lfun		dIst1	S
+i_postdec	integer postdecrement	ck_lfun		dist1	S
 
 # Ordinary operators.
 
-pow		exponentiation		ck_null		fst	S S
-
-multiply	multiplication		ck_null		Ifst	S S
-i_multiply	integer multiplication	ck_null		ifst	S S
-divide		division		ck_null		Ifst	S S
-i_divide	integer division	ck_null		ifst	S S
-modulo		modulus			ck_null		Iifst	S S
-i_modulo	integer modulus		ck_null		ifst	S S
-repeat		repeat			ck_repeat	mt	L S
-
-add		addition		ck_null		Ifst	S S
-i_add		integer addition	ck_null		ifst	S S
-subtract	subtraction		ck_null		Ifst	S S
-i_subtract	integer subtraction	ck_null		ifst	S S
-concat		concatenation		ck_concat	fst	S S
-stringify	string			ck_fun		fst	S
-
-left_shift	left bitshift		ck_bitop	fst	S S
-right_shift	right bitshift		ck_bitop	fst	S S
-
-lt		numeric lt		ck_null		Iifs	S S
-i_lt		integer lt		ck_null		ifs	S S
-gt		numeric gt		ck_null		Iifs	S S
-i_gt		integer gt		ck_null		ifs	S S
-le		numeric le		ck_null		Iifs	S S
-i_le		integer le		ck_null		ifs	S S
-ge		numeric ge		ck_null		Iifs	S S
-i_ge		integer ge		ck_null		ifs	S S
-eq		numeric eq		ck_null		Iifs	S S
-i_eq		integer eq		ck_null		ifs	S S
-ne		numeric ne		ck_null		Iifs	S S
-i_ne		integer ne		ck_null		ifs	S S
-ncmp		spaceship operator	ck_null		Iifst	S S
-i_ncmp		integer spaceship	ck_null		ifst	S S
-
-slt		string lt		ck_scmp		ifs	S S
-sgt		string gt		ck_scmp		ifs	S S
-sle		string le		ck_scmp		ifs	S S
-sge		string ge		ck_scmp		ifs	S S
-seq		string eq		ck_null		ifs	S S
-sne		string ne		ck_null		ifs	S S
-scmp		string comparison	ck_scmp		ifst	S S
-
-bit_and		bitwise and		ck_bitop	fst	S S
-bit_xor		bitwise xor		ck_bitop	fst	S S
-bit_or		bitwise or		ck_bitop	fst	S S
-
-negate		negate			ck_null		Ifst	S
-i_negate	integer negate		ck_null		ifst	S
-not		not			ck_null		ifs	S
-complement	1's complement		ck_bitop	fst	S
+pow		exponentiation		ck_null		fst2	S S
+
+multiply	multiplication		ck_null		Ifst2	S S
+i_multiply	integer multiplication	ck_null		ifst2	S S
+divide		division		ck_null		Ifst2	S S
+i_divide	integer division	ck_null		ifst2	S S
+modulo		modulus			ck_null		Iifst2	S S
+i_modulo	integer modulus		ck_null		ifst2	S S
+repeat		repeat			ck_repeat	mt2	L S
+
+add		addition		ck_null		Ifst2	S S
+i_add		integer addition	ck_null		ifst2	S S
+subtract	subtraction		ck_null		Ifst2	S S
+i_subtract	integer subtraction	ck_null		ifst2	S S
+concat		concatenation		ck_concat	fst2	S S
+stringify	string			ck_fun		fst@	S
+
+left_shift	left bitshift		ck_bitop	fst2	S S
+right_shift	right bitshift		ck_bitop	fst2	S S
+
+lt		numeric lt		ck_null		Iifs2	S S
+i_lt		integer lt		ck_null		ifs2	S S
+gt		numeric gt		ck_null		Iifs2	S S
+i_gt		integer gt		ck_null		ifs2	S S
+le		numeric le		ck_null		Iifs2	S S
+i_le		integer le		ck_null		ifs2	S S
+ge		numeric ge		ck_null		Iifs2	S S
+i_ge		integer ge		ck_null		ifs2	S S
+eq		numeric eq		ck_null		Iifs2	S S
+i_eq		integer eq		ck_null		ifs2	S S
+ne		numeric ne		ck_null		Iifs2	S S
+i_ne		integer ne		ck_null		ifs2	S S
+ncmp		spaceship operator	ck_null		Iifst2	S S
+i_ncmp		integer spaceship	ck_null		ifst2	S S
+
+slt		string lt		ck_scmp		ifs2	S S
+sgt		string gt		ck_scmp		ifs2	S S
+sle		string le		ck_scmp		ifs2	S S
+sge		string ge		ck_scmp		ifs2	S S
+seq		string eq		ck_null		ifs2	S S
+sne		string ne		ck_null		ifs2	S S
+scmp		string comparison	ck_scmp		ifst2	S S
+
+bit_and		bitwise and		ck_bitop	fst2	S S
+bit_xor		bitwise xor		ck_bitop	fst2	S S
+bit_or		bitwise or		ck_bitop	fst2	S S
+
+negate		negate			ck_null		Ifst1	S
+i_negate	integer negate		ck_null		ifst1	S
+not		not			ck_null		ifs1	S
+complement	1's complement		ck_bitop	fst1	S
 
 # High falutin' math.
 
-atan2		atan2			ck_fun		fst	S S
-sin		sin			ck_fun		fstu	S?
-cos		cos			ck_fun		fstu	S?
-rand		rand			ck_fun		st	S?
-srand		srand			ck_fun		s	S?
-exp		exp			ck_fun		fstu	S?
-log		log			ck_fun		fstu	S?
-sqrt		sqrt			ck_fun		fstu	S?
+atan2		atan2			ck_fun		fst@	S S
+sin		sin			ck_fun		fstu%	S?
+cos		cos			ck_fun		fstu%	S?
+rand		rand			ck_fun		st%	S?
+srand		srand			ck_fun		s%	S?
+exp		exp			ck_fun		fstu%	S?
+log		log			ck_fun		fstu%	S?
+sqrt		sqrt			ck_fun		fstu%	S?
 
 # Lowbrow math.
 
-int		int			ck_fun		fstu	S?
-hex		hex			ck_fun		fstu	S?
-oct		oct			ck_fun		fstu	S?
-abs		abs			ck_fun		fstu	S?
+int		int			ck_fun		fstu%	S?
+hex		hex			ck_fun		fstu%	S?
+oct		oct			ck_fun		fstu%	S?
+abs		abs			ck_fun		fstu%	S?
 
 # String stuff.
 
-length		length			ck_lengthconst	istu	S?
-substr		substr			ck_fun		st	S S S?
-vec		vec			ck_fun		ist	S S S
+length		length			ck_lengthconst	istu%	S?
+substr		substr			ck_fun		st@	S S S?
+vec		vec			ck_fun		ist@	S S S
 
-index		index			ck_index	ist	S S S?
-rindex		rindex			ck_index	ist	S S S?
+index		index			ck_index	ist@	S S S?
+rindex		rindex			ck_index	ist@	S S S?
 
-sprintf		sprintf			ck_fun_locale	mfst	S L
-formline	formline		ck_fun		ms	S L
-ord		ord			ck_fun		ifstu	S?
-chr		chr			ck_fun		fstu	S?
-crypt		crypt			ck_fun		fst	S S
-ucfirst		upper case first	ck_fun_locale	fstu	S?
-lcfirst		lower case first	ck_fun_locale	fstu	S?
-uc		upper case		ck_fun_locale	fstu	S?
-lc		lower case		ck_fun_locale	fstu	S?
-quotemeta	quote metachars		ck_fun		fstu	S?
+sprintf		sprintf			ck_fun_locale	mfst@	S L
+formline	formline		ck_fun		ms@	S L
+ord		ord			ck_fun		ifstu%	S?
+chr		chr			ck_fun		fstu%	S?
+crypt		crypt			ck_fun		fst@	S S
+ucfirst		upper case first	ck_fun_locale	fstu%	S?
+lcfirst		lower case first	ck_fun_locale	fstu%	S?
+uc		upper case		ck_fun_locale	fstu%	S?
+lc		lower case		ck_fun_locale	fstu%	S?
+quotemeta	quote metachars		ck_fun		fstu%	S?
 
 # Arrays.
 
-rv2av		array deref		ck_rvconst	dt	
-aelemfast	known array element	ck_null		s	A S
-aelem		array element		ck_null		s	A S
-aslice		array slice		ck_null		m	A L
+rv2av		array deref		ck_rvconst	dt1	
+aelemfast	known array element	ck_null		s*	A S
+aelem		array element		ck_null		s2	A S
+aslice		array slice		ck_null		m@	A L
 
 # Hashes.
 
-each		each			ck_fun		t	H
-values		values			ck_fun		t	H
-keys		keys			ck_fun		t	H
-delete		delete			ck_delete	0	S
-exists		exists operator		ck_exists	is	S
-rv2hv		hash deref		ck_rvconst	dt	
-helem		hash elem		ck_null		s	H S
-hslice		hash slice		ck_null		m	H L
+each		each			ck_fun		t%	H
+values		values			ck_fun		t%	H
+keys		keys			ck_fun		t%	H
+delete		delete			ck_delete	%	S
+exists		exists operator		ck_exists	is%	S
+rv2hv		hash deref		ck_rvconst	dt1	
+helem		hash elem		ck_null		s2@	H S
+hslice		hash slice		ck_null		m@	H L
 
 # Explosives and implosives.
 
-unpack		unpack			ck_fun		0	S S
-pack		pack			ck_fun		mst	S L
-split		split			ck_split	t	S S S
-join		join			ck_fun		mst	S L
+unpack		unpack			ck_fun		@	S S
+pack		pack			ck_fun		mst@	S L
+split		split			ck_split	t@	S S S
+join		join			ck_fun		mst@	S L
 
 # List operators.
 
-list		list			ck_null		m	L
-lslice		list slice		ck_null		0	H L L
-anonlist	anonymous list		ck_fun		ms	L
-anonhash	anonymous hash		ck_fun		ms	L
+list		list			ck_null		m@	L
+lslice		list slice		ck_null		2	H L L
+anonlist	anonymous list		ck_fun		ms@	L
+anonhash	anonymous hash		ck_fun		ms@	L
 
-splice		splice			ck_fun		m	A S? S? L
-push		push			ck_fun		imst	A L
-pop		pop			ck_shift	s	A
-shift		shift			ck_shift	s	A
-unshift		unshift			ck_fun		imst	A L
-sort		sort			ck_sort		m	C? L
-reverse		reverse			ck_fun		mt	L
+splice		splice			ck_fun		m@	A S? S? L
+push		push			ck_fun		imst@	A L
+pop		pop			ck_shift	si%	A
+shift		shift			ck_shift	s%	A
+unshift		unshift			ck_fun		imst@	A L
+sort		sort			ck_sort		m@	C? L
+reverse		reverse			ck_fun		mt@	L
 
-grepstart	grep			ck_grep		dm	C L
-grepwhile	grep iterator		ck_null		dt	
+grepstart	grep			ck_grep		dm@	C L
+grepwhile	grep iterator		ck_null		dt|	
 
-mapstart	map			ck_grep		dm	C L
-mapwhile	map iterator		ck_null		dt
+mapstart	map			ck_grep		dm@	C L
+mapwhile	map iterator		ck_null		dt|
 
 # Range stuff.
 
-range		flipflop		ck_null		0	S S
-flip		range (or flip)		ck_null		0	S S
-flop		range (or flop)		ck_null		0
+range		flipflop		ck_null		?	S S
+flip		range (or flip)		ck_null		1	S S
+flop		range (or flop)		ck_null		1
 
 # Control.
 
-and		logical and		ck_null		0	
-or		logical or		ck_null		0	
-xor		logical xor		ck_null		fs	S S	
-cond_expr	conditional expression	ck_null		d	
-andassign	logical and assignment	ck_null		s	
-orassign	logical or assignment	ck_null		s	
-
-method		method lookup		ck_null		d
-entersub	subroutine entry	ck_subr		dmt	L
-leavesub	subroutine exit		ck_null		0	
-caller		caller			ck_fun		t	S?
-warn		warn			ck_fun		imst	L
-die		die			ck_fun		dimst	L
-reset		reset			ck_fun		is	S?
-
-lineseq		line sequence		ck_null		0	
-nextstate	next statement		ck_null		s	
-dbstate		debug next statement	ck_null		s	
-unstack		unstack			ck_null		s
+and		logical and		ck_null		|	
+or		logical or		ck_null		|	
+xor		logical xor		ck_null		fs|	S S	
+cond_expr	conditional expression	ck_null		d?	
+andassign	logical and assignment	ck_null		s|	
+orassign	logical or assignment	ck_null		s|	
+
+method		method lookup		ck_null		d1
+entersub	subroutine entry	ck_subr		dmt1	L
+leavesub	subroutine exit		ck_null		1	
+caller		caller			ck_fun		t%	S?
+warn		warn			ck_fun		imst@	L
+die		die			ck_fun		dimst@	L
+reset		reset			ck_fun		is%	S?
+
+lineseq		line sequence		ck_null		@	
+nextstate	next statement		ck_null		s;	
+dbstate		debug next statement	ck_null		s;	
+unstack		unstack			ck_null		s0
 enter		block entry		ck_null		0	
-leave		block exit		ck_null		0	
-scope		block			ck_null		0	
-enteriter	foreach loop entry	ck_null		d	
+leave		block exit		ck_null		@	
+scope		block			ck_null		@	
+enteriter	foreach loop entry	ck_null		d{	
 iter		foreach loop iterator	ck_null		0	
-enterloop	loop entry		ck_null		d	
-leaveloop	loop exit		ck_null		0	
-return		return			ck_null		dm	L
-last		last			ck_null		ds	
-next		next			ck_null		ds	
-redo		redo			ck_null		ds	
-dump		dump			ck_null		ds	
-goto		goto			ck_null		ds	
-exit		exit			ck_fun		ds	S?
+enterloop	loop entry		ck_null		d{	
+leaveloop	loop exit		ck_null		2	
+return		return			ck_null		dm@	L
+last		last			ck_null		ds}	
+next		next			ck_null		ds}	
+redo		redo			ck_null		ds}	
+dump		dump			ck_null		ds}	
+goto		goto			ck_null		ds}	
+exit		exit			ck_fun		ds%	S?
 
 #nswitch		numeric switch		ck_null		d	
 #cswitch		character switch	ck_null		d	
 
 # I/O.
 
-open		open			ck_fun		ist	F S?
-close		close			ck_fun		is	F?
-pipe_op		pipe			ck_fun		is	F F
+open		open			ck_fun		ist@	F S?
+close		close			ck_fun		is%	F?
+pipe_op		pipe			ck_fun		is@	F F
 
-fileno		fileno			ck_fun		ist	F
-umask		umask			ck_fun		ist	S?
-binmode		binmode			ck_fun		s	F
+fileno		fileno			ck_fun		ist%	F
+umask		umask			ck_fun		ist%	S?
+binmode		binmode			ck_fun		s%	F
 
-tie		tie			ck_fun		idms	R S L
-untie		untie			ck_fun		is	R
-tied		tied			ck_fun		s	R
-dbmopen		dbmopen			ck_fun		is	H S S
-dbmclose	dbmclose		ck_fun		is	H
+tie		tie			ck_fun		idms@	R S L
+untie		untie			ck_fun		is%	R
+tied		tied			ck_fun		s%	R
+dbmopen		dbmopen			ck_fun		is@	H S S
+dbmclose	dbmclose		ck_fun		is%	H
 
-sselect		select system call	ck_select	t	S S S S
-select		select			ck_select	st	F?
+sselect		select system call	ck_select	t@	S S S S
+select		select			ck_select	st@	F?
 
-getc		getc			ck_eof		st	F?
-read		read			ck_fun		imst	F R S S?
-enterwrite	write			ck_fun		dis	F?
-leavewrite	write exit		ck_null		0	
+getc		getc			ck_eof		st%	F?
+read		read			ck_fun		imst@	F R S S?
+enterwrite	write			ck_fun		dis%	F?
+leavewrite	write exit		ck_null		1	
 
-prtf		printf			ck_listiob	ims	F? L
-print		print			ck_listiob	ims	F? L
+prtf		printf			ck_listiob	ims@	F? L
+print		print			ck_listiob	ims@	F? L
 
-sysopen		sysopen			ck_fun		s	F S S S?
-sysseek		sysseek			ck_fun		s	F S S
-sysread		sysread			ck_fun		imst	F R S S?
-syswrite	syswrite		ck_fun		imst	F S S S?
+sysopen		sysopen			ck_fun		s@	F S S S?
+sysseek		sysseek			ck_fun		s@	F S S
+sysread		sysread			ck_fun		imst@	F R S S?
+syswrite	syswrite		ck_fun		imst@	F S S S?
 
-send		send			ck_fun		imst	F S S S?
-recv		recv			ck_fun		imst	F R S S
+send		send			ck_fun		imst@	F S S S?
+recv		recv			ck_fun		imst@	F R S S
 
-eof		eof			ck_eof		is	F?
-tell		tell			ck_fun		st	F?
-seek		seek			ck_fun		s	F S S
+eof		eof			ck_eof		is%	F?
+tell		tell			ck_fun		st%	F?
+seek		seek			ck_fun		s@	F S S
 # truncate really behaves as if it had both "S S" and "F S"
-truncate	truncate		ck_trunc	is	S S
+truncate	truncate		ck_trunc	is@	S S
 
-fcntl		fcntl			ck_fun		st	F S S
-ioctl		ioctl			ck_fun		st	F S S
-flock		flock			ck_fun		ist	F S
+fcntl		fcntl			ck_fun		st@	F S S
+ioctl		ioctl			ck_fun		st@	F S S
+flock		flock			ck_fun		ist@	F S
 
 # Sockets.
 
-socket		socket			ck_fun		is	F S S S
-sockpair	socketpair		ck_fun		is	F F S S S
+socket		socket			ck_fun		is@	F S S S
+sockpair	socketpair		ck_fun		is@	F F S S S
 
-bind		bind			ck_fun		is	F S
-connect		connect			ck_fun		is	F S
-listen		listen			ck_fun		is	F S
-accept		accept			ck_fun		ist	F F
-shutdown	shutdown		ck_fun		ist	F S
+bind		bind			ck_fun		is@	F S
+connect		connect			ck_fun		is@	F S
+listen		listen			ck_fun		is@	F S
+accept		accept			ck_fun		ist@	F F
+shutdown	shutdown		ck_fun		ist@	F S
 
-gsockopt	getsockopt		ck_fun		is	F S S
-ssockopt	setsockopt		ck_fun		is	F S S S
+gsockopt	getsockopt		ck_fun		is@	F S S
+ssockopt	setsockopt		ck_fun		is@	F S S S
 
-getsockname	getsockname		ck_fun		is	F
-getpeername	getpeername		ck_fun		is	F
+getsockname	getsockname		ck_fun		is%	F
+getpeername	getpeername		ck_fun		is%	F
 
 # Stat calls.
 
-lstat		lstat			ck_ftst		u	F
-stat		stat			ck_ftst		u	F
-ftrread		-R			ck_ftst		isu	F
-ftrwrite	-W			ck_ftst		isu	F
-ftrexec		-X			ck_ftst		isu	F
-fteread		-r			ck_ftst		isu	F
-ftewrite	-w			ck_ftst		isu	F
-fteexec		-x			ck_ftst		isu	F
-ftis		-e			ck_ftst		isu	F
-fteowned	-O			ck_ftst		isu	F
-ftrowned	-o			ck_ftst		isu	F
-ftzero		-z			ck_ftst		isu	F
-ftsize		-s			ck_ftst		istu	F
-ftmtime		-M			ck_ftst		stu	F
-ftatime		-A			ck_ftst		stu	F
-ftctime		-C			ck_ftst		stu	F
-ftsock		-S			ck_ftst		isu	F
-ftchr		-c			ck_ftst		isu	F
-ftblk		-b			ck_ftst		isu	F
-ftfile		-f			ck_ftst		isu	F
-ftdir		-d			ck_ftst		isu	F
-ftpipe		-p			ck_ftst		isu	F
-ftlink		-l			ck_ftst		isu	F
-ftsuid		-u			ck_ftst		isu	F
-ftsgid		-g			ck_ftst		isu	F
-ftsvtx		-k			ck_ftst		isu	F
-fttty		-t			ck_ftst		is	F
-fttext		-T			ck_ftst		isu	F
-ftbinary	-B			ck_ftst		isu	F
+lstat		lstat			ck_ftst		u-	F
+stat		stat			ck_ftst		u-	F
+ftrread		-R			ck_ftst		isu-	F
+ftrwrite	-W			ck_ftst		isu-	F
+ftrexec		-X			ck_ftst		isu-	F
+fteread		-r			ck_ftst		isu-	F
+ftewrite	-w			ck_ftst		isu-	F
+fteexec		-x			ck_ftst		isu-	F
+ftis		-e			ck_ftst		isu-	F
+fteowned	-O			ck_ftst		isu-	F
+ftrowned	-o			ck_ftst		isu-	F
+ftzero		-z			ck_ftst		isu-	F
+ftsize		-s			ck_ftst		istu-	F
+ftmtime		-M			ck_ftst		stu-	F
+ftatime		-A			ck_ftst		stu-	F
+ftctime		-C			ck_ftst		stu-	F
+ftsock		-S			ck_ftst		isu-	F
+ftchr		-c			ck_ftst		isu-	F
+ftblk		-b			ck_ftst		isu-	F
+ftfile		-f			ck_ftst		isu-	F
+ftdir		-d			ck_ftst		isu-	F
+ftpipe		-p			ck_ftst		isu-	F
+ftlink		-l			ck_ftst		isu-	F
+ftsuid		-u			ck_ftst		isu-	F
+ftsgid		-g			ck_ftst		isu-	F
+ftsvtx		-k			ck_ftst		isu-	F
+fttty		-t			ck_ftst		is-	F
+fttext		-T			ck_ftst		isu-	F
+ftbinary	-B			ck_ftst		isu-	F
 
 # File calls.
 
-chdir		chdir			ck_fun		ist	S?
-chown		chown			ck_fun		imst	L
-chroot		chroot			ck_fun		istu	S?
-unlink		unlink			ck_fun		imstu	L
-chmod		chmod			ck_fun		imst	L
-utime		utime			ck_fun		imst	L
-rename		rename			ck_fun		ist	S S
-link		link			ck_fun		ist	S S
-symlink		symlink			ck_fun		ist	S S
-readlink	readlink		ck_fun		stu	S?
-mkdir		mkdir			ck_fun		ist	S S
-rmdir		rmdir			ck_fun		istu	S?
+chdir		chdir			ck_fun		ist%	S?
+chown		chown			ck_fun		imst@	L
+chroot		chroot			ck_fun		istu%	S?
+unlink		unlink			ck_fun		imstu@	L
+chmod		chmod			ck_fun		imst@	L
+utime		utime			ck_fun		imst@	L
+rename		rename			ck_fun		ist@	S S
+link		link			ck_fun		ist@	S S
+symlink		symlink			ck_fun		ist@	S S
+readlink	readlink		ck_fun		stu%	S?
+mkdir		mkdir			ck_fun		ist@	S S
+rmdir		rmdir			ck_fun		istu%	S?
 
 # Directory calls.
 
-open_dir	opendir			ck_fun		is	F S
-readdir		readdir			ck_fun		0	F
-telldir		telldir			ck_fun		st	F
-seekdir		seekdir			ck_fun		s	F S
-rewinddir	rewinddir		ck_fun		s	F
-closedir	closedir		ck_fun		is	F
+open_dir	opendir			ck_fun		is@	F S
+readdir		readdir			ck_fun		%	F
+telldir		telldir			ck_fun		st%	F
+seekdir		seekdir			ck_fun		s@	F S
+rewinddir	rewinddir		ck_fun		s%	F
+closedir	closedir		ck_fun		is%	F
 
 # Process control.
 
-fork		fork			ck_null		ist	
-wait		wait			ck_null		ist	
-waitpid		waitpid			ck_fun		ist	S S
-system		system			ck_exec		imst	S? L
-exec		exec			ck_exec		dimst	S? L
-kill		kill			ck_fun		dimst	L
-getppid		getppid			ck_null		ist	
-getpgrp		getpgrp			ck_fun		ist	S?
-setpgrp		setpgrp			ck_fun		ist	S? S?
-getpriority	getpriority		ck_fun		ist	S S
-setpriority	setpriority		ck_fun		ist	S S S
+fork		fork			ck_null		ist0	
+wait		wait			ck_null		ist0	
+waitpid		waitpid			ck_fun		ist@	S S
+system		system			ck_exec		imst@	S? L
+exec		exec			ck_exec		dimst@	S? L
+kill		kill			ck_fun		dimst@	L
+getppid		getppid			ck_null		ist0	
+getpgrp		getpgrp			ck_fun		ist%	S?
+setpgrp		setpgrp			ck_fun		ist@	S? S?
+getpriority	getpriority		ck_fun		ist@	S S
+setpriority	setpriority		ck_fun		ist@	S S S
 
 # Time calls.
 
-time		time			ck_null		ist	
+time		time			ck_null		ist0	
 tms		times			ck_null		0	
-localtime	localtime		ck_fun		t	S?
-gmtime		gmtime			ck_fun		t	S?
-alarm		alarm			ck_fun		istu	S?
-sleep		sleep			ck_fun		ist	S?
+localtime	localtime		ck_fun		t%	S?
+gmtime		gmtime			ck_fun		t%	S?
+alarm		alarm			ck_fun		istu%	S?
+sleep		sleep			ck_fun		ist%	S?
 
 # Shared memory.
 
-shmget		shmget			ck_fun		imst	S S S
-shmctl		shmctl			ck_fun		imst	S S S
-shmread		shmread			ck_fun		imst	S S S S
-shmwrite	shmwrite		ck_fun		imst	S S S S
+shmget		shmget			ck_fun		imst@	S S S
+shmctl		shmctl			ck_fun		imst@	S S S
+shmread		shmread			ck_fun		imst@	S S S S
+shmwrite	shmwrite		ck_fun		imst@	S S S S
 
 # Message passing.
 
-msgget		msgget			ck_fun		imst	S S
-msgctl		msgctl			ck_fun		imst	S S S
-msgsnd		msgsnd			ck_fun		imst	S S S
-msgrcv		msgrcv			ck_fun		imst	S S S S S
+msgget		msgget			ck_fun		imst@	S S
+msgctl		msgctl			ck_fun		imst@	S S S
+msgsnd		msgsnd			ck_fun		imst@	S S S
+msgrcv		msgrcv			ck_fun		imst@	S S S S S
 
 # Semaphores.
 
-semget		semget			ck_fun		imst	S S S
-semctl		semctl			ck_fun		imst	S S S S
-semop		semop			ck_fun		imst	S S
+semget		semget			ck_fun		imst@	S S S
+semctl		semctl			ck_fun		imst@	S S S S
+semop		semop			ck_fun		imst@	S S
 
 # Eval.
 
-require		require			ck_require	du	S?
-dofile		do 'file'		ck_fun		d	S
-entereval	eval string		ck_eval		d	S
-leaveeval	eval exit		ck_null		0	S
-#evalonce	eval constant string	ck_null		d	S
-entertry	eval block		ck_null		0	
-leavetry	eval block exit		ck_null		0	
+require		require			ck_require	du%	S?
+dofile		do 'file'		ck_fun		d1	S
+entereval	eval string		ck_eval		d%	S
+leaveeval	eval exit		ck_null		1	S
+#evalonce	eval constant string	ck_null		d1	S
+entertry	eval block		ck_null		|	
+leavetry	eval block exit		ck_null		@	
 
 # Get system info.
 
-ghbyname	gethostbyname		ck_fun		0	S
-ghbyaddr	gethostbyaddr		ck_fun		0	S S
+ghbyname	gethostbyname		ck_fun		%	S
+ghbyaddr	gethostbyaddr		ck_fun		@	S S
 ghostent	gethostent		ck_null		0	
-gnbyname	getnetbyname		ck_fun		0	S
-gnbyaddr	getnetbyaddr		ck_fun		0	S S
+gnbyname	getnetbyname		ck_fun		%	S
+gnbyaddr	getnetbyaddr		ck_fun		@	S S
 gnetent		getnetent		ck_null		0	
-gpbyname	getprotobyname		ck_fun		0	S
-gpbynumber	getprotobynumber	ck_fun		0	S
+gpbyname	getprotobyname		ck_fun		%	S
+gpbynumber	getprotobynumber	ck_fun		@	S
 gprotoent	getprotoent		ck_null		0	
-gsbyname	getservbyname		ck_fun		0	S S
-gsbyport	getservbyport		ck_fun		0	S S
+gsbyname	getservbyname		ck_fun		@	S S
+gsbyport	getservbyport		ck_fun		@	S S
 gservent	getservent		ck_null		0	
-shostent	sethostent		ck_fun		is	S
-snetent		setnetent		ck_fun		is	S
-sprotoent	setprotoent		ck_fun		is	S
-sservent	setservent		ck_fun		is	S
-ehostent	endhostent		ck_null		is	
-enetent		endnetent		ck_null		is	
-eprotoent	endprotoent		ck_null		is	
-eservent	endservent		ck_null		is	
-gpwnam		getpwnam		ck_fun		0	S
-gpwuid		getpwuid		ck_fun		0	S
+shostent	sethostent		ck_fun		is%	S
+snetent		setnetent		ck_fun		is%	S
+sprotoent	setprotoent		ck_fun		is%	S
+sservent	setservent		ck_fun		is%	S
+ehostent	endhostent		ck_null		is0	
+enetent		endnetent		ck_null		is0	
+eprotoent	endprotoent		ck_null		is0	
+eservent	endservent		ck_null		is0	
+gpwnam		getpwnam		ck_fun		%	S
+gpwuid		getpwuid		ck_fun		%	S
 gpwent		getpwent		ck_null		0	
-spwent		setpwent		ck_null		is	
-epwent		endpwent		ck_null		is	
-ggrnam		getgrnam		ck_fun		0	S
-ggrgid		getgrgid		ck_fun		0	S
+spwent		setpwent		ck_null		is0	
+epwent		endpwent		ck_null		is0	
+ggrnam		getgrnam		ck_fun		%	S
+ggrgid		getgrgid		ck_fun		%	S
 ggrent		getgrent		ck_null		0	
-sgrent		setgrent		ck_null		is	
-egrent		endgrent		ck_null		is	
-getlogin	getlogin		ck_null		st	
+sgrent		setgrent		ck_null		is0	
+egrent		endgrent		ck_null		is0	
+getlogin	getlogin		ck_null		st0	
 
 # Miscellaneous.
 
-syscall		syscall			ck_fun		imst	S L
+syscall		syscall			ck_fun		imst@	S L
 
 # For multi-threading
-lock		lock			ck_rfun		s	S
+lock		lock			ck_rfun		s%	S