diff options
Diffstat (limited to '')
41 files changed, 2187 insertions, 542 deletions
diff --git a/stdlib/source/lux/abstract/equivalence.lux b/stdlib/source/lux/abstract/equivalence.lux index d23f37942..eacb4a48f 100644 --- a/stdlib/source/lux/abstract/equivalence.lux +++ b/stdlib/source/lux/abstract/equivalence.lux @@ -35,7 +35,9 @@ (def: (= left right) (sub (rec sub) left right)))) -(structure: #export contravariant (Contravariant Equivalence) +(structure: #export contravariant + (Contravariant Equivalence) + (def: (map-1 f equivalence) (structure (def: (= reference sample) diff --git a/stdlib/source/lux/abstract/monad.lux b/stdlib/source/lux/abstract/monad.lux index f0444a4cf..5aec10012 100644 --- a/stdlib/source/lux/abstract/monad.lux +++ b/stdlib/source/lux/abstract/monad.lux @@ -87,6 +87,13 @@ _ (#.Left "Wrong syntax for 'do'"))) +(def: #export (bind monad f) + (All [! a b] + (-> (Monad !) (-> a (! b)) + (-> (! a) (! b)))) + (|>> (:: monad map f) + (:: monad join))) + (def: #export (seq monad) {#.doc "Run all the monadic values in the list and produce a list of the base values."} (All [M a] diff --git a/stdlib/source/lux/data/format/binary.lux b/stdlib/source/lux/data/format/binary.lux index 03af219a7..81c8ceadd 100644 --- a/stdlib/source/lux/data/format/binary.lux +++ b/stdlib/source/lux/data/format/binary.lux @@ -44,7 +44,8 @@ (-> Specification Binary) (|> size binary.create [0] mutation product.right)) -(structure: #export monoid (Monoid Specification) +(structure: #export monoid + (Monoid Specification) (def: identity ..no-op) diff --git a/stdlib/source/lux/target/jvm/attribute.lux b/stdlib/source/lux/target/jvm/attribute.lux index 236ecf608..5f8892631 100644 --- a/stdlib/source/lux/target/jvm/attribute.lux +++ b/stdlib/source/lux/target/jvm/attribute.lux @@ -4,7 +4,6 @@ [monad (#+ do)] ["." equivalence (#+ Equivalence)]] [control - ["." state (#+ State)] ["." try] ["." exception (#+ exception:)]] [data @@ -18,7 +17,7 @@ [encoding ["#." unsigned (#+ U2 U4)]] ["#." constant (#+ UTF8 Class Value) - ["#/." pool (#+ Pool)]]] + ["#/." pool (#+ Pool Resource)]]] ["." / #_ ["#." constant (#+ Constant)] ["#." code]]) @@ -43,7 +42,7 @@ (Writer (Info about)))) (function (_ [name length info]) (let [[nameS nameT] (//index.writer name) - [lengthS lengthT] (//unsigned.u4-writer length) + [lengthS lengthT] (//unsigned.writer/4 length) [infoS infoT] (writer info)] [($_ n.+ nameS lengthS infoS) (|>> nameT lengthT infoT)]))) @@ -68,9 +67,9 @@ (def: fixed-attribute-length ($_ n.+ ## u2 attribute_name_index; - //unsigned.u2-bytes + //unsigned.bytes/2 ## u4 attribute_length; - //unsigned.u4-bytes + //unsigned.bytes/4 )) (def: (length attribute) @@ -78,7 +77,7 @@ (case attribute (^template [<tag>] (<tag> [name length info]) - (|> length //unsigned.nat .nat (n.+ fixed-attribute-length))) + (|> length //unsigned.value (n.+ fixed-attribute-length))) ([#Constant] [#Code]))) (def: constant-name "ConstantValue") @@ -86,12 +85,12 @@ (def: (constant' @name index) (-> (Index UTF8) Constant Attribute) (#Constant {#name @name - #length (//unsigned.u4 /constant.length) + #length (|> /constant.length //unsigned.u4 try.assume) #info index})) (def: #export (constant index) - (-> Constant (State Pool Attribute)) - (do state.monad + (-> Constant (Resource Attribute)) + (do //constant/pool.monad [@name (//constant/pool.utf8 ..constant-name)] (wrap (constant' @name index)))) @@ -101,13 +100,15 @@ (-> (Index UTF8) Code Attribute) (#Code {#name @name ## https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.3 - #length (//unsigned.u4 - (/code.length ..length specification)) + #length (|> specification + (/code.length ..length) + //unsigned.u4 + try.assume) #info specification})) (def: #export (code specification) - (-> Code (State Pool Attribute)) - (do state.monad + (-> Code (Resource Attribute)) + (do //constant/pool.monad [@name (//constant/pool.utf8 ..code-name)] (wrap (code' @name specification)))) diff --git a/stdlib/source/lux/target/jvm/attribute/code.lux b/stdlib/source/lux/target/jvm/attribute/code.lux index 0bf1bec4e..3a9629c1f 100644 --- a/stdlib/source/lux/target/jvm/attribute/code.lux +++ b/stdlib/source/lux/target/jvm/attribute/code.lux @@ -12,15 +12,16 @@ [collection ["." row (#+ Row) ("#@." functor fold)]]]] ["." /// #_ - [instruction - ["#." resources (#+ Resources)]] + [bytecode + [environment + ["#." limit (#+ Limit)]]] [encoding ["#." unsigned (#+ U2)]]] ["." / #_ ["#." exception (#+ Exception)]]) (type: #export (Code Attribute) - {#resources Resources + {#limit Limit #code Binary #exception-table (Row Exception) #attributes (Row Attribute)}) @@ -30,20 +31,20 @@ ($_ n.+ ## u2 max_stack; ## u2 max_locals; - ///resources.length + ///limit.length ## u4 code_length; - ///unsigned.u4-bytes + ///unsigned.bytes/4 ## u1 code[code_length]; (binary.size (get@ #code code)) ## u2 exception_table_length; - ///unsigned.u2-bytes + ///unsigned.bytes/2 ## exception_table[exception_table_length]; (|> code (get@ #exception-table) row.size (n.* /exception.length)) ## u2 attributes_count; - ///unsigned.u2-bytes + ///unsigned.bytes/2 ## attribute_info attributes[attributes_count]; (|> code (get@ #attributes) @@ -54,7 +55,7 @@ (All [attribute] (-> (Equivalence attribute) (Equivalence (Code attribute)))) ($_ equivalence.product - ///resources.equivalence + ///limit.equivalence binary.equivalence (row.equivalence /exception.equivalence) (row.equivalence attribute-equivalence) @@ -66,7 +67,7 @@ ($_ binaryF@compose ## u2 max_stack; ## u2 max_locals; - (///resources.writer (get@ #resources code)) + (///limit.writer (get@ #limit code)) ## u4 code_length; ## u1 code[code_length]; (binaryF.binary/32 (get@ #code code)) diff --git a/stdlib/source/lux/target/jvm/attribute/code/exception.lux b/stdlib/source/lux/target/jvm/attribute/code/exception.lux index 97fe962e6..820e5c8a6 100644 --- a/stdlib/source/lux/target/jvm/attribute/code/exception.lux +++ b/stdlib/source/lux/target/jvm/attribute/code/exception.lux @@ -5,13 +5,13 @@ [data [number ["n" nat]] - [format - [".F" binary (#+ Writer)]]]] + ["." format #_ + ["#" binary (#+ Writer)]]]] ["." // #_ ["//#" /// #_ [constant (#+ Class)] ["#." index (#+ Index)] - [instruction + [bytecode ["#." address (#+ Address)]] [encoding ["#." unsigned (#+ U2)]]]]) @@ -36,18 +36,18 @@ Nat ($_ n.+ ## u2 start_pc; - ////unsigned.u2-bytes + ////unsigned.bytes/2 ## u2 end_pc; - ////unsigned.u2-bytes + ////unsigned.bytes/2 ## u2 handler_pc; - ////unsigned.u2-bytes + ////unsigned.bytes/2 ## u2 catch_type; - ////unsigned.u2-bytes + ////unsigned.bytes/2 )) (def: #export writer (Writer Exception) - ($_ binaryF.and + ($_ format.and ////address.writer ////address.writer ////address.writer diff --git a/stdlib/source/lux/target/jvm/attribute/constant.lux b/stdlib/source/lux/target/jvm/attribute/constant.lux index debf07abe..0206ed26e 100644 --- a/stdlib/source/lux/target/jvm/attribute/constant.lux +++ b/stdlib/source/lux/target/jvm/attribute/constant.lux @@ -19,7 +19,7 @@ ///index.equivalence) (def: #export length - ///unsigned.u2-bytes) + ///index.length) (def: #export writer (Writer Constant) diff --git a/stdlib/source/lux/target/jvm/bytecode.lux b/stdlib/source/lux/target/jvm/bytecode.lux new file mode 100644 index 000000000..7dc974658 --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode.lux @@ -0,0 +1,823 @@ +(.module: + [lux (#- Type int) + ["." host] + [abstract + [monoid (#+ Monoid)] + ["." monad (#+ Monad do)]] + [control + [writer (#+ Writer)] + ["." state (#+ State')] + ["." function] + ["." try (#+ Try)] + ["." exception (#+ exception:)]] + [data + ["." product] + ["." maybe] + [text + ["%" format (#+ format)]] + [number + ["n" nat] + ["i" int] + ["." i32]] + [collection + ["." list ("#@." functor fold)] + ["." dictionary (#+ Dictionary)] + ["." row (#+ Row)]]] + [macro + ["." template]]] + ["." / #_ + ["#." address (#+ Address)] + ["#." jump (#+ Jump Big-Jump)] + ["_" instruction (#+ Primitive-Array-Type Instruction Estimator) ("#@." monoid)] + ["#." environment (#+ Environment) + [limit + [registry (#+ Register)]]] + ["/#" // #_ + ["#." index (#+ Index)] + [encoding + ["#." name] + ["#." unsigned (#+ U1 U2)] + ["#." signed (#+ S4)]] + ["#." constant (#+ UTF8) + ["#/." pool (#+ Pool Resource)]] + [attribute + [code + ["#." exception (#+ Exception)]]] + ["." type (#+ Type) + [category (#+ Class Object Value' Value Return' Return Method)] + ["." reflection] + ["." parser]]]]) + +(type: #export Label Nat) + +(type: #export Resolver (Dictionary Label Address)) + +(type: #export Tracker + {#program-counter Address + #next Label + #known Resolver}) + +(def: fresh + Tracker + {#program-counter /address.start + #next 0 + #known (dictionary.new n.hash)}) + +(type: #export Relative + (-> Resolver (Try [(Row Exception) Instruction]))) + +(def: no-exceptions + (Row Exception) + row.empty) + +(def: relative-identity + Relative + (function.constant (#try.Success [..no-exceptions _.empty]))) + +(structure: relative-monoid + (Monoid Relative) + + (def: identity ..relative-identity) + + (def: (compose left right) + (cond (is? ..relative-identity left) + right + + (is? ..relative-identity right) + left + + ## else + (function (_ resolver) + (do try.monad + [[left-exceptions left-instruction] (left resolver) + [right-exceptions right-instruction] (right resolver)] + (wrap [(:: row.monoid compose left-exceptions right-exceptions) + (_@compose left-instruction right-instruction)])))))) + +(type: #export (Bytecode a) + (State' Try [Pool Environment Tracker] (Writer Relative a))) + +(def: #export new-label + (Bytecode Label) + (function (_ [pool environment tracker]) + (#try.Success [[pool + environment + (update@ #next inc tracker)] + [..relative-identity + (get@ #next tracker)]]))) + +(exception: #export (label-has-already-been-set {label Label}) + (exception.report + ["Label" (%.nat label)])) + +(def: #export (set-label label) + (-> Label (Bytecode Any)) + (function (_ [pool environment tracker]) + (if (dictionary.contains? label (get@ #known tracker)) + (exception.throw ..label-has-already-been-set [label]) + (#try.Success [[pool + environment + (update@ #known + (dictionary.put label (get@ #program-counter tracker)) + tracker)] + [..relative-identity + []]])))) + +(def: #export monad + (Monad Bytecode) + (:coerce (Monad Bytecode) + (state.with try.monad))) + +(def: #export (resolve bytecode) + (All [a] (-> (Bytecode a) (Resource [Environment (Row Exception) Instruction a]))) + (function (_ pool) + (do try.monad + [[[pool environment tracker] [relative output]] (bytecode [pool /environment.start ..fresh]) + [exceptions instruction] (relative (get@ #known tracker))] + (wrap [pool [environment exceptions instruction output]])))) + +(def: (step estimator counter) + (-> Estimator Address (Try Address)) + (/address.move (estimator counter) counter)) + +(def: (bytecode consumption production last-register [estimator bytecode] input) + (All [a] (-> U2 U2 Register [Estimator (-> [a] Instruction)] [a] (Bytecode Any))) + (function (_ [pool environment tracker]) + (do try.monad + [environment' (|> environment + (/environment.consumes consumption) + (monad.bind @ (/environment.produces production)) + (monad.bind @ (/environment.has last-register))) + program-counter' (step estimator (get@ #program-counter tracker))] + (wrap [[pool + environment' + (set@ #program-counter program-counter' tracker)] + [(function.constant (#try.Success [..no-exceptions (bytecode input)])) + []]])))) + +(template [<name> <frames>] + [(def: <name> U2 (|> <frames> //unsigned.u2 try.assume))] + + [$0 0] + [$1 1] + [$2 2] + [$3 3] + [$4 4] + [$5 5] + [$6 6] + ) + +(template [<name> <registry>] + [(def: <name> Register (|> <registry> //unsigned.u1 try.assume))] + + [@0 0] + [@1 1] + [@2 2] + [@3 3] + [@4 4] + ) + +(template [<name> <consumption> <production> <last-register> <instruction>] + [(def: #export <name> + (Bytecode Any) + (..bytecode <consumption> + <production> + <last-register> + <instruction> + []))] + + [nop $0 $0 @0 _.nop] + + [aconst-null $0 $1 @0 _.aconst-null] + + [iconst-m1 $0 $1 @0 _.iconst-m1] + [iconst-0 $0 $1 @0 _.iconst-0] + [iconst-1 $0 $1 @0 _.iconst-1] + [iconst-2 $0 $1 @0 _.iconst-2] + [iconst-3 $0 $1 @0 _.iconst-3] + [iconst-4 $0 $1 @0 _.iconst-4] + [iconst-5 $0 $1 @0 _.iconst-5] + + [lconst-0 $0 $2 @0 _.lconst-0] + [lconst-1 $0 $2 @0 _.lconst-1] + + [fconst-0 $0 $1 @0 _.fconst-0] + [fconst-1 $0 $1 @0 _.fconst-1] + [fconst-2 $0 $1 @0 _.fconst-2] + + [dconst-0 $0 $2 @0 _.dconst-0] + [dconst-1 $0 $2 @0 _.dconst-1] + + [pop $1 $0 @0 _.pop] + [pop2 $2 $0 @0 _.pop2] + + [dup $1 $2 @0 _.dup] + [dup-x1 $2 $3 @0 _.dup-x1] + [dup-x2 $3 $4 @0 _.dup-x2] + [dup2 $2 $4 @0 _.dup2] + [dup2-x1 $3 $5 @0 _.dup2-x1] + [dup2-x2 $4 $6 @0 _.dup2-x2] + + [swap $2 $2 @0 _.swap] + + [iaload $2 $1 @0 _.iaload] + [laload $2 $2 @0 _.laload] + [faload $2 $1 @0 _.faload] + [daload $2 $2 @0 _.daload] + [aaload $2 $1 @0 _.aaload] + [baload $2 $1 @0 _.baload] + [caload $2 $1 @0 _.caload] + [saload $2 $1 @0 _.saload] + + [iload-0 $0 $1 @0 _.iload-0] + [iload-1 $0 $1 @1 _.iload-1] + [iload-2 $0 $1 @2 _.iload-2] + [iload-3 $0 $1 @3 _.iload-3] + + [lload-0 $0 $2 @1 _.lload-0] + [lload-1 $0 $2 @2 _.lload-1] + [lload-2 $0 $2 @3 _.lload-2] + [lload-3 $0 $2 @4 _.lload-3] + + [fload-0 $0 $1 @0 _.fload-0] + [fload-1 $0 $1 @1 _.fload-1] + [fload-2 $0 $1 @2 _.fload-2] + [fload-3 $0 $1 @3 _.fload-3] + + [dload-0 $0 $2 @1 _.dload-0] + [dload-1 $0 $2 @2 _.dload-1] + [dload-2 $0 $2 @3 _.dload-2] + [dload-3 $0 $2 @4 _.dload-3] + + [aload-0 $0 $1 @0 _.aload-0] + [aload-1 $0 $1 @1 _.aload-1] + [aload-2 $0 $1 @2 _.aload-2] + [aload-3 $0 $1 @3 _.aload-3] + + [iastore $3 $1 @0 _.iastore] + [lastore $4 $1 @0 _.lastore] + [fastore $3 $1 @0 _.fastore] + [dastore $4 $1 @0 _.dastore] + [aastore $3 $1 @0 _.aastore] + [bastore $3 $1 @0 _.bastore] + [castore $3 $1 @0 _.castore] + [sastore $3 $1 @0 _.sastore] + + [istore-0 $1 $0 @0 _.istore-0] + [istore-1 $1 $0 @1 _.istore-1] + [istore-2 $1 $0 @2 _.istore-2] + [istore-3 $1 $0 @3 _.istore-3] + + [lstore-0 $2 $0 @1 _.lstore-0] + [lstore-1 $2 $0 @2 _.lstore-1] + [lstore-2 $2 $0 @3 _.lstore-2] + [lstore-3 $2 $0 @4 _.lstore-3] + + [fstore-0 $1 $0 @0 _.fstore-0] + [fstore-1 $1 $0 @1 _.fstore-1] + [fstore-2 $1 $0 @2 _.fstore-2] + [fstore-3 $1 $0 @3 _.fstore-3] + + [dstore-0 $2 $0 @1 _.dstore-0] + [dstore-1 $2 $0 @2 _.dstore-1] + [dstore-2 $2 $0 @3 _.dstore-2] + [dstore-3 $2 $0 @4 _.dstore-3] + + [astore-0 $1 $0 @0 _.astore-0] + [astore-1 $1 $0 @1 _.astore-1] + [astore-2 $1 $0 @2 _.astore-2] + [astore-3 $1 $0 @3 _.astore-3] + + [iadd $2 $1 @0 _.iadd] + [isub $2 $1 @0 _.isub] + [imul $2 $1 @0 _.imul] + [idiv $2 $1 @0 _.idiv] + [irem $2 $1 @0 _.irem] + [ineg $2 $1 @0 _.ineg] + [ishl $2 $1 @0 _.ishl] + [ishr $2 $1 @0 _.ishr] + [iushr $2 $1 @0 _.iushr] + [iand $2 $1 @0 _.iand] + [ior $2 $1 @0 _.ior] + [ixor $2 $1 @0 _.ixor] + + [ladd $4 $2 @0 _.ladd] + [lsub $4 $2 @0 _.lsub] + [lmul $4 $2 @0 _.lmul] + [ldiv $4 $2 @0 _.ldiv] + [lrem $4 $2 @0 _.lrem] + [lneg $4 $2 @0 _.lneg] + [land $4 $2 @0 _.land] + [lor $4 $2 @0 _.lor] + [lxor $4 $2 @0 _.lxor] + [lshl $3 $2 @0 _.lshl] + [lshr $3 $2 @0 _.lshr] + [lushr $3 $2 @0 _.lushr] + + [fadd $2 $1 @0 _.fadd] + [fsub $2 $1 @0 _.fsub] + [fmul $2 $1 @0 _.fmul] + [fdiv $2 $1 @0 _.fdiv] + [frem $2 $1 @0 _.frem] + [fneg $2 $1 @0 _.fneg] + + [dadd $4 $2 @0 _.dadd] + [dsub $4 $2 @0 _.dsub] + [dmul $4 $2 @0 _.dmul] + [ddiv $4 $2 @0 _.ddiv] + [drem $4 $2 @0 _.drem] + [dneg $4 $2 @0 _.dneg] + + [l2i $2 $1 @0 _.l2i] + [l2f $2 $1 @0 _.l2f] + [l2d $2 $2 @0 _.l2d] + + [f2i $1 $1 @0 _.f2i] + [f2l $1 $2 @0 _.f2l] + [f2d $1 $2 @0 _.f2d] + + [d2i $2 $1 @0 _.d2i] + [d2l $2 $2 @0 _.d2l] + [d2f $2 $1 @0 _.d2f] + + [i2l $1 $2 @0 _.i2l] + [i2f $1 $1 @0 _.i2f] + [i2d $1 $2 @0 _.i2d] + [i2b $1 $1 @0 _.i2b] + [i2c $1 $1 @0 _.i2c] + [i2s $1 $1 @0 _.i2s] + + [lcmp $4 $1 @0 _.lcmp] + + [fcmpl $2 $1 @0 _.fcmpl] + [fcmpg $2 $1 @0 _.fcmpg] + + [dcmpl $4 $1 @0 _.dcmpl] + [dcmpg $4 $1 @0 _.dcmpg] + + [ireturn $1 $0 @0 _.ireturn] + [lreturn $2 $0 @0 _.lreturn] + [freturn $1 $0 @0 _.freturn] + [dreturn $2 $0 @0 _.dreturn] + [areturn $1 $0 @0 _.areturn] + [return $0 $0 @0 _.return] + + [arraylength $1 $1 @0 _.arraylength] + + [athrow $1 $0 @0 _.athrow] + + [monitorenter $1 $0 @0 _.monitorenter] + [monitorexit $1 $0 @0 _.monitorexit] + ) + +(def: #export (bipush byte) + (-> U1 (Bytecode Any)) + (..bytecode $0 $1 @0 _.bipush [byte])) + +(def: (lift resource) + (All [a] + (-> (Resource a) + (Bytecode a))) + (function (_ [pool environment tracker]) + (do try.monad + [[pool' output] (resource pool)] + (wrap [[pool' environment tracker] + [..relative-identity + output]])))) + +(def: #export (string value) + (-> //constant.UTF8 (Bytecode Any)) + (do ..monad + [index (..lift (//constant/pool.string value))] + (case (|> index //index.value //unsigned.value //unsigned.u1) + (#try.Success index) + (..bytecode $0 $1 @0 _.ldc [index]) + + (#try.Failure _) + (..bytecode $0 $1 @0 _.ldc-w/string [index])))) + +(template [<size> <name> <type> <constant> <ldc> <to-lux> <specializations>] + [(def: #export (<name> value) + (-> <type> (Bytecode Any)) + (case (|> value //constant.value <to-lux>) + (^template [<special> <instruction>] + <special> (..bytecode $0 <size> @0 <instruction> [])) + <specializations> + + _ (do ..monad + [index (..lift (<constant> value))] + (..bytecode $0 <size> @0 <ldc> [index]))))] + + [$1 int //constant.Integer //constant/pool.integer _.ldc-w/integer + (<| .int i32.i64) + ([-1 _.iconst-m1] + [+0 _.iconst-0] + [+1 _.iconst-1] + [+2 _.iconst-2] + [+3 _.iconst-3] + [+4 _.iconst-4] + [+5 _.iconst-5])] + [$2 long //constant.Long //constant/pool.long _.ldc2-w/long + (<|) + ([+0 _.lconst-0] + [+1 _.lconst-1])] + [$1 float //constant.Float //constant/pool.float _.ldc-w/float + (<| host.float-to-double) + ([+0.0 _.fconst-0] + [+1.0 _.fconst-1] + [+2.0 _.fconst-2])] + [$2 double //constant.Double //constant/pool.double _.ldc2-w/double + (<|) + ([+0.0 _.fconst-0] + [+1.0 _.fconst-1])] + ) + +(template [<size> <name> <general> <specials>] + [(def: #export (<name> local) + (-> Register (Bytecode Any)) + (with-expansions [<specials>' (template.splice <specials>)] + (`` (case (//unsigned.value local) + (~~ (template [<case> <instruction> <last-register>] + [<case> (..bytecode $0 <size> <last-register> <instruction> [])] + + <specials>')) + _ (..bytecode $0 <size> local <general> [local])))))] + + [$1 iload _.iload + [[0 _.iload-0 @0] + [1 _.iload-1 @1] + [2 _.iload-2 @2] + [3 _.iload-3 @3]]] + [$2 lload _.lload + [[0 _.lload-0 @1] + [1 _.lload-1 @2] + [2 _.lload-2 @3] + [3 _.lload-3 @4]]] + [$1 fload _.fload + [[0 _.fload-0 @0] + [1 _.fload-1 @1] + [2 _.fload-2 @2] + [3 _.fload-3 @3]]] + [$2 dload _.dload + [[0 _.dload-0 @1] + [1 _.dload-1 @2] + [2 _.dload-2 @3] + [3 _.dload-3 @4]]] + [$1 aload _.aload + [[0 _.aload-0 @0] + [1 _.aload-1 @1] + [2 _.aload-2 @2] + [3 _.aload-3 @3]]] + ) + +(template [<size> <name> <general> <specials>] + [(def: #export (<name> local) + (-> Register (Bytecode Any)) + (with-expansions [<specials>' (template.splice <specials>)] + (`` (case (//unsigned.value local) + (~~ (template [<case> <instruction> <last-register>] + [<case> (..bytecode <size> $0 <last-register> <instruction> [])] + + <specials>')) + _ (..bytecode <size> $0 local <general> [local])))))] + + [$1 istore _.istore + [[0 _.istore-0 @0] + [1 _.istore-1 @1] + [2 _.istore-2 @2] + [3 _.istore-3 @3]]] + [$2 lstore _.lstore + [[0 _.lstore-0 @1] + [1 _.lstore-1 @2] + [2 _.lstore-2 @3] + [3 _.lstore-3 @4]]] + [$1 fstore _.fstore + [[0 _.fstore-0 @0] + [1 _.fstore-1 @1] + [2 _.fstore-2 @2] + [3 _.fstore-3 @3]]] + [$2 dstore _.dstore + [[0 _.dstore-0 @1] + [1 _.dstore-1 @2] + [2 _.dstore-2 @3] + [3 _.dstore-3 @4]]] + [$1 astore _.astore + [[0 _.astore-0 @0] + [1 _.astore-1 @1] + [2 _.astore-2 @2] + [3 _.astore-3 @3]]] + ) + +(template [<consumption> <production> <name> <instruction> <input>] + [(def: #export <name> + (-> <input> (Bytecode Any)) + (..bytecode <consumption> <production> @0 <instruction>))] + + [$0 $0 ret _.ret Register] + [$1 $1 newarray _.newarray Primitive-Array-Type] + [$0 $1 sipush _.sipush U2] + ) + +(exception: #export (unknown-label {label Label}) + (exception.report + ["Label" (%.nat label)])) + +(exception: #export (cannot-do-a-big-jump {label Label} + {@from Address} + {jump Big-Jump}) + (exception.report + ["Label" (%.nat label)] + ["Start" (|> @from /address.value //unsigned.value %.nat)] + ["Target" (|> jump //signed.value %.int)])) + +(type: Any-Jump (Either Big-Jump Jump)) + +(def: (jump @from @to) + (-> Address Address (Try Any-Jump)) + (do try.monad + [jump (:: @ map //signed.value + (/address.jump @from @to))] + (let [big? (n.> (//unsigned.value //unsigned.maximum/2) + (.nat (i.* (if (i.>= +0 jump) + +1 + -1) + jump)))] + (if big? + (:: @ map (|>> #.Left) (//signed.s4 jump)) + (:: @ map (|>> #.Right) (//signed.s2 jump)))))) + +(def: (resolve-label label resolver) + (-> Label Resolver (Try Address)) + (case (dictionary.get label resolver) + (#.Some address) + (#try.Success address) + + #.None + (exception.throw ..unknown-label [label]))) + +(template [<consumption> <name> <instruction>] + [(def: #export (<name> label) + (-> Label (Bytecode Any)) + (let [[estimator bytecode] <instruction>] + (function (_ [pool environment tracker]) + (do try.monad + [environment' (|> environment + (/environment.consumes <consumption>)) + program-counter' (step estimator (get@ #program-counter tracker))] + (wrap (let [@from (get@ #program-counter tracker)] + [[pool environment' (set@ #program-counter program-counter' tracker)] + [(function (_ resolver) + (do try.monad + [@to (..resolve-label label resolver) + jump (..jump @from @to)] + (case jump + (#.Left jump) + (exception.throw ..cannot-do-a-big-jump [label @from jump]) + + (#.Right jump) + (#try.Success [..no-exceptions (bytecode jump)])))) + []]]))))))] + + [$1 ifeq _.ifeq] + [$1 ifne _.ifne] + [$1 iflt _.iflt] + [$1 ifge _.ifge] + [$1 ifgt _.ifgt] + [$1 ifle _.ifle] + + [$2 if-icmpeq _.if-icmpeq] + [$2 if-icmpne _.if-icmpne] + [$2 if-icmplt _.if-icmplt] + [$2 if-icmpge _.if-icmpge] + [$2 if-icmpgt _.if-icmpgt] + [$2 if-icmple _.if-icmple] + + [$2 if-acmpeq _.if-acmpeq] + [$2 if-acmpne _.if-acmpne] + + [$1 ifnull _.ifnull] + [$1 ifnonnull _.ifnonnull] + ) + +(template [<production> <name> <bytecode>] + [(def: #export (<name> label) + (-> Label (Bytecode Any)) + (let [[estimator bytecode] <bytecode>] + (function (_ [pool environment tracker]) + (do try.monad + [environment' (|> environment + (/environment.produces <production>)) + program-counter' (step estimator (get@ #program-counter tracker))] + (wrap (let [@from (get@ #program-counter tracker)] + [[pool environment' (set@ #program-counter program-counter' tracker)] + [(function (_ resolver) + (case (dictionary.get label resolver) + (#.Some @to) + (do try.monad + [jump (..jump @from @to)] + (case jump + (#.Left jump) + (exception.throw ..cannot-do-a-big-jump [label @from jump]) + + (#.Right jump) + (#try.Success [..no-exceptions (bytecode jump)]))) + + #.None + (exception.throw ..unknown-label [label]))) + []]]))))))] + + [$0 goto _.goto] + [$1 jsr _.jsr] + ) + +(def: (big-jump jump) + (-> Any-Jump Big-Jump) + (case jump + (#.Left big) + big + + (#.Right small) + (/jump.lift small))) + +(exception: #export invalid-tableswitch) + +(def: #export (tableswitch minimum default cases) + (-> S4 Label (List Label) (Bytecode Any)) + (let [[estimator bytecode] _.tableswitch] + (function (_ [pool environment tracker]) + (do try.monad + [environment' (|> environment + (/environment.consumes $1)) + program-counter' (step (estimator (list.size cases)) (get@ #program-counter tracker))] + (wrap (let [@from (get@ #program-counter tracker)] + [[pool environment' (set@ #program-counter program-counter' tracker)] + [(function (_ resolver) + (let [get (: (-> Label (Maybe Address)) + (function (_ label) + (dictionary.get label resolver)))] + (case (do maybe.monad + [@default (get default) + @cases (monad.map @ get cases)] + (wrap [@default @cases])) + (#.Some [@default @cases]) + (do try.monad + [>default (:: @ map ..big-jump (..jump @from @default)) + >cases (monad.map @ (|>> (..jump @from) (:: @ map ..big-jump)) + @cases)] + (#try.Success [..no-exceptions (bytecode minimum >default >cases)])) + + #.None + (exception.throw ..invalid-tableswitch [])))) + []]])))))) + +(exception: #export invalid-lookupswitch) + +(def: #export (lookupswitch default cases) + (-> Label (List [S4 Label]) (Bytecode Any)) + (let [[estimator bytecode] _.lookupswitch] + (function (_ [pool environment tracker]) + (do try.monad + [environment' (|> environment + (/environment.consumes $1)) + program-counter' (step (estimator (list.size cases)) (get@ #program-counter tracker))] + (wrap (let [@from (get@ #program-counter tracker)] + [[pool environment' (set@ #program-counter program-counter' tracker)] + [(function (_ resolver) + (let [get (: (-> Label (Maybe Address)) + (function (_ label) + (dictionary.get label resolver)))] + (case (do maybe.monad + [@default (get default) + @cases (monad.map @ (|>> product.right get) cases)] + (wrap [@default @cases])) + (#.Some [@default @cases]) + (do try.monad + [>default (:: @ map ..big-jump (..jump @from @default)) + >cases (|> @cases + (monad.map @ (|>> (..jump @from) (:: @ map ..big-jump))) + (:: @ map (|>> (list.zip2 (list@map product.left cases)))))] + (#try.Success [..no-exceptions (bytecode >default >cases)])) + + #.None + (exception.throw ..invalid-lookupswitch [])))) + []]])))))) + +(def: reflection + (All [category] + (-> (Type (<| Return' Value' category)) Text)) + (|>> type.reflection reflection.reflection)) + +(template [<consumption> <production> <name> <category> <instruction>] + [(def: #export (<name> class) + (-> (Type <category>) (Bytecode Any)) + (do ..monad + ## TODO: Make sure it's impossible to have indexes greater than U2. + [index (..lift (//constant/pool.class (//name.internal (..reflection class))))] + (..bytecode <consumption> <production> @0 <instruction> [index])))] + + [$0 $1 new Class _.new] + [$1 $1 anewarray Object _.anewarray] + [$1 $1 checkcast Object _.checkcast] + [$1 $1 instanceof Object _.instanceof] + ) + +(def: #export (iinc register increase) + (-> Register U1 (Bytecode Any)) + (..bytecode $0 $0 register _.iinc [register increase])) + +(def: #export (multianewarray class dimensions) + (-> (Type Class) U1 (Bytecode Any)) + (do ..monad + [index (..lift (//constant/pool.class (//name.internal (..reflection class))))] + (..bytecode (//unsigned.lift/2 dimensions) $1 @0 _.multianewarray [index dimensions]))) + +(def: (type-size type) + (-> (Type Return) Nat) + (cond (is? type.void type) + 0 + + (or (is? type.long type) + (is? type.double type)) + 2 + + ## else + 1)) + +(template [<static?> <name> <instruction>] + [(def: #export (<name> class method type) + (-> (Type Class) Text (Type Method) (Bytecode Any)) + (let [[inputs output exceptions] (parser.method type)] + (do ..monad + [index (<| ..lift + (//constant/pool.method (..reflection class)) + {#//constant/pool.name method + #//constant/pool.descriptor (type.descriptor type)}) + #let [consumption (|> inputs + (list@map ..type-size) + (list@fold n.+ (if <static?> 0 1)) + //unsigned.u1 + try.assume) + production (|> output ..type-size //unsigned.u1 try.assume)]] + (..bytecode (//unsigned.lift/2 consumption) + (//unsigned.lift/2 production) + @0 + <instruction> [index consumption production]))))] + + [#1 invokestatic _.invokestatic] + [#0 invokevirtual _.invokevirtual] + [#0 invokespecial _.invokespecial] + [#0 invokeinterface _.invokeinterface] + ) + +(template [<consumption> <name> <1> <2>] + [(def: #export (<name> class field type) + (-> (Type Class) Text (Type Value) (Bytecode Any)) + (do ..monad + [index (<| ..lift + (//constant/pool.field (..reflection class)) + {#//constant/pool.name field + #//constant/pool.descriptor (type.descriptor type)})] + (if (or (is? type.long type) + (is? type.double type)) + (..bytecode <consumption> $2 @0 <2> [index]) + (..bytecode <consumption> $1 @0 <1> [index]))))] + + [$0 getstatic _.getstatic/1 _.getstatic/2] + [$1 putstatic _.putstatic/1 _.putstatic/2] + [$1 getfield _.getfield/1 _.getfield/2] + [$2 putfield _.putfield/1 _.putfield/2] + ) + +(exception: #export (invalid-range-for-try {start Address} {end Address}) + (exception.report + ["Start" (|> start /address.value //unsigned.value %.nat)] + ["End" (|> end /address.value //unsigned.value %.nat)])) + +(def: #export (try @start @end @handler catch) + (-> Label Label Label (Type Class) (Bytecode Any)) + (do ..monad + [@catch (..lift (//constant/pool.class (//name.internal (..reflection catch))))] + (function (_ [pool environment tracker]) + (#try.Success + [[pool environment tracker] + [(function (_ resolver) + (do try.monad + [@start (..resolve-label @start resolver) + @end (..resolve-label @end resolver) + _ (if (/address.after? @start @end) + (wrap []) + (exception.throw ..invalid-range-for-try [@start @end])) + @handler (..resolve-label @handler resolver)] + (wrap [(row.row {#//exception.start @start + #//exception.end @end + #//exception.handler @handler + #//exception.catch @catch}) + _.empty]))) + []]])))) + +(def: #export (compose pre post) + (All [pre post] + (-> (Bytecode pre) (Bytecode post) (Bytecode post))) + (do ..monad + [_ pre] + post)) diff --git a/stdlib/source/lux/target/jvm/bytecode/address.lux b/stdlib/source/lux/target/jvm/bytecode/address.lux new file mode 100644 index 000000000..4b58b1ca1 --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode/address.lux @@ -0,0 +1,68 @@ +(.module: + [lux #* + [abstract + [equivalence (#+ Equivalence)] + [monad (#+ do)]] + [control + ["." try (#+ Try)]] + [data + [format + [binary (#+ Writer)]] + [number + ["n" nat]]] + [type + abstract]] + ["." // #_ + [jump (#+ Big-Jump)] + ["/#" // #_ + [encoding + ["#." unsigned (#+ U2)] + ["#." signed (#+ S4)]]]]) + +(abstract: #export Address + {} + + U2 + + (def: #export value + (-> Address U2) + (|>> :representation)) + + (def: #export start + Address + (|> 0 ///unsigned.u2 try.assume :abstraction)) + + (def: #export (move distance) + (-> U2 (-> Address (Try Address))) + (|>> :representation + (///unsigned.+/2 distance) + (:: try.functor map (|>> :abstraction)))) + + (def: with-sign + (-> Address (Try S4)) + (|>> :representation ///unsigned.value .int ///signed.s4)) + + (def: #export (jump from to) + (-> Address Address (Try Big-Jump)) + (do try.monad + [from (with-sign from) + to (with-sign to)] + (///signed.-/4 from to))) + + (def: #export (after? reference subject) + (-> Address Address Bit) + (n.> (|> reference :representation ///unsigned.value) + (|> subject :representation ///unsigned.value))) + + (structure: #export equivalence + (Equivalence Address) + + (def: (= reference subject) + (:: ///unsigned.equivalence = + (:representation reference) + (:representation subject)))) + + (def: #export writer + (Writer Address) + (|>> :representation ///unsigned.writer/2)) + ) diff --git a/stdlib/source/lux/target/jvm/bytecode/environment.lux b/stdlib/source/lux/target/jvm/bytecode/environment.lux new file mode 100644 index 000000000..9056b0911 --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode/environment.lux @@ -0,0 +1,63 @@ +(.module: + [lux #* + [abstract + [monad (#+ do)] + [monoid (#+ Monoid)]] + [control + ["." try (#+ Try)]]] + [/ + ["/." limit (#+ Limit) + ["/." stack (#+ Stack)] + ["/." registry (#+ Register)]] + [/// + [encoding + [unsigned (#+ U2)]]]]) + +(type: #export Environment + {#limit Limit + #stack Stack}) + +(def: #export start + Environment + {#limit /limit.start + #stack /stack.empty}) + +(type: #export Condition + (-> Environment (Try Environment))) + +(structure: #export monoid + (Monoid Condition) + + (def: identity (|>> #try.Success)) + + (def: (compose left right) + (function (_ environment) + (do try.monad + [environment (left environment)] + (right environment))))) + +(def: #export (consumes amount) + (-> U2 Condition) + ## TODO: Revisit this definition once lenses/optics have been implemented, + ## since it can probably be simplified with them. + (function (_ environment) + (do try.monad + [stack' (/stack.pop amount (get@ #..stack environment))] + (wrap (set@ #..stack stack' environment))))) + +(def: #export (produces amount) + (-> U2 Condition) + (function (_ environment) + (do try.monad + [current (/stack.push amount (get@ #..stack environment)) + #let [limit (|> environment + (get@ [#..limit #/limit.stack]) + (/stack.max current))]] + (wrap (|> environment + (set@ #..stack current) + (set@ [#..limit #/limit.stack] limit)))))) + +(def: #export (has register) + (-> Register Condition) + (|>> (update@ [#..limit #/limit.registry] (/registry.has register)) + #try.Success)) diff --git a/stdlib/source/lux/target/jvm/bytecode/environment/limit.lux b/stdlib/source/lux/target/jvm/bytecode/environment/limit.lux new file mode 100644 index 000000000..2e2312fb5 --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode/environment/limit.lux @@ -0,0 +1,42 @@ +(.module: + [lux #* + [abstract + ["." equivalence (#+ Equivalence)]] + [data + [number + ["n" nat]] + ["." format #_ + ["#" binary (#+ Writer) ("#@." monoid)]]]] + ["." / #_ + ["#." stack (#+ Stack)] + ["#." registry (#+ Registry)]]) + +(type: #export Limit + {#stack Stack + #registry Registry}) + +(def: #export start + Limit + {#stack /stack.empty + #registry /registry.empty}) + +(def: #export length + ($_ n.+ + ## u2 max_stack; + /stack.length + ## u2 max_locals; + /registry.length)) + +(def: #export equivalence + (Equivalence Limit) + ($_ equivalence.product + /stack.equivalence + /registry.equivalence + )) + +(def: #export (writer limit) + (Writer Limit) + ($_ format@compose + (/stack.writer (get@ #stack limit)) + (/registry.writer (get@ #registry limit)) + )) diff --git a/stdlib/source/lux/target/jvm/bytecode/environment/limit/registry.lux b/stdlib/source/lux/target/jvm/bytecode/environment/limit/registry.lux new file mode 100644 index 000000000..c04f6fa15 --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode/environment/limit/registry.lux @@ -0,0 +1,44 @@ +(.module: + [lux #* + [abstract + ["." equivalence (#+ Equivalence)]] + [data + ["." maybe] + [format + [binary (#+ Writer)]]] + [type + abstract]] + ["." ///// #_ + [encoding + ["#." unsigned (#+ U1 U2)]]]) + +(type: #export Register U1) + +(abstract: #export Registry + {} + + U2 + + (def: #export empty + Registry + (|> 0 /////unsigned.u2 maybe.assume :abstraction)) + + (def: #export equivalence + (Equivalence Registry) + (:: equivalence.contravariant map-1 + (|>> :representation) + /////unsigned.equivalence)) + + (def: #export writer + (Writer Registry) + (|>> :representation /////unsigned.writer/2)) + + (def: #export (has register) + (-> Register (-> Registry Registry)) + (|>> :representation + (/////unsigned.max/2 (/////unsigned.lift/2 register)) + :abstraction)) + ) + +(def: #export length + /////unsigned.bytes/2) diff --git a/stdlib/source/lux/target/jvm/bytecode/environment/limit/stack.lux b/stdlib/source/lux/target/jvm/bytecode/environment/limit/stack.lux new file mode 100644 index 000000000..87ad6a31b --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode/environment/limit/stack.lux @@ -0,0 +1,59 @@ +(.module: + [lux #* + [abstract + ["." equivalence (#+ Equivalence)]] + [control + ["." try (#+ Try)]] + [data + ["." maybe] + [format + [binary (#+ Writer)]]] + [type + abstract]] + ["." ///// #_ + [encoding + ["#." unsigned (#+ U2)]]]) + +(abstract: #export Stack + {} + + U2 + + (def: #export empty + Stack + (|> 0 /////unsigned.u2 maybe.assume :abstraction)) + + (def: #export equivalence + (Equivalence Stack) + (:: equivalence.contravariant map-1 + (|>> :representation) + /////unsigned.equivalence)) + + (def: #export writer + (Writer Stack) + (|>> :representation /////unsigned.writer/2)) + + (def: stack + (-> U2 Stack) + (|>> :abstraction)) + + (template [<op> <name>] + [(def: #export (<name> amount) + (-> U2 (-> Stack (Try Stack))) + (|>> :representation + (<op> amount) + (:: try.functor map ..stack)))] + + [/////unsigned.+/2 push] + [/////unsigned.-/2 pop] + ) + + (def: #export (max left right) + (-> Stack Stack Stack) + (:abstraction + (/////unsigned.max/2 (:representation left) + (:representation right)))) + ) + +(def: #export length + /////unsigned.bytes/2) diff --git a/stdlib/source/lux/target/jvm/bytecode/instruction.lux b/stdlib/source/lux/target/jvm/bytecode/instruction.lux new file mode 100644 index 000000000..0a80b067c --- /dev/null +++ b/stdlib/source/lux/target/jvm/bytecode/instruction.lux @@ -0,0 +1,685 @@ +(.module: + [lux #* + [abstract + [monad (#+ do)] + [monoid (#+ Monoid)]] + [control + ["." function] + ["." try]] + [data + ["." product] + ["." binary] + [number (#+ hex) + ["n" nat]] + [format + [".F" binary (#+ Mutation Specification)]] + [collection + ["." list]]] + [macro + ["." template]] + [type + abstract]] + ["." // #_ + ["#." address (#+ Address)] + ["#." jump (#+ Jump Big-Jump)] + [environment + [limit + [registry (#+ Register)]]] + ["/#" // #_ + ["#." index (#+ Index)] + ["#." constant (#+ Class Reference)] + [encoding + ["#." unsigned (#+ U1 U2 U4)] + ["#." signed (#+ S4)]] + [type + [category (#+ Value Method)]]]]) + +(type: #export Size U2) + +(type: #export Estimator + (-> Address Size)) + +(def: fixed + (-> Size Estimator) + function.constant) + +(type: #export Instruction + (-> Specification Specification)) + +(def: #export empty + Instruction + function.identity) + +(def: #export run + (-> Instruction Specification) + (function.apply binaryF.no-op)) + +(type: Opcode Nat) + +(template [<name> <size>] + [(def: <name> Size (|> <size> ///unsigned.u2 try.assume))] + + [opcode-size 1] + [register-size 1] + [byte-size 1] + [index-size 2] + [big-jump-size 4] + [integer-size 4] + ) + +(def: (nullary' opcode) + (-> Opcode Mutation) + (function (_ [offset binary]) + [(n.+ (///unsigned.value ..opcode-size) + offset) + (try.assume + (binary.write/8 offset opcode binary))])) + +(def: nullary + [Estimator (-> Opcode Instruction)] + [(..fixed ..opcode-size) + (function (_ opcode [size mutation]) + [(n.+ (///unsigned.value ..opcode-size) + size) + (|>> mutation ((nullary' opcode)))])]) + +(template [<name> <size>] + [(def: <name> + Size + (|> ..opcode-size + (///unsigned.+/2 <size>) try.assume))] + + [size/1 ..register-size] + [size/2 ..index-size] + [size/4 ..big-jump-size] + ) + +(template [<shift> <name> <inputT> <writer> <unwrap>] + [(with-expansions [<private> (template.identifier [<name> "'"])] + (def: (<private> opcode input0) + (-> Opcode <inputT> Mutation) + (function (_ [offset binary]) + [(n.+ (///unsigned.value <shift>) offset) + (try.assume + (do try.monad + [_ (binary.write/8 offset opcode binary)] + (<writer> (n.+ (///unsigned.value ..opcode-size) offset) + (<unwrap> input0) + binary)))])) + + (def: <name> + [Estimator (-> Opcode <inputT> Instruction)] + [(..fixed <shift>) + (function (_ opcode input0 [size mutation]) + [(n.+ (///unsigned.value <shift>) size) + (|>> mutation ((<private> opcode input0)))])]))] + + [..size/1 unary/1 U1 binary.write/8 ///unsigned.value] + [..size/2 unary/2 U2 binary.write/16 ///unsigned.value] + [..size/2 jump/2 Jump binary.write/16 ///signed.value] + [..size/4 jump/4 Big-Jump binary.write/32 ///signed.value] + ) + +(def: size/11 + Size + (|> ..opcode-size + (///unsigned.+/2 ..register-size) try.assume + (///unsigned.+/2 ..byte-size) try.assume)) + +(def: (binary/11' opcode input0 input1) + (-> Opcode U1 U1 Mutation) + (function (_ [offset binary]) + [(n.+ (///unsigned.value ..size/11) offset) + (try.assume + (do try.monad + [_ (binary.write/8 offset opcode binary) + _ (binary.write/8 (n.+ (///unsigned.value ..opcode-size) offset) + (///unsigned.value input0) + binary)] + (binary.write/8 (n.+ (///unsigned.value ..size/1) offset) + (///unsigned.value input1) + binary)))])) + +(def: binary/11 + [Estimator (-> Opcode U1 U1 Instruction)] + [(..fixed ..size/11) + (function (_ opcode input0 input1 [size mutation]) + [(n.+ (///unsigned.value ..size/11) size) + (|>> mutation ((binary/11' opcode input0 input1)))])]) + +(def: size/21 + Size + (|> ..opcode-size + (///unsigned.+/2 ..index-size) try.assume + (///unsigned.+/2 ..byte-size) try.assume)) + +(def: (binary/21' opcode input0 input1) + (-> Opcode U2 U1 Mutation) + (function (_ [offset binary]) + [(n.+ (///unsigned.value ..size/21) offset) + (try.assume + (do try.monad + [_ (binary.write/8 offset opcode binary) + _ (binary.write/16 (n.+ (///unsigned.value ..opcode-size) offset) + (///unsigned.value input0) + binary)] + (binary.write/8 (n.+ (///unsigned.value ..size/2) offset) + (///unsigned.value input1) + binary)))])) + +(def: binary/21 + [Estimator (-> Opcode U2 U1 Instruction)] + [(..fixed ..size/21) + (function (_ opcode input0 input1 [size mutation]) + [(n.+ (///unsigned.value ..size/21) size) + (|>> mutation ((binary/21' opcode input0 input1)))])]) + +(def: size/211 + Size + (|> ..opcode-size + (///unsigned.+/2 ..index-size) try.assume + (///unsigned.+/2 ..byte-size) try.assume + (///unsigned.+/2 ..byte-size) try.assume)) + +(def: (trinary/211' opcode input0 input1 input2) + (-> Opcode U2 U1 U1 Mutation) + (function (_ [offset binary]) + [(n.+ (///unsigned.value ..size/211) offset) + (try.assume + (do try.monad + [_ (binary.write/8 offset opcode binary) + _ (binary.write/16 (n.+ (///unsigned.value ..opcode-size) offset) + (///unsigned.value input0) + binary) + _ (binary.write/8 (n.+ (///unsigned.value ..size/2) offset) + (///unsigned.value input1) + binary)] + (binary.write/8 (n.+ (///unsigned.value ..size/21) offset) + (///unsigned.value input2) + binary)))])) + +(def: trinary/211 + [Estimator (-> Opcode U2 U1 U1 Instruction)] + [(..fixed ..size/211) + (function (_ opcode input0 input1 input2 [size mutation]) + [(n.+ (///unsigned.value ..size/211) size) + (|>> mutation ((trinary/211' opcode input0 input1 input2)))])]) + +(abstract: #export Primitive-Array-Type + {} + + U1 + + (def: code + (-> Primitive-Array-Type U1) + (|>> :representation)) + + (template [<code> <name>] + [(def: #export <name> (|> <code> ///unsigned.u1 try.assume :abstraction))] + + [04 t-boolean] + [05 t-char] + [06 t-float] + [07 t-double] + [08 t-byte] + [09 t-short] + [10 t-int] + [11 t-long] + )) + +## https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5 +(with-expansions [<constants> (template [<code> <name>] + [[<code> <name> [] []]] + + ["01" aconst-null] + + ["02" iconst-m1] + ["03" iconst-0] + ["04" iconst-1] + ["05" iconst-2] + ["06" iconst-3] + ["07" iconst-4] + ["08" iconst-5] + + ["09" lconst-0] + ["0A" lconst-1] + + ["0B" fconst-0] + ["0C" fconst-1] + ["0D" fconst-2] + + ["0E" dconst-0] + ["0F" dconst-1]) + <register-loads> (template [<code> <name>] + [[<code> <name> [[register Register]] [register]]] + + ["15" iload] + ["16" lload] + ["17" fload] + ["18" dload] + ["19" aload]) + <simple-register-loads> (template [<code> <name>] + [[<code> <name> [] []]] + + ["1A" iload-0] + ["1B" iload-1] + ["1C" iload-2] + ["1D" iload-3] + + ["1E" lload-0] + ["1F" lload-1] + ["20" lload-2] + ["21" lload-3] + + ["22" fload-0] + ["23" fload-1] + ["24" fload-2] + ["25" fload-3] + + ["26" dload-0] + ["27" dload-1] + ["28" dload-2] + ["29" dload-3] + + ["2A" aload-0] + ["2B" aload-1] + ["2C" aload-2] + ["2D" aload-3]) + <register-stores> (template [<code> <name>] + [[<code> <name> [[register Register]] [register]]] + + ["36" istore] + ["37" lstore] + ["38" fstore] + ["39" dstore] + ["3A" astore]) + <simple-register-stores> (template [<code> <name>] + [[<code> <name> [] []]] + + ["3B" istore-0] + ["3C" istore-1] + ["3D" istore-2] + ["3E" istore-3] + + ["3F" lstore-0] + ["40" lstore-1] + ["41" lstore-2] + ["42" lstore-3] + + ["43" fstore-0] + ["44" fstore-1] + ["45" fstore-2] + ["46" fstore-3] + + ["47" dstore-0] + ["48" dstore-1] + ["49" dstore-2] + ["4A" dstore-3] + + ["4B" astore-0] + ["4C" astore-1] + ["4D" astore-2] + ["4E" astore-3]) + <array-loads> (template [<code> <name>] + [[<code> <name> [] []]] + + ["2E" iaload] + ["2F" laload] + ["30" faload] + ["31" daload] + ["32" aaload] + ["33" baload] + ["34" caload] + ["35" saload]) + <array-stores> (template [<code> <name>] + [[<code> <name> [] []]] + + ["4f" iastore] + ["50" lastore] + ["51" fastore] + ["52" dastore] + ["53" aastore] + ["54" bastore] + ["55" castore] + ["56" sastore]) + <arithmetic> (template [<code> <name>] + [[<code> <name> [] []]] + + ["60" iadd] + ["64" isub] + ["68" imul] + ["6c" idiv] + ["70" irem] + ["74" ineg] + ["78" ishl] + ["7a" ishr] + ["7c" iushr] + ["7e" iand] + ["80" ior] + ["82" ixor] + + ["61" ladd] + ["65" lsub] + ["69" lmul] + ["6D" ldiv] + ["71" lrem] + ["75" lneg] + ["7F" land] + ["81" lor] + ["83" lxor] + + ["62" fadd] + ["66" fsub] + ["6A" fmul] + ["6E" fdiv] + ["72" frem] + ["76" fneg] + + ["63" dadd] + ["67" dsub] + ["6B" dmul] + ["6F" ddiv] + ["73" drem] + ["77" dneg]) + <conversions> (template [<code> <name>] + [[<code> <name> [] []]] + + ["88" l2i] + ["89" l2f] + ["8A" l2d] + + ["8B" f2i] + ["8C" f2l] + ["8D" f2d] + + ["8E" d2i] + ["8F" d2l] + ["90" d2f] + + ["85" i2l] + ["86" i2f] + ["87" i2d] + ["91" i2b] + ["92" i2c] + ["93" i2s]) + <comparisons> (template [<code> <name>] + [[<code> <name> [] []]] + + ["94" lcmp] + + ["95" fcmpl] + ["96" fcmpg] + + ["97" dcmpl] + ["98" dcmpg]) + <returns> (template [<code> <name>] + [[<code> <name> [] []]] + + ["AC" ireturn] + ["AD" lreturn] + ["AE" freturn] + ["AF" dreturn] + ["B0" areturn] + ["B1" return] + ) + <jumps> (template [<code> <name>] + [[<code> <name> [[jump Jump]] [jump]]] + + ["99" ifeq] + ["9A" ifne] + ["9B" iflt] + ["9C" ifge] + ["9D" ifgt] + ["9E" ifle] + + ["9F" if-icmpeq] + ["A0" if-icmpne] + ["A1" if-icmplt] + ["A2" if-icmpge] + ["A3" if-icmpgt] + ["A4" if-icmple] + + ["A5" if-acmpeq] + ["A6" if-acmpne] + + ["A7" goto] + ["A8" jsr] + + ["C6" ifnull] + ["C7" ifnonnull]) + <fields> (template [<code> <name>] + [[<code> <name> [[index (Index (Reference Value))]] [(///index.value index)]]] + + ["B2" getstatic/1] ["B2" getstatic/2] + ["B3" putstatic/1] ["B3" putstatic/2] + ["B4" getfield/1] ["B4" getfield/2] + ["B5" putfield/1] ["B5" putfield/2])] + (template [<arity> <definitions>] + [(with-expansions [<definitions>' (template.splice <definitions>)] + (template [<code> <name> <instruction-inputs> <arity-inputs>] + [(with-expansions [<inputs>' (template.splice <instruction-inputs>) + <input-types> (template [<input-name> <input-type>] + [<input-type>] + + <inputs>') + <input-names> (template [<input-name> <input-type>] + [<input-name>] + + <inputs>')] + (def: #export <name> + [Estimator (-> [<input-types>] Instruction)] + (let [[estimator <arity>'] <arity>] + [estimator + (function (_ [<input-names>]) + (`` (<arity>' (hex <code>) (~~ (template.splice <arity-inputs>)))))])))] + + <definitions>' + ))] + + [..nullary + [["00" nop [] []] + <constants> + ["57" pop [] []] + ["58" pop2 [] []] + ["59" dup [] []] + ["5A" dup-x1 [] []] + ["5B" dup-x2 [] []] + ["5C" dup2 [] []] + ["5D" dup2-x1 [] []] + ["5E" dup2-x2 [] []] + ["5F" swap [] []] + <simple-register-loads> + <array-loads> + <simple-register-stores> + <array-stores> + <arithmetic> + ["79" lshl [] []] + ["7B" lshr [] []] + ["7D" lushr [] []] + <conversions> + <comparisons> + <returns> + ["BE" arraylength [] []] + ["BF" athrow [] []] + ["C2" monitorenter [] []] + ["C3" monitorexit [] []]]] + + [..unary/1 + [["10" bipush [[byte U1]] [byte]] + ["12" ldc [[index U1]] [index]] + <register-loads> + <register-stores> + ["A9" ret [[register Register]] [register]] + ["BC" newarray [[type Primitive-Array-Type]] [(..code type)]]]] + + [..unary/2 + [["11" sipush [[short U2]] [short]] + ["13" ldc-w/integer [[index (Index ///constant.Integer)]] [(///index.value index)]] + ["13" ldc-w/float [[index (Index ///constant.Float)]] [(///index.value index)]] + ["13" ldc-w/string [[index (Index ///constant.String)]] [(///index.value index)]] + ["14" ldc2-w/long [[index (Index ///constant.Long)]] [(///index.value index)]] + ["14" ldc2-w/double [[index (Index ///constant.Double)]] [(///index.value index)]] + <fields> + ["BB" new [[index (Index Class)]] [(///index.value index)]] + ["BD" anewarray [[index (Index Class)]] [(///index.value index)]] + ["C0" checkcast [[index (Index Class)]] [(///index.value index)]] + ["C1" instanceof [[index (Index Class)]] [(///index.value index)]] + ["B6" invokevirtual [[index (Index (Reference Method))] [count U1] [output-count U1]] [(///index.value index)]] + ["B7" invokespecial [[index (Index (Reference Method))] [count U1] [output-count U1]] [(///index.value index)]] + ["B8" invokestatic [[index (Index (Reference Method))] [count U1] [output-count U1]] [(///index.value index)]]]] + + [..jump/2 + [<jumps>]] + + [..jump/4 + [["C8" goto-w [[jump Big-Jump]] [jump]] + ["C9" jsr-w [[jump Big-Jump]] [jump]]]] + + [..binary/11 + [["84" iinc [[register Register] [byte U1]] [register byte]]]] + + [..binary/21 + [["C5" multianewarray [[index (Index Class)] [count U1]] [(///index.value index) count]]]] + + [..trinary/211 + [["B9" invokeinterface [[index (Index (Reference Method))] [count U1] [output-count U1]] [(///index.value index) count (try.assume (///unsigned.u1 0))]]]] + )) + +(def: (switch-padding offset) + (-> Nat Nat) + (let [parameter-start (n.+ (///unsigned.value ..opcode-size) + offset)] + (n.% 4 + (n.- (n.% 4 parameter-start) + 4)))) + +(def: #export tableswitch + [(-> Nat Estimator) + (-> S4 Big-Jump (List Big-Jump) Instruction)] + (let [estimator (: (-> Nat Estimator) + (function (_ amount-of-cases offset) + (|> ($_ n.+ + (///unsigned.value ..opcode-size) + (switch-padding (///unsigned.value (//address.value offset))) + (///unsigned.value ..big-jump-size) + (///unsigned.value ..integer-size) + (///unsigned.value ..integer-size) + (n.* amount-of-cases + (///unsigned.value ..big-jump-size))) + ///unsigned.u2 + try.assume)))] + [estimator + (function (_ minimum default cases) + (let [amount-of-cases (list.size cases) + estimator (estimator amount-of-cases)] + (function (_ [size mutation]) + (let [padding (switch-padding size) + tableswitch-size (try.assume + (do try.monad + [size (///unsigned.u2 size)] + (:: @ map (|>> estimator ///unsigned.value) + (//address.move size //address.start)))) + tableswitch-mutation (: Mutation + (function (_ [offset binary]) + [(n.+ tableswitch-size offset) + (try.assume + (do try.monad + [amount-of-cases (|> amount-of-cases .int ///signed.s4) + maximum (///signed.+/4 minimum amount-of-cases) + _ (binary.write/8 offset (hex "AA") binary) + #let [offset (n.+ (///unsigned.value ..opcode-size) offset)] + _ (case padding + 3 (do @ + [_ (binary.write/8 offset 0 binary)] + (binary.write/16 (inc offset) 0 binary)) + 2 (binary.write/16 offset 0 binary) + 1 (binary.write/8 offset 0 binary) + _ (wrap binary)) + #let [offset (n.+ padding offset)] + _ (binary.write/32 offset (///signed.value default) binary) + #let [offset (n.+ (///unsigned.value ..big-jump-size) offset)] + _ (binary.write/32 offset (///signed.value minimum) binary) + #let [offset (n.+ (///unsigned.value ..integer-size) offset)] + _ (binary.write/32 offset (///signed.value maximum) binary)] + (loop [offset (n.+ (///unsigned.value ..integer-size) offset) + cases cases] + (case cases + #.Nil + (wrap binary) + + (#.Cons head tail) + (do @ + [_ (binary.write/32 offset (///signed.value head) binary)] + (recur (n.+ (///unsigned.value ..big-jump-size) offset) + tail))))))]))] + [(n.+ tableswitch-size + size) + (|>> mutation tableswitch-mutation)]))))])) + +(def: #export lookupswitch + [(-> Nat Estimator) + (-> Big-Jump (List [S4 Big-Jump]) Instruction)] + (let [case-size (n.+ (///unsigned.value ..integer-size) + (///unsigned.value ..big-jump-size)) + estimator (: (-> Nat Estimator) + (function (_ amount-of-cases offset) + (|> ($_ n.+ + (///unsigned.value ..opcode-size) + (switch-padding (///unsigned.value (//address.value offset))) + (///unsigned.value ..big-jump-size) + (///unsigned.value ..integer-size) + (n.* amount-of-cases case-size)) + ///unsigned.u2 + try.assume)))] + [estimator + (function (_ default cases) + (let [amount-of-cases (list.size cases) + estimator (estimator amount-of-cases)] + (function (_ [size mutation]) + (let [padding (switch-padding size) + lookupswitch-size (try.assume + (do try.monad + [size (///unsigned.u2 size)] + (:: @ map (|>> estimator ///unsigned.value) + (//address.move size //address.start)))) + lookupswitch-mutation (: Mutation + (function (_ [offset binary]) + [(n.+ lookupswitch-size offset) + (try.assume + (do try.monad + [_ (binary.write/8 offset (hex "AB") binary) + #let [offset (n.+ (///unsigned.value ..opcode-size) offset)] + _ (case padding + 3 (do @ + [_ (binary.write/8 offset 0 binary)] + (binary.write/16 (inc offset) 0 binary)) + 2 (binary.write/16 offset 0 binary) + 1 (binary.write/8 offset 0 binary) + _ (wrap binary)) + #let [offset (n.+ padding offset)] + _ (binary.write/32 offset (///signed.value default) binary) + #let [offset (n.+ (///unsigned.value ..big-jump-size) offset)] + _ (binary.write/32 offset amount-of-cases binary)] + (loop [offset (n.+ (///unsigned.value ..integer-size) offset) + cases cases] + (case cases + #.Nil + (wrap binary) + + (#.Cons [value jump] tail) + (do @ + [_ (binary.write/32 offset (///signed.value value) binary) + _ (binary.write/32 (n.+ (///unsigned.value ..integer-size) offset) (///signed.value jump) binary)] + (recur (n.+ case-size offset) + tail))))))]))] + [(n.+ lookupswitch-size + size) + (|>> mutation lookupswitch-mutation)]))))])) + +(structure: #export monoid + (Monoid Instruction) + + (def: identity ..empty) + + (def: (compose left right) + (|>> left right))) diff --git a/stdlib/source/lux/target/jvm/instruction/jump.lux b/stdlib/source/lux/target/jvm/bytecode/jump.lux index fcda92bd1..47126631c 100644 --- a/stdlib/source/lux/target/jvm/instruction/jump.lux +++ b/stdlib/source/lux/target/jvm/bytecode/jump.lux @@ -12,10 +12,10 @@ ///signed.equivalence) (def: #export writer - ///signed.s2-writer) + ///signed.writer/2) (type: #export Big-Jump S4) (def: #export lift (-> Jump Big-Jump) - (|>> ///signed.int ///signed.s4)) + ///signed.lift/4) diff --git a/stdlib/source/lux/target/jvm/class.lux b/stdlib/source/lux/target/jvm/class.lux index bc3670110..ec2832b19 100644 --- a/stdlib/source/lux/target/jvm/class.lux +++ b/stdlib/source/lux/target/jvm/class.lux @@ -5,7 +5,8 @@ ["." equivalence (#+ Equivalence)] ["." monad (#+ do)]] [control - ["." state (#+ State)]] + ["." state] + ["." try (#+ Try)]] [data [number (#+) [i64 (#+)]] @@ -27,7 +28,7 @@ ["#." unsigned (#+)] ["#." name (#+ Internal)]] ["#." constant (#+ Constant) - ["#/." pool (#+ Pool)]]]) + ["#/." pool (#+ Pool Resource)]]]) (type: #export #rec Class {#magic Magic @@ -70,11 +71,11 @@ (def: (install-classes this super interfaces) (-> Internal Internal (List Internal) - (State Pool [(Index //constant.Class) (Index //constant.Class) (Row (Index //constant.Class))])) - (do state.monad + (Resource [(Index //constant.Class) (Index //constant.Class) (Row (Index //constant.Class))])) + (do //constant/pool.monad [@this (//constant/pool.class this) @super (//constant/pool.class super) - @interfaces (: (State Pool (Row (Index //constant.Class))) + @interfaces (: (Resource (Row (Index //constant.Class))) (monad.fold @ (function (_ interface @interfaces) (do @ [@interface (//constant/pool.class interface)] @@ -88,28 +89,29 @@ fields methods attributes) (-> Major (Modifier Class) Internal Internal (List Internal) - (List (State Pool Field)) - (List (State Pool Method)) + (List (Resource Field)) + (List (Resource Method)) (Row Attribute) - Class) - (let [[pool [@this @super @interfaces] =fields =methods] - (state.run //constant/pool.empty - (do state.monad - [classes (install-classes this super interfaces) - =fields (monad.seq state.monad fields) - =methods (monad.seq state.monad methods)] - (wrap [classes =fields =methods])))] - {#magic //magic.code - #minor-version //version.default-minor - #major-version version - #constant-pool pool - #modifier modifier - #this @this - #super @super - #interfaces @interfaces - #fields (row.from-list =fields) - #methods (row.from-list =methods) - #attributes attributes})) + (Try Class)) + (do try.monad + [[pool [@this @super @interfaces] =fields =methods] + (<| (state.run' //constant/pool.empty) + (do //constant/pool.monad + [classes (install-classes this super interfaces) + =fields (monad.seq //constant/pool.monad fields) + =methods (monad.seq //constant/pool.monad methods)] + (wrap [classes =fields =methods])))] + (wrap {#magic //magic.code + #minor-version //version.default-minor + #major-version version + #constant-pool pool + #modifier modifier + #this @this + #super @super + #interfaces @interfaces + #fields (row.from-list =fields) + #methods (row.from-list =methods) + #attributes attributes}))) (def: #export (writer class) (Writer Class) diff --git a/stdlib/source/lux/target/jvm/constant/pool.lux b/stdlib/source/lux/target/jvm/constant/pool.lux index c6dd5e45c..a839a4a3e 100644 --- a/stdlib/source/lux/target/jvm/constant/pool.lux +++ b/stdlib/source/lux/target/jvm/constant/pool.lux @@ -3,11 +3,10 @@ ["." host] [abstract ["." equivalence (#+ Equivalence)] - [monad (#+ do)]] + [monad (#+ Monad do)]] [control - ["." state (#+ State)] - ["." try (#+ Try)] - ["." exception (#+ exception:)]] + ["." state (#+ State')] + ["." try (#+ Try)]] [data [number ["." i32] @@ -16,8 +15,8 @@ ["." frac]] ["." text ["%" format (#+ format)]] - [format - [".F" binary (#+ Writer) ("specification@." monoid)]] + ["." format #_ + ["#" binary (#+ Writer) ("specification@." monoid)]] [collection ["." row (#+ Row) ("#@." fold)]]] [type @@ -42,7 +41,14 @@ (row.equivalence (equivalence.product //index.equivalence //.equivalence)))) -(template: (!add <tag> <=> <value>) +(type: #export (Resource a) + (State' Try Pool a)) + +(def: #export monad + (Monad Resource) + (state.with try.monad)) + +(template: (!add <tag> <equivalence> <value>) (function (_ [next pool]) (with-expansions [<try-again> (as-is (recur (.inc idx)))] (loop [idx 0] @@ -50,9 +56,9 @@ (#.Some entry) (case entry [index (<tag> reference)] - (if (:: <=> = reference <value>) - [[next pool] - index] + (if (:: <equivalence> = reference <value>) + (#try.Success [[next pool] + index]) <try-again>) _ @@ -60,98 +66,27 @@ #.None (let [new (<tag> <value>)] - [[(|> next - //index.number - (//unsigned.u2/+ (//unsigned.u2 (//.size new))) - //index.index) - (row.add [next new] pool)] - next])))))) - -(template: (!raw-index <index>) - (|> <index> //index.number //unsigned.nat)) - -(exception: #export (invalid-index {index (Index Any)}) - (exception.report - ["Index" (|> index !raw-index %.nat)])) - -(exception: #export (invalid-constant {index (Index Any)} - {tag Name}) - (exception.report - ["Index" (|> index !raw-index %.nat)] - ["Expected tag" (%.name tag)])) - -(template: (!fetch <tag> <index>) - (with-expansions [<failure> (as-is [[next pool] (exception.throw ..invalid-index [<index>])])] - (function (_ [next pool]) - (loop [idx 0] - (case (row.nth idx pool) - (#.Some [index entry]) - (let [index' (!raw-index index) - <index>' (!raw-index <index>)] - (cond (n.< index' <index>') - (recur (inc idx)) - - (n.= index' <index>') - (case entry - (<tag> value) - [[next pool] (#try.Success value)] - - _ - [[next pool] (exception.throw ..invalid-constant [<index> (name-of <tag>)])]) - - ## (n.> index' <index>') - <failure>)) - - #.None - <failure>)) - ))) - -(exception: #export (cannot-find {tag Name} {value Text}) - (exception.report - ["Expected tag" (%.name tag)] - ["Value" value])) - -(template: (!find <tag> <=> <%> <expected>) - (function (_ [next pool]) - (with-expansions [<try-again> (as-is (recur (.inc idx)))] - (loop [idx 0] - (case (row.nth idx pool) - (#.Some [index entry]) - (case entry - (<tag> actual) - (if (:: <=> = actual <expected>) - [[next pool] - (#try.Success index)] - <try-again>) - - _ - <try-again>) - - #.None - [[next pool] - (exception.throw ..cannot-find [(name-of <tag>) (<%> <expected>)])]))))) + (do try.monad + [@new (//unsigned.u2 (//.size new)) + next (: (Try Index) + (|> next + //index.value + (//unsigned.+/2 @new) + (:: @ map //index.index)))] + (wrap [[next + (row.add [next new] pool)] + next])))))))) + +(template: (!index <index>) + (|> <index> //index.value //unsigned.value)) (type: (Adder of) - (-> of (State Pool (Index of)))) - -(type: (Fetcher of) - (-> (Index of) (State Pool (Try of)))) - -(type: (Finder of) - (-> of (State Pool (Try (Index of))))) + (-> of (Resource (Index of)))) (template [<name> <type> <tag> <equivalence> <format>] [(def: #export (<name> value) (Adder <type>) - (!add <tag> <equivalence> value)) - - (`` (def: #export ((~~ (template.identifier ["fetch-" <name>])) index) - (Fetcher <type>) - (!fetch <tag> index))) - - (`` (def: #export ((~~ (template.identifier ["find-" <name>])) reference) - (Finder <type>) - (!find <tag> <equivalence> <format> reference)))] + (!add <tag> <equivalence> value))] [integer Integer #//.Integer (//.value-equivalence i32.equivalence) (|>> //.value .nat %.nat)] [float Float #//.Float (//.value-equivalence //.float-equivalence) (|>> //.value host.float-to-double (:coerce Frac) %.frac)] @@ -161,15 +96,15 @@ ) (def: #export (string value) - (-> Text (State Pool (Index String))) - (do state.monad + (-> Text (Resource (Index String))) + (do ..monad [@value (utf8 value) #let [value (//.string @value)]] (!add #//.String (//.value-equivalence //index.equivalence) value))) (def: #export (class name) - (-> Internal (State Pool (Index Class))) - (do state.monad + (-> Internal (Resource (Index Class))) + (do ..monad [@name (utf8 (//name.read name)) #let [value (//.class @name)]] (!add #//.Class //.class-equivalence value))) @@ -177,7 +112,7 @@ (def: #export (descriptor value) (All [kind] (-> (Descriptor kind) - (State Pool (Index (Descriptor kind))))) + (Resource (Index (Descriptor kind))))) (let [value (//descriptor.descriptor value)] (!add #//.UTF8 text.equivalence value))) @@ -187,8 +122,8 @@ (def: #export (name-and-type [name descriptor]) (All [of] - (-> (Member of) (State Pool (Index (Name-And-Type of))))) - (do state.monad + (-> (Member of) (Resource (Index (Name-And-Type of))))) + (do ..monad [@name (utf8 name) @descriptor (..descriptor descriptor)] (!add #//.Name-And-Type //.name-and-type-equivalence @@ -197,8 +132,8 @@ (template [<name> <tag> <of>] [(def: #export (<name> class member) - (-> External (Member <of>) (State Pool (Index (Reference <of>)))) - (do state.monad + (-> External (Member <of>) (Resource (Index (Reference <of>)))) + (do ..monad [@class (..class (//name.internal class)) @name-and-type (name-and-type member)] (!add <tag> //.reference-equivalence @@ -215,10 +150,10 @@ (function (_ [next pool]) (row@fold (function (_ [_index post] pre) (specification@compose pre (//.writer post))) - (binaryF.bits/16 (!raw-index next)) + (format.bits/16 (!index next)) pool))) (def: #export empty Pool - [(|> 1 //unsigned.u2 //index.index) + [(|> 1 //unsigned.u2 try.assume //index.index) row.empty]) diff --git a/stdlib/source/lux/target/jvm/constant/tag.lux b/stdlib/source/lux/target/jvm/constant/tag.lux index a3da84812..1771bfd19 100644 --- a/stdlib/source/lux/target/jvm/constant/tag.lux +++ b/stdlib/source/lux/target/jvm/constant/tag.lux @@ -2,14 +2,16 @@ [lux #* [abstract [equivalence (#+ Equivalence)]] + [control + ["." try]] [data [format [binary (#+ Writer)]]] [type abstract]] - [/// + ["." /// #_ [encoding - ["." unsigned (#+ U1) ("u1@." equivalence)]]]) + ["#." unsigned (#+ U1) ("u1@." equivalence)]]]) (abstract: #export Tag {} @@ -25,7 +27,7 @@ (template [<code> <name>] [(def: #export <name> Tag - (:abstraction (unsigned.u1 <code>)))] + (|> <code> ///unsigned.u1 try.assume :abstraction))] [01 utf8] [03 integer] @@ -45,5 +47,5 @@ (def: #export writer (Writer Tag) - (|>> :representation unsigned.u1-writer)) + (|>> :representation ///unsigned.writer/1)) ) diff --git a/stdlib/source/lux/target/jvm/encoding/signed.lux b/stdlib/source/lux/target/jvm/encoding/signed.lux index 3609142a3..8455d2dba 100644 --- a/stdlib/source/lux/target/jvm/encoding/signed.lux +++ b/stdlib/source/lux/target/jvm/encoding/signed.lux @@ -3,13 +3,18 @@ [abstract [equivalence (#+ Equivalence)] [order (#+ Order)]] + [control + ["." try (#+ Try)] + ["." exception (#+ exception:)]] [data [number ["." i64] ["n" nat] ["i" int]] - [format - [".F" binary (#+ Writer)]]] + [text + ["%" format (#+ format)]] + ["." format #_ + ["#" binary (#+ Writer)]]] [macro ["." template]] [type @@ -19,7 +24,7 @@ {} Int - (def: #export int + (def: #export value (-> (Signed Any) Int) (|>> :representation)) @@ -35,42 +40,67 @@ (def: (< reference sample) (i.< (:representation reference) (:representation sample)))) - (template [<bytes> <name> <size> <constructor> <max> <+>] + (exception: #export (value-exceeds-the-scope {value Int} + {scope Nat}) + (exception.report + ["Value" (%.int value)] + ["Scope (in bytes)" (%.nat scope)])) + + (template [<bytes> <name> <size> <constructor> <maximum> <+> <->] [(with-expansions [<raw> (template.identifier [<name> "'"])] (abstract: #export <raw> {} Any) (type: #export <name> (Signed <raw>))) - (def: #export <size> Nat <bytes>) + (def: #export <size> <bytes>) - (def: #export <max> + (def: #export <maximum> <name> (|> <bytes> (n.* i64.bits-per-byte) dec i64.mask :abstraction)) (def: #export <constructor> - (-> Int <name>) - (let [limit (|> <bytes> (n.* i64.bits-per-byte) i64.mask .nat)] - (|>> (i64.and limit) :abstraction))) + (-> Int (Try <name>)) + (let [positive (|> <bytes> (n.* i64.bits-per-byte) i64.mask .nat) + negative (|> positive (i64.arithmetic-right-shift 1) i64.not)] + (function (_ value) + (if (i.= (if (i.< +0 value) + (i64.or negative value) + (i64.and positive value)) + value) + (#try.Success (:abstraction value)) + (exception.throw ..value-exceeds-the-scope [value <size>]))))) + + (template [<abstract-operation> <concrete-operation>] + [(def: #export (<abstract-operation> parameter subject) + (-> <name> <name> (Try <name>)) + (<constructor> + (<concrete-operation> (:representation parameter) + (:representation subject))))] - (def: #export (<+> parameter subject) - (-> <name> <name> <name>) - (let [limit (|> <bytes> (n.* i64.bits-per-byte) i64.mask .nat)] - (:abstraction - (i64.and limit - (i.+ (:representation parameter) - (:representation subject))))))] + [<+> i.+] + [<-> i.-] + )] - [1 S1 s1-bytes s1 max-s1 s1/+] - [2 S2 s2-bytes s2 max-s2 s2/+] - [4 S4 s4-bytes s4 max-s4 s4/+] + [1 S1 bytes/1 s1 maximum/1 +/1 -/1] + [2 S2 bytes/2 s2 maximum/2 +/2 -/2] + [4 S4 bytes/4 s4 maximum/4 +/4 -/4] ) - ) -(template [<writer-name> <type> <writer>] - [(def: #export <writer-name> - (Writer <type>) - (|>> ..int <writer>))] + (template [<name> <from> <to>] + [(def: #export <name> + (-> <from> <to>) + (|>> :transmutation))] - [s1-writer S1 binaryF.bits/8] - [s2-writer S2 binaryF.bits/16] - [s4-writer S4 binaryF.bits/32] + [lift/2 S1 S2] + [lift/4 S2 S4] + ) + + (template [<writer-name> <type> <writer>] + [(def: #export <writer-name> + (Writer <type>) + (|>> :representation <writer>))] + + [writer/1 S1 format.bits/8] + [writer/2 S2 format.bits/16] + [writer/4 S4 format.bits/32] + ) ) diff --git a/stdlib/source/lux/target/jvm/encoding/unsigned.lux b/stdlib/source/lux/target/jvm/encoding/unsigned.lux index 56885d576..4286976dc 100644 --- a/stdlib/source/lux/target/jvm/encoding/unsigned.lux +++ b/stdlib/source/lux/target/jvm/encoding/unsigned.lux @@ -3,12 +3,17 @@ [abstract [equivalence (#+ Equivalence)] [order (#+ Order)]] + [control + ["." try (#+ Try)] + ["." exception (#+ exception:)]] [data [number ["." i64] ["n" nat]] - [format - [".F" binary (#+ Writer)]]] + [text + ["%" format (#+ format)]] + ["." format #_ + ["#" binary (#+ Writer)]]] [macro ["." template]] [type @@ -18,56 +23,94 @@ {} Nat - (def: #export nat + (def: #export value (-> (Unsigned Any) Nat) (|>> :representation)) (structure: #export equivalence (All [brand] (Equivalence (Unsigned brand))) (def: (= reference sample) - (n.= (:representation reference) (:representation sample)))) + (n.= (:representation reference) + (:representation sample)))) (structure: #export order (All [brand] (Order (Unsigned brand))) (def: &equivalence ..equivalence) (def: (< reference sample) - (n.< (:representation reference) (:representation sample)))) + (n.< (:representation reference) + (:representation sample)))) - (template [<bytes> <name> <size> <constructor> <max> <+>] + (exception: #export (value-exceeds-the-maximum {value Nat} + {maximum (Unsigned Any)}) + (exception.report + ["Value" (%.nat value)] + ["Maximum" (%.nat (:representation maximum))])) + + (exception: #export [brand] (subtraction-cannot-yield-negative-value + {parameter (Unsigned brand)} + {subject (Unsigned brand)}) + (exception.report + ["Parameter" (%.nat (:representation parameter))] + ["Subject" (%.nat (:representation subject))])) + + (template [<bytes> <name> <size> <constructor> <maximum> <+> <-> <max>] [(with-expansions [<raw> (template.identifier [<name> "'"])] (abstract: #export <raw> {} Any) (type: #export <name> (Unsigned <raw>))) - (def: #export <size> Nat <bytes>) + (def: #export <size> <bytes>) - (def: #export <max> + (def: #export <maximum> <name> (|> <bytes> (n.* i64.bits-per-byte) i64.mask :abstraction)) - (def: #export <constructor> - (-> Nat <name>) - (|>> (i64.and (:representation <max>)) :abstraction)) + (def: #export (<constructor> value) + (-> Nat (Try <name>)) + (if (n.<= (:representation <maximum>) value) + (#try.Success (:abstraction value)) + (exception.throw ..value-exceeds-the-maximum [value <maximum>]))) (def: #export (<+> parameter subject) + (-> <name> <name> (Try <name>)) + (<constructor> + (n.+ (:representation parameter) + (:representation subject)))) + + (def: #export (<-> parameter subject) + (-> <name> <name> (Try <name>)) + (let [parameter' (:representation parameter) + subject' (:representation subject)] + (if (n.<= subject' parameter') + (#try.Success (:abstraction (n.- parameter' subject'))) + (exception.throw ..subtraction-cannot-yield-negative-value [parameter subject])))) + + (def: #export (<max> left right) (-> <name> <name> <name>) - (:abstraction - (i64.and (:representation <max>) - (n.+ (:representation parameter) - (:representation subject)))))] - - [1 U1 u1-bytes u1 max-u1 u1/+] - [2 U2 u2-bytes u2 max-u2 u2/+] - [4 U4 u4-bytes u4 max-u4 u4/+] + (:abstraction (n.max (:representation left) + (:representation right))))] + + [1 U1 bytes/1 u1 maximum/1 +/1 -/1 max/1] + [2 U2 bytes/2 u2 maximum/2 +/2 -/2 max/2] + [4 U4 bytes/4 u4 maximum/4 +/4 -/4 max/4] ) - ) -(template [<writer-name> <type> <writer>] - [(def: #export <writer-name> - (Writer <type>) - (|>> ..nat <writer>))] + (template [<name> <from> <to>] + [(def: #export <name> + (-> <from> <to>) + (|>> :transmutation))] + + [lift/2 U1 U2] + [lift/4 U2 U4] + ) - [u1-writer U1 binaryF.bits/8] - [u2-writer U2 binaryF.bits/16] - [u4-writer U4 binaryF.bits/32] + (template [<writer-name> <type> <writer>] + [(def: #export <writer-name> + (Writer <type>) + (|>> :representation <writer>))] + + [writer/1 U1 format.bits/8] + [writer/2 U2 format.bits/16] + [writer/4 U4 format.bits/32] + ) ) diff --git a/stdlib/source/lux/target/jvm/field.lux b/stdlib/source/lux/target/jvm/field.lux index 1e7edac35..8541076f7 100644 --- a/stdlib/source/lux/target/jvm/field.lux +++ b/stdlib/source/lux/target/jvm/field.lux @@ -4,8 +4,6 @@ [monoid (#+)] ["." equivalence (#+ Equivalence)] ["." monad (#+ do)]] - [control - ["." state (#+ State)]] [data [number (#+) [i64 (#+)]] @@ -18,7 +16,7 @@ ["." // #_ ["." modifier (#+ Modifier modifiers:)] ["#." constant (#+ UTF8) - ["#/." pool (#+ Pool)]] + ["#/." pool (#+ Pool Resource)]] ["#." index (#+ Index)] ["#." attribute (#+ Attribute)] ["#." type (#+ Type) @@ -65,8 +63,8 @@ (def: #export (field modifier name type attributes) (-> (Modifier Field) UTF8 (Type Value) (Row Attribute) - (State Pool Field)) - (do state.monad + (Resource Field)) + (do //constant/pool.monad [@name (//constant/pool.utf8 name) @descriptor (//constant/pool.descriptor (//type.descriptor type))] (wrap {#modifier modifier diff --git a/stdlib/source/lux/target/jvm/index.lux b/stdlib/source/lux/target/jvm/index.lux index 430276f4b..490667436 100644 --- a/stdlib/source/lux/target/jvm/index.lux +++ b/stdlib/source/lux/target/jvm/index.lux @@ -11,6 +11,9 @@ [encoding ["#." unsigned (#+ U2)]]]) +(def: #export length + //unsigned.bytes/2) + (abstract: #export (Index kind) {} @@ -20,17 +23,17 @@ (All [kind] (-> U2 (Index kind))) (|>> :abstraction)) - (def: #export number + (def: #export value (-> (Index Any) U2) (|>> :representation)) (def: #export equivalence (All [kind] (Equivalence (Index kind))) (:: equivalence.contravariant map-1 - ..number + ..value //unsigned.equivalence)) (def: #export writer (All [kind] (Writer (Index kind))) - (|>> ..number //unsigned.u2-writer)) + (|>> :representation //unsigned.writer/2)) ) diff --git a/stdlib/source/lux/target/jvm/instruction/address.lux b/stdlib/source/lux/target/jvm/instruction/address.lux deleted file mode 100644 index 1be4460b2..000000000 --- a/stdlib/source/lux/target/jvm/instruction/address.lux +++ /dev/null @@ -1,31 +0,0 @@ -(.module: - [lux #* - [abstract - [equivalence (#+ Equivalence)]] - [data - [format - [binary (#+ Writer)]]] - [type - abstract]] - ["." /// #_ - [encoding - ["#." unsigned (#+ U2)]]]) - -(abstract: #export Address - {} - - U2 - - (def: #export address - (-> U2 Address) - (|>> :abstraction)) - - (structure: #export equivalence - (Equivalence Address) - (def: (= reference subject) - (:: ///unsigned.equivalence = (:representation reference) (:representation subject)))) - - (def: #export writer - (Writer Address) - (|>> :representation ///unsigned.u2-writer)) - ) diff --git a/stdlib/source/lux/target/jvm/instruction/condition.lux b/stdlib/source/lux/target/jvm/instruction/condition.lux deleted file mode 100644 index 50061b579..000000000 --- a/stdlib/source/lux/target/jvm/instruction/condition.lux +++ /dev/null @@ -1,83 +0,0 @@ -(.module: - [lux #* - [abstract - [monad (#+ do)] - [monoid (#+ Monoid)]] - [control - ["." try (#+ Try)] - ["." exception (#+ exception:)]] - [data - ["." binary] - [number (#+ hex) - ["n" nat]] - [text - ["%" format (#+ format)]] - [format - [".F" binary (#+ Mutation Specification)]]]] - ["." // #_ - ["#." resources (#+ Resources)] - ["/#" // #_ - [encoding - ["#." unsigned (#+ U1 U2)]]]]) - -(type: #export Stack U2) - -(type: #export Environment - {#resources Resources - #stack Stack}) - -(def: #export start - Environment - {#resources //resources.start - #stack (///unsigned.u2 0)}) - -(type: #export Condition - (-> Environment (Try Environment))) - -(structure: #export monoid - (Monoid Condition) - - (def: identity (|>> #try.Success)) - - (def: (compose left right) - (function (_ environment) - (do try.monad - [environment (left environment)] - (right environment))))) - -(def: #export (produces amount env) - (-> Nat Condition) - (let [stack (n.+ amount - (///unsigned.nat (get@ #stack env))) - max-stack (n.max stack - (///unsigned.nat (get@ [#resources #//resources.max-stack] env)))] - (|> env - (set@ #stack (///unsigned.u2 stack)) - (set@ [#resources #//resources.max-stack] (///unsigned.u2 max-stack)) - #try.Success))) - -(exception: #export (cannot-pop-stack {stack-size Nat} - {wanted-pops Nat}) - (exception.report - ["Stack Size" (%.nat stack-size)] - ["Wanted Pops" (%.nat wanted-pops)])) - -(def: #export (consumes wanted-pops env) - (-> Nat Condition) - (let [stack-size (///unsigned.nat (get@ #stack env))] - (if (n.<= stack-size wanted-pops) - (#try.Success (update@ #stack - (|>> ///unsigned.nat (n.- wanted-pops) ///unsigned.u2) - env)) - (exception.throw ..cannot-pop-stack [stack-size wanted-pops])))) - -(type: #export Local U1) - -(def: #export (has-local local environment) - (-> Local Condition) - (let [max-locals (n.max (///unsigned.nat (get@ [#resources #//resources.max-locals] environment)) - (///unsigned.nat local))] - (|> environment - (set@ [#resources #//resources.max-locals] - (///unsigned.u2 max-locals)) - #try.Success))) diff --git a/stdlib/source/lux/target/jvm/instruction/resources.lux b/stdlib/source/lux/target/jvm/instruction/resources.lux deleted file mode 100644 index c7d741a1d..000000000 --- a/stdlib/source/lux/target/jvm/instruction/resources.lux +++ /dev/null @@ -1,46 +0,0 @@ -(.module: - [lux #* - [abstract - ["." equivalence (#+ Equivalence)]] - [data - [number - ["n" nat]] - [format - [".F" binary (#+ Writer) ("#@." monoid)]]]] - ["." /// #_ - [encoding - ["#." unsigned (#+ U2)]]]) - -(type: #export Resources - {#max-stack U2 - #max-locals U2}) - -(def: #export start - Resources - {#max-stack (///unsigned.u2 0) - #max-locals (///unsigned.u2 0)}) - -(def: #export length - ($_ n.+ - ## u2 max_stack; - ///unsigned.u2-bytes - ## u2 max_locals; - ///unsigned.u2-bytes)) - -(def: #export equivalence - (Equivalence Resources) - ($_ equivalence.product - ## u2 max_stack; - ///unsigned.equivalence - ## u2 max_locals; - ///unsigned.equivalence - )) - -(def: #export (writer resources) - (Writer Resources) - ($_ binaryF@compose - ## u2 max_stack; - (///unsigned.u2-writer (get@ #max-stack resources)) - ## u2 max_locals; - (///unsigned.u2-writer (get@ #max-locals resources)) - )) diff --git a/stdlib/source/lux/target/jvm/magic.lux b/stdlib/source/lux/target/jvm/magic.lux index ff2d119e4..408de3d84 100644 --- a/stdlib/source/lux/target/jvm/magic.lux +++ b/stdlib/source/lux/target/jvm/magic.lux @@ -1,5 +1,7 @@ (.module: [lux #* + [control + ["." try]] [data [number (#+ hex)]]] ["." // #_ @@ -11,7 +13,7 @@ (def: #export code Magic - (//unsigned.u4 (hex "CAFEBABE"))) + (|> (hex "CAFEBABE") //unsigned.u4 try.assume)) (def: #export writer - //unsigned.u4-writer) + //unsigned.writer/4) diff --git a/stdlib/source/lux/target/jvm/method.lux b/stdlib/source/lux/target/jvm/method.lux index af2d07de7..060ad1bc1 100644 --- a/stdlib/source/lux/target/jvm/method.lux +++ b/stdlib/source/lux/target/jvm/method.lux @@ -5,13 +5,12 @@ ["." equivalence (#+ Equivalence)] ["." monad (#+ do)]] [control - ["." try] - ["." state (#+ State)]] + ["." try]] [data [number (#+) [i64 (#+)]] - [format - [".F" binary (#+ Writer) ("#@." monoid)]] + ["." format #_ + ["#" binary (#+ Writer) ("#@." monoid)]] [collection ["." row (#+ Row)]]] [type @@ -22,10 +21,10 @@ ["#." attribute (#+ Attribute) ["#/." code]] ["#." constant (#+ UTF8) - ["#/." pool (#+ Pool)]] - ["#." instruction (#+ Instruction) - ["#/." condition] - ["#/." bytecode]] + ["#/." pool (#+ Pool Resource)]] + ["#." bytecode (#+ Bytecode) + ["#/." environment] + ["#/." instruction]] ["#." type (#+ Type) ["#/." category] ["#." descriptor (#+ Descriptor)]]]) @@ -52,25 +51,15 @@ ) (def: #export (method modifier name type attributes code) - (-> (Modifier Method) UTF8 (Type //type/category.Method) (List (State Pool Attribute)) (Instruction Any) - (State Pool Method)) - (do state.monad + (-> (Modifier Method) UTF8 (Type //type/category.Method) (List (Resource Attribute)) (Bytecode Any) + (Resource Method)) + (do //constant/pool.monad [@name (//constant/pool.utf8 name) @descriptor (//constant/pool.descriptor (//type.descriptor type)) attributes (monad.seq @ attributes) - ?code (//instruction.resolve code) - [environment exceptions bytecode] (case (do try.monad - [[bytecode exceptions output] ?code - [environment specification] (//instruction/bytecode.run bytecode)] - (wrap [environment exceptions (binaryF.instance specification)])) - (#try.Success [environment exceptions bytecode]) - (wrap [environment exceptions bytecode]) - - (#try.Failure error) - ## TODO: Allow error-management within - ## the monad. - (error! error)) - @code (//attribute.code {#//attribute/code.resources (get@ #//instruction/condition.resources environment) + [environment exceptions instruction output] (//bytecode.resolve code) + #let [bytecode (|> instruction //bytecode/instruction.run format.instance)] + @code (//attribute.code {#//attribute/code.limit (get@ #//bytecode/environment.limit environment) #//attribute/code.code bytecode #//attribute/code.exception-table exceptions #//attribute/code.attributes (row.row)})] @@ -89,12 +78,12 @@ (def: #export (writer field) (Writer Method) - (`` ($_ binaryF@compose + (`` ($_ format@compose (~~ (template [<writer> <slot>] [(<writer> (get@ <slot> field))] [//modifier.writer #modifier] [//index.writer #name] [//index.writer #descriptor] - [(binaryF.row/16 //attribute.writer) #attributes])) + [(format.row/16 //attribute.writer) #attributes])) ))) diff --git a/stdlib/source/lux/target/jvm/modifier.lux b/stdlib/source/lux/target/jvm/modifier.lux index f7024b669..3eafb170a 100644 --- a/stdlib/source/lux/target/jvm/modifier.lux +++ b/stdlib/source/lux/target/jvm/modifier.lux @@ -4,6 +4,7 @@ ["." equivalence (#+ Equivalence)] ["." monoid (#+ Monoid)]] [control + ["." try] ["<>" parser ["<c>" code]]] [data @@ -29,12 +30,13 @@ (template: (!wrap value) (|> value //unsigned.u2 + try.assume :abstraction)) (template: (!unwrap value) (|> value :representation - //unsigned.nat)) + //unsigned.value)) (def: #export code (-> (Modifier Any) //unsigned.U2) @@ -66,7 +68,7 @@ (def: #export writer (All [of] (Writer (Modifier of))) - (|>> :representation //unsigned.u2-writer)) + (|>> :representation //unsigned.writer/2)) ) (syntax: #export (modifiers: ofT {options (<>.many <c>.any)}) diff --git a/stdlib/source/lux/target/jvm/version.lux b/stdlib/source/lux/target/jvm/version.lux index 48d2dcaa9..8d5e40111 100644 --- a/stdlib/source/lux/target/jvm/version.lux +++ b/stdlib/source/lux/target/jvm/version.lux @@ -1,5 +1,7 @@ (.module: - [lux #*] + [lux #* + [control + ["." try]]] ["." // #_ [encoding ["#." unsigned (#+ U2)]]]) @@ -8,12 +10,14 @@ (type: #export Minor Version) (type: #export Major Version) -(def: #export default-minor Minor (//unsigned.u2 0)) +(def: #export default-minor + Minor + (|> 0 //unsigned.u2 try.assume)) (template [<number> <name>] [(def: #export <name> Major - (//unsigned.u2 <number>))] + (|> <number> //unsigned.u2 try.assume))] [45 v1_1] [46 v1_2] @@ -30,4 +34,4 @@ ) (def: #export writer - //unsigned.u2-writer) + //unsigned.writer/2) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/case.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/case.lux index a56629158..e583b36b7 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/case.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/case.lux @@ -11,7 +11,7 @@ [target [jvm ["." constant] - ["_" instruction (#+ Label Instruction) ("#@." monad)] + ["_" bytecode (#+ Label Bytecode) ("#@." monad)] ["." type (#+ Type) [category (#+ Method)]] [encoding @@ -33,7 +33,7 @@ (type.method [(list //type.value) type.boolean (list)])) (def: (pop-alt stack-depth) - (-> Nat (Instruction Any)) + (-> Nat (Bytecode Any)) (.case stack-depth 0 (_@wrap []) 1 _.pop @@ -44,31 +44,31 @@ (pop-alt (n.- 2 stack-depth))))) (def: ldc/integer - (-> (I64 Any) (Instruction Any)) + (-> (I64 Any) (Bytecode Any)) (|>> .i64 i32.i32 constant.integer _.ldc/integer)) (def: ldc/long - (-> (I64 Any) (Instruction Any)) + (-> (I64 Any) (Bytecode Any)) (|>> .int constant.long _.ldc/long)) (def: ldc/double - (-> Frac (Instruction Any)) + (-> Frac (Bytecode Any)) (|>> constant.double _.ldc/double)) (def: peek - (Instruction Any) + (Bytecode Any) ($_ _.compose _.dup (//runtime.get //runtime.stack-head))) (def: pop - (Instruction Any) + (Bytecode Any) ($_ _.compose (//runtime.get //runtime.stack-tail) (_.checkcast //type.stack))) (def: (path' phase stack-depth @else @end path) - (-> Phase Nat Label Label Path (Operation (Instruction Any))) + (-> Phase Nat Label Label Path (Operation (Bytecode Any))) (.case path #synthesis.Pop (operation@wrap ..pop) @@ -214,7 +214,7 @@ )) (def: (path phase path @end) - (-> Phase Path Label (Operation (Instruction Any))) + (-> Phase Path Label (Operation (Bytecode Any))) (do phase.monad [@else //runtime.forge-label pathG (..path' phase 1 @else @end path)] @@ -227,7 +227,7 @@ (_.goto @end))))) (def: #export (if phase conditionS thenS elseS) - (-> Phase Synthesis Synthesis Synthesis (Operation (Instruction Any))) + (-> Phase Synthesis Synthesis Synthesis (Operation (Bytecode Any))) (do phase.monad [conditionG (phase conditionS) thenG (phase thenS) @@ -246,7 +246,7 @@ (_.set-label @end)))))) (def: #export (let phase inputS register bodyS) - (-> Phase Synthesis Register Synthesis (Operation (Instruction Any))) + (-> Phase Synthesis Register Synthesis (Operation (Bytecode Any))) (do phase.monad [inputG (phase inputS) bodyG (phase bodyS)] @@ -256,7 +256,7 @@ bodyG)))) (def: #export (case phase valueS path) - (-> Phase Synthesis Path (Operation (Instruction Any))) + (-> Phase Synthesis Path (Operation (Bytecode Any))) (do phase.monad [@end //runtime.forge-label valueG (phase valueS) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/extension/common.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/extension/common.lux index d8ac81cc4..1fba35532 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/extension/common.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/extension/common.lux @@ -5,9 +5,9 @@ ["." monad (#+ do)]] [control ["." try] + ["." exception (#+ exception:)] ["<>" parser - ["<s>" synthesis (#+ Parser)]] - ["." exception (#+ exception:)]] + ["<s>" synthesis (#+ Parser)]]] [data ["." product] [number @@ -18,7 +18,7 @@ ["." dictionary]]] [target [jvm - ["_" instruction (#+ Label Instruction) ("#@." monad)] + ["_" bytecode (#+ Label Bytecode) ("#@." monad)] ["." constant] [encoding ["." signed (#+ S4)]] @@ -42,7 +42,7 @@ (def: #export (custom [parser handler]) (All [s] (-> [(Parser s) - (-> Text Phase s (Operation (Instruction Any)))] + (-> Text Phase s (Operation (Bytecode Any)))] Handler)) (function (_ extension-name phase input) (case (<s>.run parser input) @@ -63,29 +63,29 @@ (def: $Error (type.class "java.lang.Error" (list))) (def: lux-int - (Instruction Any) + (Bytecode Any) ($_ _.compose _.i2l (///value.wrap type.long))) (def: jvm-int - (Instruction Any) + (Bytecode Any) ($_ _.compose (///value.unwrap type.long) _.l2i)) (def: ensure-string - (Instruction Any) + (Bytecode Any) (_.checkcast $String)) -(def: (predicate instruction) - (-> (-> Label (Instruction Any)) - (Instruction Any)) +(def: (predicate bytecode) + (-> (-> Label (Bytecode Any)) + (Bytecode Any)) (do _.monad [@then _.new-label @end _.new-label] ($_ _.compose - (instruction @then) + (bytecode @then) (_.getstatic $Boolean "FALSE" $Boolean) (_.goto @end) (_.set-label @then) @@ -107,7 +107,7 @@ inputG (phase inputS) elseG (phase elseS) conditionalsG+ (: (Operation (List [(List [S4 Label]) - (Instruction Any)])) + (Bytecode Any)])) (monad.map @ (function (_ [chars branch]) (do @ [branchG (phase branch) @@ -138,14 +138,14 @@ )))))])) (def: (lux::is [referenceG sampleG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose referenceG sampleG (..predicate _.if-acmpeq))) (def: (lux::try riskyG) - (Unary (Instruction Any)) + (Unary (Bytecode Any)) ($_ _.compose riskyG (_.checkcast ///function.class) @@ -160,7 +160,7 @@ (template [<name> <op>] [(def: (<name> [maskG inputG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose inputG (///value.unwrap type.long) maskG (///value.unwrap type.long) @@ -173,7 +173,7 @@ (template [<name> <op>] [(def: (<name> [shiftG inputG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose inputG (///value.unwrap type.long) shiftG ..jvm-int @@ -190,7 +190,7 @@ (template [<name> <const>] [(def: (<name> _) - (Nullary (Instruction Any)) + (Nullary (Bytecode Any)) ($_ _.compose (_.ldc/double (constant.double <const>)) (///value.wrap type.double)))] @@ -202,7 +202,7 @@ (template [<name> <type> <op>] [(def: (<name> [paramG subjectG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose subjectG (///value.unwrap <type>) paramG (///value.unwrap <type>) @@ -224,7 +224,7 @@ (template [<eq> <lt> <type> <cmp>] [(template [<name> <reference>] [(def: (<name> [paramG subjectG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose subjectG (///value.unwrap <type>) paramG (///value.unwrap <type>) @@ -240,12 +240,12 @@ ) (def: (to-string class from) - (-> (Type Class) (Type Primitive) (Instruction Any)) + (-> (Type Class) (Type Primitive) (Bytecode Any)) (_.invokestatic class "toString" (type.method [(list from) ..$String (list)]))) (template [<name> <prepare> <transform>] [(def: (<name> inputG) - (Unary (Instruction Any)) + (Unary (Bytecode Any)) ($_ _.compose inputG <prepare> @@ -318,18 +318,18 @@ (/////bundle.install "decode" (unary ..f64::decode))))) (def: (text::size inputG) - (Unary (Instruction Any)) + (Unary (Bytecode Any)) ($_ _.compose inputG ..ensure-string (_.invokevirtual ..$String "length" (type.method [(list) type.int (list)])) ..lux-int)) -(def: no-op (Instruction Any) (_@wrap [])) +(def: no-op (Bytecode Any) (_@wrap [])) (template [<name> <pre-subject> <pre-param> <op> <post>] [(def: (<name> [paramG subjectG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose subjectG <pre-subject> paramG <pre-param> @@ -347,14 +347,14 @@ ) (def: (text::concat [leftG rightG]) - (Binary (Instruction Any)) + (Binary (Bytecode Any)) ($_ _.compose leftG ..ensure-string rightG ..ensure-string (_.invokevirtual ..$String "concat" (type.method [(list ..$String) ..$String (list)])))) (def: (text::clip [startG endG subjectG]) - (Trinary (Instruction Any)) + (Trinary (Bytecode Any)) ($_ _.compose subjectG ..ensure-string startG ..jvm-int @@ -363,7 +363,7 @@ (def: index-method (type.method [(list ..$String type.int) type.int (list)])) (def: (text::index [startG partG textG]) - (Trinary (Instruction Any)) + (Trinary (Bytecode Any)) (do _.monad [@not-found _.new-label @end _.new-label] @@ -397,7 +397,7 @@ (def: string-method (type.method [(list ..$String) type.void (list)])) (def: (io::log messageG) - (Unary (Instruction Any)) + (Unary (Bytecode Any)) ($_ _.compose (_.getstatic ..$System "out" ..$PrintStream) messageG @@ -406,7 +406,7 @@ ///runtime.unit)) (def: (io::error messageG) - (Unary (Instruction Any)) + (Unary (Bytecode Any)) ($_ _.compose (_.new ..$Error) _.dup @@ -417,7 +417,7 @@ (def: exit-method (type.method [(list type.int) type.void (list)])) (def: (io::exit codeG) - (Unary (Instruction Any)) + (Unary (Bytecode Any)) ($_ _.compose codeG ..jvm-int (_.invokestatic ..$System "exit" ..exit-method) @@ -425,7 +425,7 @@ (def: time-method (type.method [(list) type.long (list)])) (def: (io::current-time _) - (Nullary (Instruction Any)) + (Nullary (Bytecode Any)) ($_ _.compose (_.invokestatic ..$System "currentTimeMillis" ..time-method) (///value.wrap type.long))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux index 6a66f78f8..35137a77b 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function.lux @@ -19,7 +19,7 @@ ["." modifier (#+ Modifier) ("#@." monoid)] ["." field (#+ Field)] ["." method (#+ Method)] - ["_" instruction (#+ Label Instruction) ("#@." monad)] + ["_" bytecode (#+ Label Bytecode) ("#@." monad)] ["." class (#+ Class)] ["." type (#+ Type) [category (#+ Return' Value')] @@ -54,10 +54,10 @@ ["." generation]]]]]) (def: #export (with @begin class environment arity body) - (-> Label External Environment Arity (Instruction Any) + (-> Label External Environment Arity (Bytecode Any) (Operation [(List (State Pool Field)) (List (State Pool Method)) - (Instruction Any)])) + (Bytecode Any)])) (let [classT (type.class class (list)) fields (: (List (State Pool Field)) (list& /arity.constant @@ -91,7 +91,7 @@ (|>> type.reflection reflection.reflection name.internal)) (def: #export (abstraction generate [environment arity bodyS]) - (-> Phase Abstraction (Operation (Instruction Any))) + (-> Phase Abstraction (Operation (Bytecode Any))) (do phase.monad [@begin //runtime.forge-label [function-class bodyG] (generation.with-context @@ -111,7 +111,7 @@ (wrap instance))) (def: #export (apply generate [abstractionS inputsS]) - (-> Phase Apply (Operation (Instruction Any))) + (-> Phase Apply (Operation (Bytecode Any))) (do phase.monad [abstractionG (generate abstractionS) inputsG (monad.map @ generate inputsS)] diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant.lux index 456e46b86..dd8144ea8 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant.lux @@ -1,7 +1,5 @@ (.module: [lux (#- Type type) - [control - [state (#+ State)]] [data [collection ["." row]]] @@ -12,7 +10,7 @@ [type (#+ Type) [category (#+ Value)]] [constant - [pool (#+ Pool)]]]]]) + [pool (#+ Resource)]]]]]) (def: modifier (Modifier Field) @@ -23,5 +21,5 @@ )) (def: #export (constant name type) - (-> Text (Type Value) (State Pool Field)) + (-> Text (Type Value) (Resource Field)) (field.field ..modifier name type (row.row))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant/arity.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant/arity.lux index 589d9c43d..d4d1a2a68 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant/arity.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/constant/arity.lux @@ -1,13 +1,11 @@ (.module: [lux (#- type) - [control - [state (#+ State)]] [target [jvm ["." type] ["." field (#+ Field)] [constant - [pool (#+ Pool)]]]]] + [pool (#+ Resource)]]]]] ["." // [/////// [arity (#+ Arity)]]]) @@ -19,5 +17,5 @@ (def: #export maximum Arity 8) (def: #export constant - (State Pool Field) + (Resource Field) (//.constant ..name ..type)) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/variable/partial/count.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/variable/partial/count.lux index 4806e3ba1..579a63992 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/variable/partial/count.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/function/field/variable/partial/count.lux @@ -1,8 +1,10 @@ (.module: [lux (#- type) + [control + ["." try]] [target [jvm - ["_" instruction (#+ Instruction)] + ["_" bytecode (#+ Bytecode)] [encoding [name (#+ External)] ["." unsigned]] @@ -14,14 +16,14 @@ (def: #export type type.int) (def: #export initial - (Instruction Any) - (_.bipush (unsigned.u1 0))) + (Bytecode Any) + (|> 0 unsigned.u1 try.assume _.bipush)) (def: this _.aload-0) (def: #export value - (Instruction Any) + (Bytecode Any) ($_ _.compose ..this (_.getfield /////abstract.class ..field ..type) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/loop.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/loop.lux index 6e7ac6f23..371b900a7 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/loop.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/loop.lux @@ -12,7 +12,7 @@ ["." list ("#@." functor)]]] [target [jvm - ["_" instruction (#+ Label Instruction) ("#@." monad)] + ["_" bytecode (#+ Label Bytecode) ("#@." monad)] [encoding ["." unsigned]]]]] ["." // #_ @@ -37,7 +37,7 @@ (_@wrap [])) (def: #export (recur translate updatesS) - (-> Phase (List Synthesis) (Operation (Instruction Any))) + (-> Phase (List Synthesis) (Operation (Bytecode Any))) (do phase.monad [[@begin offset] generation.anchor updatesG (|> updatesS @@ -71,7 +71,7 @@ (_.goto @begin))))) (def: #export (scope translate [offset initsS+ iterationS]) - (-> Phase [Nat (List Synthesis) Synthesis] (Operation (Instruction Any))) + (-> Phase [Nat (List Synthesis) Synthesis] (Operation (Bytecode Any))) (do phase.monad [@begin //runtime.forge-label initsI+ (monad.map @ translate initsS+) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/primitive.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/primitive.lux index f17b3f2d1..946ea34d5 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/primitive.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/primitive.lux @@ -5,7 +5,7 @@ [target [jvm ["." constant] - ["_" instruction (#+ Instruction)] + ["_" bytecode (#+ Bytecode)] ["." type]]] [macro ["." template]]] @@ -17,12 +17,12 @@ (def: $Double (type.class "java.lang.Double" (list))) (def: #export (bit value) - (-> Bit (Instruction Any)) + (-> Bit (Bytecode Any)) (_.getstatic $Boolean (if value "TRUE" "FALSE") $Boolean)) (template [<name> <inputT> <ldc> <class> <inputD>] [(def: #export (<name> value) - (-> <inputT> (Instruction Any)) + (-> <inputT> (Bytecode Any)) (do _.monad [_ (`` (|> value (~~ (template.splice <ldc>))))] (_.invokestatic <class> "valueOf" (type.method [(list <inputD>) <class> (list)]))))] @@ -31,4 +31,4 @@ [f64 Frac [constant.double _.ldc/double] $Double type.double] ) -(def: #export text _.ldc/string) +(def: #export text _.string) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/reference.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/reference.lux index 6c9a963d7..a5c4c3156 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/reference.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/reference.lux @@ -12,7 +12,7 @@ ["." generation]]]] [target [jvm - ["_" instruction (#+ Instruction)] + ["_" bytecode (#+ Bytecode)] ["." type] [encoding ["." unsigned]]]]] @@ -22,11 +22,11 @@ ["#." type]]) (def: local - (-> Register (Instruction Any)) + (-> Register (Bytecode Any)) (|>> unsigned.u1 _.aload)) (def: #export this - (Instruction Any) + (Bytecode Any) _.aload-0) (template [<name> <prefix>] @@ -39,7 +39,7 @@ ) (def: (foreign variable) - (-> Register (Operation (Instruction Any))) + (-> Register (Operation (Bytecode Any))) (do phase.monad [function-class generation.context] (wrap ($_ _.compose @@ -49,7 +49,7 @@ //type.value))))) (def: #export (variable variable) - (-> Variable (Operation (Instruction Any))) + (-> Variable (Operation (Bytecode Any))) (case variable (#reference.Local variable) (operation@wrap (..local variable)) @@ -58,7 +58,7 @@ (..foreign variable))) (def: #export (constant name) - (-> Name (Operation (Instruction Any))) + (-> Name (Operation (Bytecode Any))) (do phase.monad [bytecode-name (generation.remember name)] (wrap (_.getstatic (type.class bytecode-name (list)) //value.field //type.value)))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/runtime.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/runtime.lux index a47892039..384193d99 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/runtime.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/runtime.lux @@ -3,7 +3,7 @@ [abstract ["." monad (#+ do)]] [control - [state (#+ State)]] + ["." try]] [data [binary (#+ Binary)] [number @@ -13,18 +13,18 @@ [collection ["." list ("#@." functor)] ["." row]] - [format - [".F" binary]]] + ["." format #_ + ["#" binary]]] [target [jvm - ["_" instruction (#+ Label Instruction)] + ["_" bytecode (#+ Label Bytecode)] ["." modifier (#+ Modifier) ("#@." monoid)] ["." field (#+ Field)] ["." method (#+ Method)] ["." version] ["." class (#+ Class)] ["." constant - [pool (#+ Pool)]] + [pool (#+ Resource)]] [encoding ["." unsigned] ["." name]] @@ -57,7 +57,7 @@ (template [<name> <base>] [(type: #export <name> - (<base> Anchor (Instruction Any) Definition))] + (<base> Anchor (Bytecode Any) Definition))] [Operation ///.Operation] [Phase ///.Phase] @@ -66,12 +66,12 @@ ) (type: #export (Generator i) - (-> Phase i (Operation (Instruction Any)))) + (-> Phase i (Operation (Bytecode Any)))) (def: #export class (type.class "LuxRuntime" (list))) (def: procedure - (-> Text (Type category.Method) (Instruction Any)) + (-> Text (Type category.Method) (Bytecode Any)) (_.invokestatic ..class)) (def: modifier @@ -83,28 +83,28 @@ )) (def: local - (-> Nat (Instruction Any)) - (|>> unsigned.u1 _.aload)) + (-> Nat (Bytecode Any)) + (|>> unsigned.u1 try.assume _.aload)) (def: this - (Instruction Any) + (Bytecode Any) _.aload-0) (def: #export (get index) - (-> (Instruction Any) (Instruction Any)) + (-> (Bytecode Any) (Bytecode Any)) ($_ _.compose index _.aaload)) (def: (set! index value) - (-> (Instruction Any) (Instruction Any) (Instruction Any)) + (-> (Bytecode Any) (Bytecode Any) (Bytecode Any)) ($_ _.compose _.dup index value _.aastore)) -(def: #export unit (_.ldc/string synthesis.unit)) +(def: #export unit (_.string synthesis.unit)) (def: variant::name "variant") (def: variant::type (type.method [(list //type.tag //type.flag //type.value) //type.variant (list)])) @@ -137,7 +137,7 @@ (def: #export right-flag ..unit) (def: #export left-injection - (Instruction Any) + (Bytecode Any) ($_ _.compose _.iconst-0 ..left-flag @@ -146,7 +146,7 @@ ..variant)) (def: #export right-injection - (Instruction Any) + (Bytecode Any) ($_ _.compose _.iconst-1 ..right-flag @@ -157,7 +157,7 @@ (def: #export some-injection ..right-injection) (def: #export none-injection - (Instruction Any) + (Bytecode Any) ($_ _.compose _.iconst-0 _.aconst-null @@ -165,7 +165,7 @@ ..variant)) (def: (risky $unsafe) - (-> (Instruction Any) (Instruction Any)) + (-> (Bytecode Any) (Bytecode Any)) (do _.monad [@from _.new-label @to _.new-label @@ -196,31 +196,31 @@ (//value.wrap type.double))))) (def: #export log! - (Instruction Any) + (Bytecode Any) (let [^PrintStream (type.class "java.io.PrintStream" (list)) ^System (type.class "java.lang.System" (list)) out (_.getstatic ^System "out" ^PrintStream) print-type (type.method [(list //type.value) type.void (list)]) print! (function (_ method) (_.invokevirtual ^PrintStream method print-type))] ($_ _.compose - out (_.ldc/string "LOG: ") (print! "print") + out (_.string "LOG: ") (print! "print") out _.swap (print! "println")))) (def: exception-constructor (type.method [(list //type.text) type.void (list)])) (def: (illegal-state-exception message) - (-> Text (Instruction Any)) + (-> Text (Bytecode Any)) (let [^IllegalStateException (type.class "java.lang.IllegalStateException" (list))] ($_ _.compose (_.new ^IllegalStateException) _.dup - (_.ldc/string message) + (_.string message) (_.invokespecial ^IllegalStateException "<init>" ..exception-constructor)))) (def: failure::type (type.method [(list) type.void (list)])) (def: (failure name message) - (-> Text Text (State Pool Method)) + (-> Text Text (Resource Method)) (method.method ..modifier name ..failure::type (list) @@ -295,7 +295,7 @@ $variant ::value (_.checkcast //type.variant) _.astore-0) - recur (: (-> Label (Instruction Any)) + recur (: (-> Label (Bytecode Any)) (function (_ @loop-start) ($_ _.compose update-$tag @@ -352,7 +352,7 @@ (def: #export right-projection (..procedure ..right-projection::name ..projection-type)) (def: projection::method2 - [(State Pool Method) (State Pool Method)] + [(Resource Method) (Resource Method)] (let [$tuple _.aload-0 $tuple::size ($_ _.compose $tuple _.arraylength) @@ -368,7 +368,7 @@ update-$tuple ($_ _.compose $tuple $last-right _.aaload (_.checkcast //type.tuple) _.astore-0) - recur (: (-> Label (Instruction Any)) + recur (: (-> Label (Bytecode Any)) (function (_ @loop) ($_ _.compose update-$lefts @@ -490,16 +490,16 @@ (-> (Type (<| Return' Value' category)) Text)) (|>> type.reflection reflection.reflection)) -(def: #export ^Object (type.class "java.lang.Object" (list))) - (def: translate-runtime (Operation Any) - (let [class (..reflection ..class) + (let [^Object (type.class "java.lang.Object" (list)) + class (..reflection ..class) modifier (: (Modifier Class) ($_ modifier@compose class.public class.final)) - bytecode (<| (binaryF.run class.writer) + bytecode (<| (format.run class.writer) + try.assume (class.class version.v6_0 modifier (name.internal class) @@ -554,7 +554,7 @@ (let [$partials _.iload-1] ($_ _.compose ..this - (_.invokespecial ..^Object "<init>" (type.method [(list) type.void (list)])) + (_.invokespecial ^Object "<init>" (type.method [(list) type.void (list)])) ..this $partials (_.putfield //function.class //function/count.field //function/count.type) @@ -564,16 +564,17 @@ class.public class.abstract)) class (..reflection //function.class) - partial-count (: (State Pool Field) + partial-count (: (Resource Field) (field.field (modifier@compose field.public field.final) //function/count.field //function/count.type (row.row))) - bytecode (<| (binaryF.run class.writer) + bytecode (<| (format.run class.writer) + try.assume (class.class version.v6_0 modifier (name.internal class) - (name.internal (..reflection ..^Object)) (list) + (name.internal (..reflection ^Object)) (list) (list partial-count) (list& <init>::method apply::method+) (row.row)))] @@ -592,5 +593,5 @@ (let [shift (n./ 4 i64.width)] ## This shift is done to avoid the possibility of forged labels ## to be in the range of the labels that are generated automatically - ## during the evaluation of Instruction expressions. + ## during the evaluation of Bytecode expressions. (:: ////.monad map (i64.left-shift shift) ///.next))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/structure.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/structure.lux index b75c646e8..b48711dd0 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/structure.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/structure.lux @@ -10,7 +10,7 @@ [target [jvm ["." constant] - ["_" instruction (#+ Instruction)] + ["_" bytecode (#+ Bytecode)] ["." type]]]] ["." // #_ ["#." runtime (#+ Operation Phase Generator)] @@ -22,7 +22,7 @@ (def: $Object (type.class "java.lang.Object" (list))) -(def: unitG (Instruction Any) (//primitive.text /////synthesis.unit)) +(def: unitG (Bytecode Any) (//primitive.text /////synthesis.unit)) (template: (!integer <value>) (|> <value> .i64 i32.i32 constant.integer)) @@ -54,7 +54,7 @@ (monad.seq @ membersI)))))) (def: (flagG right?) - (-> Bit (Instruction Any)) + (-> Bit (Bytecode Any)) (if right? ..unitG _.aconst-null)) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/jvm/value.lux b/stdlib/source/lux/tool/compiler/phase/generation/jvm/value.lux index e6deaf205..462c625c9 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/jvm/value.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/jvm/value.lux @@ -2,7 +2,7 @@ [lux (#- Type type) [target [jvm - ["_" instruction (#+ Instruction)] + ["_" bytecode (#+ Bytecode)] ["." type (#+ Type) ("#@." equivalence) [category (#+ Primitive)] ["." box]]]]]) @@ -35,13 +35,13 @@ ) (def: #export (wrap type) - (-> (Type Primitive) (Instruction Any)) + (-> (Type Primitive) (Bytecode Any)) (let [wrapper (type.class (primitive-wrapper type) (list))] (_.invokestatic wrapper "valueOf" (type.method [(list type) wrapper (list)])))) (def: #export (unwrap type) - (-> (Type Primitive) (Instruction Any)) + (-> (Type Primitive) (Bytecode Any)) (let [wrapper (type.class (primitive-wrapper type) (list))] ($_ _.compose (_.checkcast wrapper) |