CVS: sml-dist primop-list,1.1.2.1,1.1.2.2
David MacQueen <[email protected]> Sun, 25 Jun 2006 05:14:43 -0700
| Newsgroups | gmane.comp.lang.sml.smlnj.commits |
|---|---|
| Message-ID | <[email protected]> |
Update of /cvsroot/smlnj/sml-dist
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv9282
Modified Files:
Tag: primop-branch-2
primop-list
Log Message:
translated types into readable form
Index: primop-list
===================================================================
RCS file: /cvsroot/smlnj/sml-dist/Attic/primop-list,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -C2 -d -r1.1.2.1 -r1.1.2.2
*** primop-list 21 Jun 2006 23:02:42 -0000 1.1.2.1
--- primop-list 25 Jun 2006 12:14:41 -0000 1.1.2.2
***************
*** 134,167 ****
(* conversion primops involving intinf *)
! test_inf_31, P.TEST_INF 31, inf_i
! test_inf_32, P.TEST_INF 32, inf_i32
! test_inf_64, P.TEST_INF 64, inf_i64
! copy_8_inf, P.COPY_INF 8, w8_inf
! copy_8_inf_w, P.COPY_INF 8, w8_inf
! copy_31_inf_w, P.COPY_INF 31, w_inf
! copy_32_inf_w, P.COPY_INF 32, w32_inf
! copy_64_inf_w, P.COPY_INF 64, w64_inf
! copy_31_inf_i, P.COPY_INF 31, i_inf
! copy_32_inf_i, P.COPY_INF 32, i32_inf
! copy_64_inf_i, P.COPY_INF 64, i64_inf
! extend_8_inf, P.EXTEND_INF 8, w8_inf
! extend_8_inf_w, P.EXTEND_INF 8, w8_inf
! extend_31_inf_w, P.EXTEND_INF 31, w_inf
! extend_32_inf_w, P.EXTEND_INF 32, w32_inf
! extend_64_inf_w, P.EXTEND_INF 64, w64_inf
! extend_31_inf_i, P.EXTEND_INF 31, i_inf
! extend_32_inf_i, P.EXTEND_INF 32, i32_inf
! extend_64_inf_i, P.EXTEND_INF 64, i64_inf
! trunc_inf_8, P.TRUNC_INF 8, inf_w8
! trunc_inf_31, P.TRUNC_INF 31, inf_w
! trunc_inf_32, P.TRUNC_INF 32, inf_w32
! trunc_inf_64, P.TRUNC_INF 64, inf_w64
(* primops to go between abstract and concrete representation of
* 64-bit ints and words *)
! w64p, P.CVT64, w64_pw32
! p64w, P.CVT64, pw32_w64
! i64p, P.CVT64, i64_pw32
! p64i, P.CVT64, pw32_i64
(* *** integer 31 primops ***
--- 134,167 ----
(* conversion primops involving intinf *)
! test_inf_31, P.TEST_INF 31, intinf -> int
! test_inf_32, P.TEST_INF 32, intinf -> int32
! test_inf_64, P.TEST_INF 64, intinf -> int64
! copy_8_inf, P.COPY_INF 8, word8 -> intinf
! copy_8_inf_w, P.COPY_INF 8, word8 -> intinf
! copy_31_inf_w, P.COPY_INF 31, word -> intinf
! copy_32_inf_w, P.COPY_INF 32, word32 -> intinf
! copy_64_inf_w, P.COPY_INF 64, w64-> intinf
! copy_31_inf_i, P.COPY_INF 31, int -> intinf
! copy_32_inf_i, P.COPY_INF 32, int32 -> intinf
! copy_64_inf_i, P.COPY_INF 64, int64 -> intinf
! extend_8_inf, P.EXTEND_INF 8, word8 -> intinf
! extend_8_inf_w, P.EXTEND_INF 8, word8 -> intinf
! extend_31_inf_w, P.EXTEND_INF 31, word -> intinf
! extend_32_inf_w, P.EXTEND_INF 32, word32 -> intinf
! extend_64_inf_w, P.EXTEND_INF 64, word64 -> intinf
! extend_31_inf_i, P.EXTEND_INF 31, int -> intinf
! extend_32_inf_i, P.EXTEND_INF 32, int32 -> intinf
! extend_64_inf_i, P.EXTEND_INF 64, int64 -> intinf
! trunc_inf_8, P.TRUNC_INF 8, intinf -> word8
! trunc_inf_31, P.TRUNC_INF 31, intinf -> word
! trunc_inf_32, P.TRUNC_INF 32, intinf -> word32
! trunc_inf_64, P.TRUNC_INF 64, intinf -> word64
(* primops to go between abstract and concrete representation of
* 64-bit ints and words *)
! w64p, P.CVT64, word64 -> word32 * word32
! p64w, P.CVT64, word32 * word32 -> word64
! i64p, P.CVT64, int64 -> word32 * word32
! p64i, P.CVT64, word32 * word32 -> int64
(* *** integer 31 primops ***
***************
*** 170,413 ****
* there are suffixed alternative versions of the primop
* (i.e., same primop, different type). *)
! i31add, int31 P.+, ii_i
! i31add_8, int31 P.+, w8w8_w8
! i31sub, int31 P.-, ii_i
! i31sub_8, int31 P.-, w8w8_w8
! i31mul, int31 P.*, ii_i
! i31mul_8, int31 P.*, w8w8_w8
! i31div, int31 P.DIV, ii_i
! i31div_8, int31 P.DIV, w8w8_w8
! i31mod, int31 P.MOD, ii_i
! i31mod_8, int31 P.MOD, w8w8_w8
! i31quot, int31 P./, ii_i
! i31rem, int31 P.REM, ii_i
! i31orb, bits31 P.ORB, ii_i
! i31orb_8, bits31 P.ORB, w8w8_w8
! i31andb, bits31 P.ANDB, ii_i
! i31andb_8, bits31 P.ANDB, w8w8_w8
! i31xorb, bits31 P.XORB, ii_i
! i31xorb_8, bits31 P.XORB, w8w8_w8
! i31notb, bits31 P.NOTB, i_i
! i31notb_8, bits31 P.NOTB, w8_w8
! i31neg, int31 P.~, i_i
! i31neg_8, int31 P.~, w8_w8
! i31lshift, bits31 P.LSHIFT, ii_i
! i31lshift_8, bits31 P.LSHIFT, w8w_w8
! i31rshift, bits31 P.RSHIFT, ii_i
! i31rshift_8, bits31 P.RSHIFT, w8w_w8
! i31lt, int31cmp P.<, ii_b
! i31lt_8, int31cmp P.<, w8w8_b
! i31lt_c, int31cmp P.<, cc_b
! i31le, int31cmp P.<=, ii_b
! i31le_8, int31cmp P.<=, w8w8_b
! i31le_c, int31cmp P.<=, cc_b
! i31gt, int31cmp P.>, ii_b
! i31gt_8, int31cmp P.>, w8w8_b
! i31gt_c, int31cmp P.>, cc_b
! i31ge, int31cmp P.>=, ii_b
! i31ge_8, int31cmp P.>=, w8w8_b
! i31ge_c, int31cmp P.>=, cc_b
! i31ltu, word31cmp P.LTU, ii_b
! i31geu, word31cmp P.GEU, ii_b
! i31eq, int31cmp P.EQL, ii_b
! i31ne, int31cmp P.NEQ, ii_b
! i31min, P.INLMIN (P.INT 31), ii_i
! i31min_8, P.INLMIN (P.INT 31), w8w8_w8
! i31max, P.INLMAX (P.INT 31), ii_i
! i31max_8, P.INLMAX (P.INT 31), w8w8_w8
! i31abs, P.INLABS (P.INT 31), i_i
(*** integer 32 primops ***)
! i32mul, int32 P.*, i32i32_i32
! i32div, int32 P.DIV, i32i32_i32
! i32mod, int32 P.MOD, i32i32_i32
! i32quot, int32 P./, i32i32_i32
! i32rem, int32 P.REM, i32i32_i32
! i32add, int32 P.+, i32i32_i32
! i32sub, int32 P.-, i32i32_i32
! i32orb, bits32 P.ORB, i32i32_i32
! i32andb, bits32 P.ANDB, i32i32_i32
! i32xorb, bits32 P.XORB, i32i32_i32
! i32lshift, bits32 P.LSHIFT, i32i32_i32
! i32rshift, bits32 P.RSHIFT, i32i32_i32
! i32neg, int32 P.~, i32_i32
! i32lt, int32cmp P.<, i32i32_b
! i32le, int32cmp P.<=, i32i32_b
! i32gt, int32cmp P.>, i32i32_b
! i32ge, int32cmp P.>=, i32i32_b
! i32eq, int32cmp P.EQL, i32i32_b
! i32ne, int32cmp P.NEQ, i32i32_b
! i32min, P.INLMIN (P.INT 32), i32i32_i32
! i32max, P.INLMAX (P.INT 32), i32i32_i32
! i32abs, P.INLABS (P.INT 32), i32_i32
(*** float 64 primops ***)
! f64add, purefloat64 (P.+), f64f64_f64
! f64sub, purefloat64 (P.-), f64f64_f64
! f64div, purefloat64 (P./), f64f64_f64
! f64mul, purefloat64 (P.* ), f64f64_f64
! f64neg, purefloat64 P.~, f64_f64
! f64ge, float64cmp (P.>=), f64f64_b
! f64gt, float64cmp (P.>), f64f64_b
! f64le, float64cmp (P.<=), f64f64_b
! f64lt, float64cmp (P.<), f64f64_b
! f64eq, float64cmp P.EQL, f64f64_b
! f64ne, float64cmp P.NEQ, f64f64_b
! f64abs, purefloat64 P.ABS, f64_f64
! f64sin, purefloat64 P.FSIN, f64_f64
! f64cos, purefloat64 P.FCOS, f64_f64
! f64tan, purefloat64 P.FTAN, f64_f64
! f64sqrt, purefloat64 P.FSQRT, f64_f64
! f64min, P.INLMIN (P.FLOAT 64), f64f64_f64
! f64max, P.INLMAX (P.FLOAT 64), f64f64_f64
(*** float64 array ***)
! f64Sub, sub (P.FLOAT 64), numSubTy
! f64chkSub, chkSub (P.FLOAT 64), numSubTy
! f64Update, update (P.FLOAT 64), numUpdTy
! f64chkUpdate, chkUpdate (P.FLOAT 64), numUpdTy
(*** word8 primops ***)
! w8orb, word31 P.ORB, w8w8_w8
! w8xorb, word31 P.XORB, w8w8_w8
! w8andb, word31 P.ANDB, w8w8_w8
! w8gt, word8cmp P.>, w8w8_b
! w8ge, word8cmp P.>=, w8w8_b
! w8lt, word8cmp P.<, w8w8_b
! w8le, word8cmp P.<=, w8w8_b
! w8eq, word8cmp P.EQL, w8w8_b
! w8ne, word8cmp P.NEQ, w8w8_b
(*** word8 array and vector ***)
! w8Sub, sub (P.UINT 8), numSubTy
! w8chkSub, chkSub (P.UINT 8), numSubTy
! w8subv, subv (P.UINT 8), numSubTy
! w8chkSubv, chkSubv (P.UINT 8), numSubTy
! w8update, update (P.UINT 8), numUpdTy
! w8chkUpdate, chkUpdate (P.UINT 8), numUpdTy
(* word31 primops *)
! w31mul, word31 (P.* ), ww_w
! w31div, word31 (P./), ww_w
! w31mod, word31 (P.REM), ww_w
! w31add, word31 (P.+), ww_w
! w31sub, word31 (P.-), ww_w
! w31orb, word31 P.ORB, ww_w
! w31xorb, word31 P.XORB, ww_w
! w31andb, word31 P.ANDB, ww_w
! w31notb, word31 P.NOTB, w_w
! w31neg, word31 P.~, w_w
! w31rshift, word31 P.RSHIFT, ww_w
! w31rshiftl, word31 P.RSHIFTL, ww_w
! w31lshift, word31 P.LSHIFT, ww_w
! w31gt, word31cmp (P.>), ww_b
! w31ge, word31cmp (P.>=), ww_b
! w31lt, word31cmp (P.<), ww_b
! w31le, word31cmp (P.<=), ww_b
! w31eq, word31cmp P.EQL, ww_b
! w31ne, word31cmp P.NEQ, ww_b
! w31ChkRshift, P.INLRSHIFT(P.UINT 31), ww_w
! w31ChkRshiftl, P.INLRSHIFTL(P.UINT 31),ww_w
! w31ChkLshift, P.INLLSHIFT(P.UINT 31), ww_w
! w31min, P.INLMIN (P.UINT 31), ww_w
! w31max, P.INLMAX (P.UINT 31), ww_w
(* (pseudo-)word8 primops *)
! w31mul_8, word31 (P.* ), w8w8_w8
! w31div_8, word31 (P./), w8w8_w8
! w31mod_8, word31 (P.REM), w8w8_w8
! w31add_8, word31 (P.+), w8w8_w8
! w31sub_8, word31 (P.-), w8w8_w8
! w31orb_8, word31 P.ORB, w8w8_w8
! w31xorb_8, word31 P.XORB, w8w8_w8
! w31andb_8, word31 P.ANDB, w8w8_w8
! w31notb_8, word31 P.NOTB, w8_w8
! w31neg_8, word31 P.~, w8_w8
! w31rshift_8, word31 P.RSHIFT, w8w_w8
! w31rshiftl_8, word31 P.RSHIFTL, w8w_w8
! w31lshift_8, word31 P.LSHIFT, w8w_w8
! w31gt_8, word31cmp (P.>), w8w8_b
! w31ge_8, word31cmp (P.>=), w8w8_b
! w31lt_8, word31cmp (P.<), w8w8_b
! w31le_8, word31cmp (P.<=), w8w8_b
! w31eq_8, word31cmp P.EQL, w8w8_b
! w31ne_8, word31cmp P.NEQ, w8w8_b
! w31ChkRshift_8, P.INLRSHIFT(P.UINT 31), w8w_w8
! w31ChkRshiftl_8,P.INLRSHIFTL(P.UINT 31),w8w_w8
! w31ChkLshift_8, P.INLLSHIFT(P.UINT 31), w8w_w8
! w31min_8, P.INLMIN (P.UINT 31), w8w8_w8
! w31max_8, P.INLMAX (P.UINT 31), w8w8_w8
(*** word32 primops ***)
! w32mul, word32 (P.* ), w32w32_w32
! w32div, word32 (P./), w32w32_w32
! w32mod, word32 (P.REM), w32w32_w32
! w32add, word32 (P.+), w32w32_w32
! w32sub, word32 (P.-), w32w32_w32
! w32orb, word32 P.ORB, w32w32_w32
! w32xorb, word32 P.XORB, w32w32_w32
! w32andb, word32 P.ANDB, w32w32_w32
! w32notb, word32 P.NOTB, w32_w32
! w32neg, word32 P.~, w32_w32
! w32rshift, word32 P.RSHIFT, w32w_w32
! w32rshiftl, word32 P.RSHIFTL, w32w_w32
! w32lshift, word32 P.LSHIFT, w32w_w32
! w32gt, word32cmp (P.>), w32w32_b
! w32ge, word32cmp (P.>=), w32w32_b
! w32lt, word32cmp (P.<), w32w32_b
! w32le, word32cmp (P.<=), w32w32_b
! w32eq, word32cmp P.EQL, w32w32_b
! w32ne, word32cmp P.NEQ, w32w32_b
! w32ChkRshift, P.INLRSHIFT(P.UINT 32), w32w_w32
! w32ChkRshiftl, P.INLRSHIFTL(P.UINT 32),w32w_w32
! w32ChkLshift, P.INLLSHIFT(P.UINT 32), w32w_w32
! w32min, P.INLMIN (P.UINT 32), w32w32_w32
! w32max, P.INLMAX (P.UINT 32), w32w32_w32
(* experimental C FFI primops *)
! raww8l, P.RAW_LOAD (P.UINT 8), w32_w32
! rawi8l, P.RAW_LOAD (P.INT 8), w32_i32
! raww16l, P.RAW_LOAD (P.UINT 16), w32_w32
! rawi16l, P.RAW_LOAD (P.INT 16), w32_i32
! raww32l, P.RAW_LOAD (P.UINT 32), w32_w32
! rawi32l, P.RAW_LOAD (P.INT 32), w32_i32
! rawf32l, P.RAW_LOAD (P.FLOAT 32), w32_f64
! rawf64l, P.RAW_LOAD (P.FLOAT 64), w32_f64
! raww8s, P.RAW_STORE (P.UINT 8), w32w32_u
! rawi8s, P.RAW_STORE (P.INT 8), w32i32_u
! raww16s, P.RAW_STORE (P.UINT 16), w32w32_u
! rawi16s, P.RAW_STORE (P.INT 16), w32i32_u
! raww32s, P.RAW_STORE (P.UINT 32), w32w32_u
! rawi32s, P.RAW_STORE (P.INT 32), w32i32_u
! rawf32s, P.RAW_STORE (P.FLOAT 32), w32f64_u
! rawf64s, P.RAW_STORE (P.FLOAT 64), w32f64_u
! rawccall, P.RAW_CCALL NONE, rccType
(* Support for direct construction of C objects on ML heap.
--- 170,413 ----
* there are suffixed alternative versions of the primop
* (i.e., same primop, different type). *)
! i31add, int31 P.+, int * int -> int
! i31add_8, int31 P.+, word8 * word8 -> word8
! i31sub, int31 P.-, int * int -> int
! i31sub_8, int31 P.-, word8 * word8 -> word8
! i31mul, int31 P.*, int * int -> int
! i31mul_8, int31 P.*, word8 * word8 -> word8
! i31div, int31 P.DIV, int * int -> int
! i31div_8, int31 P.DIV, word8 * word8 -> word8
! i31mod, int31 P.MOD, int * int -> int
! i31mod_8, int31 P.MOD, word8 * word8 -> word8
! i31quot, int31 P./, int * int -> int
! i31rem, int31 P.REM, int * int -> int
! i31orb, bits31 P.ORB, int * int -> int
! i31orb_8, bits31 P.ORB, word8 * word8 -> word8
! i31andb, bits31 P.ANDB, int * int -> int
! i31andb_8, bits31 P.ANDB, word8 * word8 -> word8
! i31xorb, bits31 P.XORB, int * int -> int
! i31xorb_8, bits31 P.XORB, word8 * word8 -> word8
! i31notb, bits31 P.NOTB, int -> int
! i31notb_8, bits31 P.NOTB, word8 -> word8
! i31neg, int31 P.~, int -> int
! i31neg_8, int31 P.~, word8 -> word8
! i31lshift, bits31 P.LSHIFT, int * int -> int
! i31lshift_8, bits31 P.LSHIFT, word8word ->word8
! i31rshift, bits31 P.RSHIFT, int * int -> int
! i31rshift_8, bits31 P.RSHIFT, word8word ->word8
! i31lt, int31cmp P.<, int * int -> bool
! i31lt_8, int31cmp P.<, word8 * word8-> bool
! i31lt_c, int31cmp P.<, char * char -> bool
! i31le, int31cmp P.<=, int * int -> bool
! i31le_8, int31cmp P.<=, word8 * word8-> bool
! i31le_c, int31cmp P.<=, char * char -> bool
! i31gt, int31cmp P.>, int * int -> bool
! i31gt_8, int31cmp P.>, word8 * word8-> bool
! i31gt_c, int31cmp P.>, char * char-> bool
! i31ge, int31cmp P.>=, int * int -> bool
! i31ge_8, int31cmp P.>=, word8 * word8-> bool
! i31ge_c, int31cmp P.>=, char * char -> bool
! i31ltu, word31cmp P.LTU, int * int -> bool
! i31geu, word31cmp P.GEU, int * int -> bool
! i31eq, int31cmp P.EQL, int * int -> bool
! i31ne, int31cmp P.NEQ, int * int -> bool
! i31min, P.INLMIN (P.INT 31), int * int -> int
! i31min_8, P.INLMIN (P.INT 31), word8 * word8 -> word8
! i31max, P.INLMAX (P.INT 31), int * int -> int
! i31max_8, P.INLMAX (P.INT 31), word8 * word8 -> word8
! i31abs, P.INLABS (P.INT 31), int -> int
(*** integer 32 primops ***)
! i32mul, int32 P.*, int32 * int32 -> int32
! i32div, int32 P.DIV, int32 * int32 -> int32
! i32mod, int32 P.MOD, int32 * int32 -> int32
! i32quot, int32 P./, int32 * int32 -> int32
! i32rem, int32 P.REM, int32 * int32 -> int32
! i32add, int32 P.+, int32 * int32 -> int32
! i32sub, int32 P.-, int32 * int32 -> int32
! i32orb, bits32 P.ORB, int32 * int32 -> int32
! i32andb, bits32 P.ANDB, int32 * int32 -> int32
! i32xorb, bits32 P.XORB, int32 * int32 -> int32
! i32lshift, bits32 P.LSHIFT, int32 * int32 -> int32
! i32rshift, bits32 P.RSHIFT, int32 * int32 -> int32
! i32neg, int32 P.~, int32 -> int32
! i32lt, int32cmp P.<, int32 * int32-> bool
! i32le, int32cmp P.<=, int32 * int32-> bool
! i32gt, int32cmp P.>, int32 * int32-> bool
! i32ge, int32cmp P.>=, int32 * int32-> bool
! i32eq, int32cmp P.EQL, int32 * int32-> bool
! i32ne, int32cmp P.NEQ, int32 * int32-> bool
! i32min, P.INLMIN (P.INT 32), int32 * int32 -> int32
! i32max, P.INLMAX (P.INT 32), int32 * int32 -> int32
! i32abs, P.INLABS (P.INT 32), int32 -> int32
(*** float 64 primops ***)
! f64add, purefloat64 (P.+), real * real-> real
! f64sub, purefloat64 (P.-), real * real-> real
! f64div, purefloat64 (P./), real * real-> real
! f64mul, purefloat64 (P.* ), real * real-> real
! f64neg, purefloat64 P.~, real -> real
! f64ge, float64cmp (P.>=), real * real-> bool
! f64gt, float64cmp (P.>), real * real-> bool
! f64le, float64cmp (P.<=), real * real-> bool
! f64lt, float64cmp (P.<), real * real-> bool
! f64eq, float64cmp P.EQL, real * real-> bool
! f64ne, float64cmp P.NEQ, real * real-> bool
! f64abs, purefloat64 P.ABS, real -> real
! f64sin, purefloat64 P.FSIN, real -> real
! f64cos, purefloat64 P.FCOS, real -> real
! f64tan, purefloat64 P.FTAN, real -> real
! f64sqrt, purefloat64 P.FSQRT, real -> real
! f64min, P.INLMIN (P.FLOAT 64), real * real-> real
! f64max, P.INLMAX (P.FLOAT 64), real * real-> real
(*** float64 array ***)
! f64Sub, sub (P.FLOAT 64), 'a * int -> 'b
! f64chkSub, chkSub (P.FLOAT 64), 'a * int -> 'b
! f64Update, update (P.FLOAT 64), 'a * int * 'b -> unit
! f64chkUpdate, chkUpdate (P.FLOAT 64), 'a * int * 'b -> unit
(*** word8 primops ***)
! w8orb, word31 P.ORB, word8 * word8 -> word8
! w8xorb, word31 P.XORB, word8 * word8 -> word8
! w8andb, word31 P.ANDB, word8 * word8 -> word8
! w8gt, word8cmp P.>, word8 * word8 -> bool
! w8ge, word8cmp P.>=, word8 * word8 -> bool
! w8lt, word8cmp P.<, word8 * word8 -> bool
! w8le, word8cmp P.<=, word8 * word8 -> bool
! w8eq, word8cmp P.EQL, word8 * word8 -> bool
! w8ne, word8cmp P.NEQ, word8 * word8 -> bool
(*** word8 array and vector ***)
! w8Sub, sub (P.UINT 8), 'a * int -> 'b
! w8chkSub, chkSub (P.UINT 8), 'a * int -> 'b
! w8subv, subv (P.UINT 8), 'a * int -> 'b
! w8chkSubv, chkSubv (P.UINT 8), 'a * int -> 'b
! w8update, update (P.UINT 8), 'a * int * 'b -> unit
! w8chkUpdate, chkUpdate (P.UINT 8), 'a * int * 'b -> unit
(* word31 primops *)
! w31mul, word31 (P.* ), word * word -> word
! w31div, word31 (P./), word * word -> word
! w31mod, word31 (P.REM), word * word -> word
! w31add, word31 (P.+), word * word -> word
! w31sub, word31 (P.-), word * word -> word
! w31orb, word31 P.ORB, word * word -> word
! w31xorb, word31 P.XORB, word * word -> word
! w31andb, word31 P.ANDB, word * word -> word
! w31notb, word31 P.NOTB, word -> word
! w31neg, word31 P.~, word -> word
! w31rshift, word31 P.RSHIFT, word * word -> word
! w31rshiftl, word31 P.RSHIFTL, word * word -> word
! w31lshift, word31 P.LSHIFT, word * word -> word
! w31gt, word31cmp (P.>), word * word -> bool
! w31ge, word31cmp (P.>=), word * word -> bool
! w31lt, word31cmp (P.<), word * word -> bool
! w31le, word31cmp (P.<=), word * word -> bool
! w31eq, word31cmp P.EQL, word * word -> bool
! w31ne, word31cmp P.NEQ, word * word -> bool
! w31ChkRshift, P.INLRSHIFT(P.UINT 31), word * word -> word
! w31ChkRshiftl, P.INLRSHIFTL(P.UINT 31),word * word -> word
! w31ChkLshift, P.INLLSHIFT(P.UINT 31), word * word -> word
! w31min, P.INLMIN (P.UINT 31), word * word -> word
! w31max, P.INLMAX (P.UINT 31), word * word -> word
(* (pseudo-)word8 primops *)
! w31mul_8, word31 (P.* ), word8 * word8 -> word8
! w31div_8, word31 (P./), word8 * word8 -> word8
! w31mod_8, word31 (P.REM), word8 * word8 -> word8
! w31add_8, word31 (P.+), word8 * word8 -> word8
! w31sub_8, word31 (P.-), word8 * word8 -> word8
! w31orb_8, word31 P.ORB, word8 * word8 -> word8
! w31xorb_8, word31 P.XORB, word8 * word8 -> word8
! w31andb_8, word31 P.ANDB, word8 * word8 -> word8
! w31notb_8, word31 P.NOTB, word8 -> word8
! w31neg_8, word31 P.~, word8 -> word8
! w31rshift_8, word31 P.RSHIFT, word8 * word -> word8
! w31rshiftl_8, word31 P.RSHIFTL, word8 * word -> word8
! w31lshift_8, word31 P.LSHIFT, word8 * word -> word8
! w31gt_8, word31cmp (P.>), word8 * word8 -> bool
! w31ge_8, word31cmp (P.>=), word8 * word8 -> bool
! w31lt_8, word31cmp (P.<), word8 * word8 -> bool
! w31le_8, word31cmp (P.<=), word8 * word8 -> bool
! w31eq_8, word31cmp P.EQL, word8 * word8 -> bool
! w31ne_8, word31cmp P.NEQ, word8 * word8 -> bool
! w31ChkRshift_8, P.INLRSHIFT(P.UINT 31), word8 * word -> word8
! w31ChkRshiftl_8,P.INLRSHIFTL(P.UINT 31),word8 * word -> word8
! w31ChkLshift_8, P.INLLSHIFT(P.UINT 31), word8 * word -> word8
! w31min_8, P.INLMIN (P.UINT 31), word8 * word8 -> word8
! w31max_8, P.INLMAX (P.UINT 31), word8 * word8 -> word8
(*** word32 primops ***)
! w32mul, word32 (P.* ), word32 * word32 -> word32
! w32div, word32 (P./), word32 * word32 -> word32
! w32mod, word32 (P.REM), word32 * word32 -> word32
! w32add, word32 (P.+), word32 * word32 -> word32
! w32sub, word32 (P.-), word32 * word32 -> word32
! w32orb, word32 P.ORB, word32 * word32 -> word32
! w32xorb, word32 P.XORB, word32 * word32 -> word32
! w32andb, word32 P.ANDB, word32 * word32 -> word32
! w32notb, word32 P.NOTB, word32 -> w32
! w32neg, word32 P.~, word32 -> w32
! w32rshift, word32 P.RSHIFT, word32 * word -> word32
! w32rshiftl, word32 P.RSHIFTL, word32 * word -> word32
! w32lshift, word32 P.LSHIFT, word32 * word -> word32
! w32gt, word32cmp (P.>), word32 * word32 -> bool
! w32ge, word32cmp (P.>=), word32 * word32 -> bool
! w32lt, word32cmp (P.<), word32 * word32 -> bool
! w32le, word32cmp (P.<=), word32 * word32 -> bool
! w32eq, word32cmp P.EQL, word32 * word32 -> bool
! w32ne, word32cmp P.NEQ, word32 * word32 -> bool
! w32ChkRshift, P.INLRSHIFT(P.UINT 32), word32 * word -> word32
! w32ChkRshiftl, P.INLRSHIFTL(P.UINT 32),word32 * word -> word32
! w32ChkLshift, P.INLLSHIFT(P.UINT 32), word32 * word -> word32
! w32min, P.INLMIN (P.UINT 32), word32 * word32 -> word32
! w32max, P.INLMAX (P.UINT 32), word32 * word32 -> word32
(* experimental C FFI primops *)
! raww8l, P.RAW_LOAD (P.UINT 8), word32 -> word32
! rawi8l, P.RAW_LOAD (P.INT 8), word32 -> int32
! raww16l, P.RAW_LOAD (P.UINT 16), word32 -> word32
! rawi16l, P.RAW_LOAD (P.INT 16), word32 -> int32
! raww32l, P.RAW_LOAD (P.UINT 32), word32 -> word32
! rawi32l, P.RAW_LOAD (P.INT 32), word32 -> int32
! rawf32l, P.RAW_LOAD (P.FLOAT 32), word32 -> real
! rawf64l, P.RAW_LOAD (P.FLOAT 64), word32 -> real
! raww8s, P.RAW_STORE (P.UINT 8), word32 * word32 -> unit
! rawi8s, P.RAW_STORE (P.INT 8), word32 * int32 -> unit
! raww16s, P.RAW_STORE (P.UINT 16), word32 * word32 -> unit
! rawi16s, P.RAW_STORE (P.INT 16), word32 * int32 -> unit
! raww32s, P.RAW_STORE (P.UINT 32), word32 * word32 -> unit
! rawi32s, P.RAW_STORE (P.INT 32), word32 * int32 -> unit
! rawf32s, P.RAW_STORE (P.FLOAT 32), word32 * real -> unit
! rawf64s, P.RAW_STORE (P.FLOAT 64), word32 * real -> unit
! rawccall, P.RAW_CCALL NONE, word32 * 'a * 'b -> 'c
(* Support for direct construction of C objects on ML heap.
***************
*** 419,440 ****
* rawupdatexxx writes to the record.
*)
! rawrecord, P.RAW_RECORD{fblock = false}, i_x
! rawrecord64, P.RAW_RECORD{fblock = true}, i_x
! rawselectw8, P.RAW_LOAD (P.UINT 8), xw32_w32
! rawselecti8, P.RAW_LOAD (P.INT 8), xw32_i32
! rawselectw16, P.RAW_LOAD (P.UINT 16), xw32_w32
! rawselecti16, P.RAW_LOAD (P.INT 16), xw32_i32
! rawselectw32, P.RAW_LOAD (P.UINT 32), xw32_w32
! rawselecti32, P.RAW_LOAD (P.INT 32), xw32_i32
! rawselectf32, P.RAW_LOAD (P.FLOAT 32), xw32_f64
! rawselectf64, P.RAW_LOAD (P.FLOAT 64), xw32_f64
! rawupdatew8, P.RAW_STORE (P.UINT 8), xw32w32_u
! rawupdatei8, P.RAW_STORE (P.INT 8), xw32i32_u
! rawupdatew16, P.RAW_STORE (P.UINT 16), xw32w32_u
! rawupdatei16, P.RAW_STORE (P.INT 16), xw32i32_u
! rawupdatew32, P.RAW_STORE (P.UINT 32), xw32w32_u
! rawupdatei32, P.RAW_STORE (P.INT 32), xw32i32_u
! rawupdatef32, P.RAW_STORE (P.FLOAT 32), xw32f64_u
! rawupdatef64, P.RAW_STORE (P.FLOAT 64), xw32f64_u
--- 419,440 ----
* rawupdatexxx writes to the record.
*)
! rawrecord, P.RAW_RECORD{fblock = false}, int -> 'a
! rawrecord64, P.RAW_RECORD{fblock = true}, int -> 'a
! rawselectw8, P.RAW_LOAD (P.UINT 8), xw32 -> word32
! rawselecti8, P.RAW_LOAD (P.INT 8), xw32 -> int32
! rawselectw16, P.RAW_LOAD (P.UINT 16), xw32 -> word32
! rawselecti16, P.RAW_LOAD (P.INT 16), xw32 -> int32
! rawselectw32, P.RAW_LOAD (P.UINT 32), xw32 -> word32
! rawselecti32, P.RAW_LOAD (P.INT 32), xw32 -> int32
! rawselectf32, P.RAW_LOAD (P.FLOAT 32), xw32 -> real
! rawselectf64, P.RAW_LOAD (P.FLOAT 64), xw32 -> real
! rawupdatew8, P.RAW_STORE (P.UINT 8), 'a * word32 * word32 -> unit
! rawupdatei8, P.RAW_STORE (P.INT 8), 'a * word32 * int32 -> unit
! rawupdatew16, P.RAW_STORE (P.UINT 16), 'a * word32 * word32 -> unit
! rawupdatei16, P.RAW_STORE (P.INT 16), 'a * word32 * int32 -> unit
! rawupdatew32, P.RAW_STORE (P.UINT 32), 'a * word32 * word32 -> unit
! rawupdatei32, P.RAW_STORE (P.INT 32), 'a * word32 * int32 -> unit
! rawupdatef32, P.RAW_STORE (P.FLOAT 32), 'a * word32 * real -> unit
! rawupdatef64, P.RAW_STORE (P.FLOAT 64), 'a * word32 * real -> unit
Using Tomcat but need to do more? Need to support web services, security?
Get stuff done quickly with pre-integrated technology to make your job easier
Download IBM WebSphere Application Server v.1.0.1 based on Apache Geronimo
http://sel.as-us.falkag.net/sel?cmd=lnk&kid=120709&bid=263057&dat=121642