100% found this document useful (1 vote)

476 views1,086 pages

Clojure

Uploaded by

beisenberg

Available Formats

Download as PDF, TXT or read online on Scribd

Download as pdf or txt

100% found this document useful (1 vote)

476 views1,086 pages

Clojure

Uploaded by

beisenberg

Available Formats

Download as PDF, TXT or read online on Scribd

Download as pdf or txt

You are on page 1/ 1086

Clojure In Small Pieces

Rich Hickey

Juozas Baliuka, Eric Bruneton, Stuart Halloway,

Chris Houser, Eugene Kuleshov, Chris Nokleberg

Timothy Daly (Editor)

Contents

1 From ideas to implementation 1

1.1 Starting from Java . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Extends and Implements . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Persistent Red Black Trees . . . . . . . . . . . . . . . . . . . . . 1
1.3.1 defclass Node . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3.2 defclass Black . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3.3 defclass BlackVal . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.4 defclass BlackBranch . . . . . . . . . . . . . . . . . . . . . 4
1.3.5 defclass BlackBranchVal . . . . . . . . . . . . . . . . . . . 5
1.3.6 defclass Red . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.7 defclass RedVal . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.8 defclass RedBranch . . . . . . . . . . . . . . . . . . . . . . 7
1.3.9 defclass RedBranchVal . . . . . . . . . . . . . . . . . . . . 8
1.3.10 defclass PersistentTreeMap . . . . . . . . . . . . . . . . . 9
1.4 Immutable Data Structures . . . . . . . . . . . . . . . . . . . . . 9
1.4.1 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.2 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.3 Hashmaps . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.4 Seqs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.5 defclass Seq . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Java Interoperability . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.7 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.8 Argument Deconstruction . . . . . . . . . . . . . . . . . . . . . . 12
1.9 The Read-Eval-Print Loop . . . . . . . . . . . . . . . . . . . . . . 12
1.10 Special Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.11 Reader Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.12 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.13 Dynamic Comopilation . . . . . . . . . . . . . . . . . . . . . . . . 12
1.14 Ahead-Of-Time Comopilation . . . . . . . . . . . . . . . . . . . . 12
1.15 Lazy Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.16 Metadata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.17 Concurrency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.18 Software Transactional Memory . . . . . . . . . . . . . . . . . . . 12

i
ii CONTENTS

1.19 Vars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.20 Atoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.21 Refs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.22 Agents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.23 Promise and Deliver . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.24 Futures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.25 MultiMethods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.26 Prototypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.27 Proxies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.28 Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.29 Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.29.1 defclass NodeIterator . . . . . . . . . . . . . . . . . . . . . 12
1.29.2 defclass KeyIterator . . . . . . . . . . . . . . . . . . . . . 13
1.29.3 defclass ValIterator . . . . . . . . . . . . . . . . . . . . . . 14
1.30 Generating Java Classes . . . . . . . . . . . . . . . . . . . . . . . 15
1.31 Type Hints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.32 Native Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2 Writing Idiomatic Clojure 17

3 The Ants Demo 19

4 Parallel Processing 21
4.1 MPI Message Passing . . . . . . . . . . . . . . . . . . . . . . . . 21
4.1.1 The N-colony Ant Demo . . . . . . . . . . . . . . . . . . . 21
4.2 MapReduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5 The ant build sequence 23

5.1 ant.build . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.2 The Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

6 jvm/clojure/asm/ 43
6.1 AnnotationVisitor.java . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2 AnnotationWriter.java . . . . . . . . . . . . . . . . . . . . . . . . 45
6.3 Attribute.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.4 ByteVector.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.5 ClassAdapter.java . . . . . . . . . . . . . . . . . . . . . . . . . . 63
6.6 ClassReader.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
6.7 ClassVisitor.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.8 ClassWriter.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
6.9 Edge.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
6.10 FieldVisitor.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
6.11 FieldWriter.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
6.12 Frame.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
6.13 Handler.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
6.14 Item.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
CONTENTS iii

6.15 Label.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

6.16 MethodAdapter.java . . . . . . . . . . . . . . . . . . . . . . . . . 194
6.17 MethodVisitor.java . . . . . . . . . . . . . . . . . . . . . . . . . . 197
6.18 MethodWriter.java . . . . . . . . . . . . . . . . . . . . . . . . . . 206
6.19 Opcodes.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
6.20 Type.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

7 jvm/clojure/asm/commons 293
7.1 AdviceAdapter.java . . . . . . . . . . . . . . . . . . . . . . . . . . 293
7.2 AnalyzerAdapter.java . . . . . . . . . . . . . . . . . . . . . . . . 306
7.3 CodeSizeEvaluator.java . . . . . . . . . . . . . . . . . . . . . . . 325
7.4 EmptyVisitor.java . . . . . . . . . . . . . . . . . . . . . . . . . . 329
7.5 GeneratorAdapter.java . . . . . . . . . . . . . . . . . . . . . . . . 333
7.6 LocalVariablesSorter.java . . . . . . . . . . . . . . . . . . . . . . 364
7.7 Method.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
7.8 SerialVersionUIDAdder.java . . . . . . . . . . . . . . . . . . . . . 376
7.9 StaticInitMerger.java . . . . . . . . . . . . . . . . . . . . . . . . . 386
7.10 TableSwitchGenerator.java . . . . . . . . . . . . . . . . . . . . . 388

8 jvm/clojure/lang/ 389
8.1 AFn.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
8.2 AFunction.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
8.3 Agent.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
8.4 AMapEntry.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
8.5 APersistentMap.java . . . . . . . . . . . . . . . . . . . . . . . . . 410
8.6 APersistentSet.java . . . . . . . . . . . . . . . . . . . . . . . . . . 417
8.7 APersistentVector.java . . . . . . . . . . . . . . . . . . . . . . . . 421
8.8 AReference.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
8.9 ARef.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
8.10 ArityException.java . . . . . . . . . . . . . . . . . . . . . . . . . 435
8.11 ArrayChunk.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
8.12 ArraySeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
8.13 ASeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
8.14 Associative.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
8.15 Atom.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
8.16 ATransientMap.java . . . . . . . . . . . . . . . . . . . . . . . . . 458
8.17 ATransientSet.java . . . . . . . . . . . . . . . . . . . . . . . . . . 460
8.18 BigInt.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
8.19 Binding.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
8.20 Box.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
8.21 ChunkBuffer.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
8.22 ChunkedCons.java . . . . . . . . . . . . . . . . . . . . . . . . . . 466
8.23 Compile.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
8.24 Compiler.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
8.25 Cons.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
8.26 Counted.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
iv CONTENTS

8.27 Delay.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647

8.28 DynamicClassLoader.java . . . . . . . . . . . . . . . . . . . . . . 648
8.29 EnumerationSeq.java . . . . . . . . . . . . . . . . . . . . . . . . . 649
8.30 Fn.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
8.31 IChunk.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
8.32 IChunkedSeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
8.33 IDeref.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
8.34 IEditableCollection.java . . . . . . . . . . . . . . . . . . . . . . . 652
8.35 IFn.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
8.36 IKeywordLookup.java . . . . . . . . . . . . . . . . . . . . . . . . 675
8.37 ILookup.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
8.38 ILookupSite.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 676
8.39 ILookupThunk.java . . . . . . . . . . . . . . . . . . . . . . . . . . 676
8.40 IMapEntry.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676
8.41 IMeta.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
8.42 Indexed.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
8.43 IndexedSeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678
8.44 IObj.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678
8.45 IPersistentCollection.java . . . . . . . . . . . . . . . . . . . . . . 678
8.46 IPersistentList.java . . . . . . . . . . . . . . . . . . . . . . . . . . 679
8.47 IPersistentMap.java . . . . . . . . . . . . . . . . . . . . . . . . . 679
8.48 IPersistentSet.java . . . . . . . . . . . . . . . . . . . . . . . . . . 680
8.49 IPersistentStack.java . . . . . . . . . . . . . . . . . . . . . . . . . 680
8.50 IPersistentVector.java . . . . . . . . . . . . . . . . . . . . . . . . 680
8.51 IPromiseImpl.java . . . . . . . . . . . . . . . . . . . . . . . . . . 681
8.52 IProxy.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
8.53 IReduce.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
8.54 IReference.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
8.55 IRef.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
8.56 ISeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
8.57 IteratorSeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
8.58 ITransientAssociative.java . . . . . . . . . . . . . . . . . . . . . . 685
8.59 ITransientCollection.java . . . . . . . . . . . . . . . . . . . . . . . 685
8.60 ITransientMap.java . . . . . . . . . . . . . . . . . . . . . . . . . . 686
8.61 ITransientSet.java . . . . . . . . . . . . . . . . . . . . . . . . . . 686
8.62 ITransientVector.java . . . . . . . . . . . . . . . . . . . . . . . . . 687
8.63 Keyword.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
8.64 KeywordLookupSite.java . . . . . . . . . . . . . . . . . . . . . . . 693
8.65 LazilyPersistentVector.java . . . . . . . . . . . . . . . . . . . . . 694
8.66 LazySeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695
8.67 LineNumberingPushbackReader.java . . . . . . . . . . . . . . . . 700
8.68 LispReader.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
8.69 LockingTransaction.java . . . . . . . . . . . . . . . . . . . . . . . 727
8.70 MapEntry.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
8.71 MapEquivalence.java . . . . . . . . . . . . . . . . . . . . . . . . . 741
8.72 MethodImplCache.java . . . . . . . . . . . . . . . . . . . . . . . . 741
CONTENTS v

8.73 MultiFn.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743

8.74 Named.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752
8.75 Namespace.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752
8.76 Numbers.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757
8.77 Obj.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
8.78 PersistentArrayMap.java . . . . . . . . . . . . . . . . . . . . . . . 838
8.79 PersistentHashMap.java . . . . . . . . . . . . . . . . . . . . . . . 845
8.80 PersistentHashSet.java . . . . . . . . . . . . . . . . . . . . . . . . 870
8.81 PersistentList.java . . . . . . . . . . . . . . . . . . . . . . . . . . 873
8.82 PersistentQueue.java . . . . . . . . . . . . . . . . . . . . . . . . . 879
8.83 PersistentStructMap.java . . . . . . . . . . . . . . . . . . . . . . 886
8.84 PersistentTreeMap.java . . . . . . . . . . . . . . . . . . . . . . . 891
8.85 PersistentTreeSet.java . . . . . . . . . . . . . . . . . . . . . . . . 904
8.86 PersistentVector.java . . . . . . . . . . . . . . . . . . . . . . . . . 906
8.87 ProxyHandler.java . . . . . . . . . . . . . . . . . . . . . . . . . . 922
8.88 Range.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 923
8.89 Ratio.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
8.90 Ref.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 926
8.91 Reflector.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935
8.92 Repl.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 946
8.93 RestFn.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 946
8.94 Reversible.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977
8.95 RT.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977
8.96 Script.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1020
8.97 SeqEnumeration.java . . . . . . . . . . . . . . . . . . . . . . . . . 1021
8.98 SeqIterator.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1021
8.99 Seqable.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022
8.100Sequential.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022
8.101Settable.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1023
8.102Sorted.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1023
8.103StringSeq.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024
8.104Symbol.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025
8.105TransactionalHashMap.java . . . . . . . . . . . . . . . . . . . . . 1027
8.106Util.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
8.107Var.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1034
8.108XMLHandler.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
8.109clojure.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1049

9 jvm/clojure 1051
9.1 main.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1051

10 clj/clojure/ 1053
10.1 core.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
10.2 core/protocols.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
10.3 main.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
10.4 set.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054
vi CONTENTS

10.5 xml.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054

10.6 zip.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054
10.7 inspector.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054
10.8 walk.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054
10.9 stacktrace.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
10.10template.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
10.11test.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
10.12test/tap.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
10.13test/junit.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
10.14pprint.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056
10.15java/io.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056
10.16repl.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056
10.17java/browse.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056
10.18java/javadoc.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056
10.19java/shell.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
10.20java/browse-ui.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
10.21string.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
10.22data.clj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
10.23clj/clojre/reflect.clj . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
10.23.1 reflect/java.clj . . . . . . . . . . . . . . . . . . . . . . . . 1060

11 Copyright and Licenses 1067

12 Index 1077
CONTENTS vii

Foreword

This is a literate fork of Clojure, invented by Rich Hickey. Every effort is made
to give credit for any and all contributions.
Clojure is a break with the past traditions of Lisp. This literate fork is a break
with the past traditions of code development.

Tim Daly
December 28, 2010 ((iHy))
Chapter 1

From ideas to
implementation

1.1 Starting from Java

1.2 Extends and Implements

1.3 Persistent Red Black Trees

There is a special kind of binary search tree called a red-black tree. It has the
property that the longest path from the root to any leaf is no more than twice
as long as the shortest path from the root to any other leaf.
In order to guarantee this property we construct a tree such that no two con-
nected nodes are red. The longest possible path will alternate red and black
nodes. The shortest path will be all black. Thus, the two paths will differ by at
most twice the length.
Since Clojure uses persistent trees the actual tree is new, not a modified tree.
(p9) PersistentTreeMap implements several subclasses to support the interop-
erability with the rest of Clojure. These will not be explained here. Refer to
the other sections of this document for more details. In particular, see (p12)
Iterators for methods of iterating across keys and values. See (p9) Seqs for
information about manipulating sequences over tree maps.

1.3.1 defclass Node

— PersistentTreeMap Node Class —

1
2 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION

static abstract class Node extends AMapEntry{

final Object key;

Node(Object key){
this.key = key;
}

public Object key(){

return key;
}

public Object val(){

return null;
}

public Object getKey(){

return key();
}

public Object getValue(){

return val();
}

Node left(){
return null;
}

Node right(){
return null;
}

abstract Node addLeft(Node ins);

abstract Node addRight(Node ins);

abstract Node removeLeft(Node del);

abstract Node removeRight(Node del);

abstract Node blacken();

abstract Node redden();

Node balanceLeft(Node parent){

return black(parent.key, parent.val(), this, parent.right());
}

Node balanceRight(Node parent){

return black(parent.key, parent.val(), parent.left(), this);
}
1.3. PERSISTENT RED BLACK TREES 3

abstract Node replace(Object key, Object val,

Node left, Node right);

———-

1.3.2 defclass Black

— PersistentTreeMap Black Class —

static class Black extends Node{

public Black(Object key){
super(key);
}

Node addLeft(Node ins){

return ins.balanceLeft(this);
}

Node addRight(Node ins){

return ins.balanceRight(this);
}

Node removeLeft(Node del){

return balanceLeftDel(key, val(), del, right());
}

Node removeRight(Node del){

return balanceRightDel(key, val(), left(), del);
}

Node blacken(){
return this;
}

Node redden(){
return new Red(key);
}

Node replace(Object key, Object val, Node left, Node right){

return black(key, val, left, right);
}

}
4 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION

———-

1.3.3 defclass BlackVal

— PersistentTreeMap BlackVal Class —

static class BlackVal extends Black{

final Object val;

public BlackVal(Object key, Object val){

super(key);
this.val = val;
}

public Object val(){

return val;
}

Node redden(){
return new RedVal(key, val);
}

———-

1.3.4 defclass BlackBranch

— PersistentTreeMap BlackBranch Class —

static class BlackBranch extends Black{

final Node left;

final Node right;

public BlackBranch(Object key, Node left, Node right){

super(key);
this.left = left;
this.right = right;
}

public Node left(){

return left;
}
1.3. PERSISTENT RED BLACK TREES 5

public Node right(){

return right;
}

Node redden(){
return new RedBranch(key, left, right);
}

———-

1.3.5 defclass BlackBranchVal

— PersistentTreeMap BlackBranchVal Class —

static class BlackBranchVal extends BlackBranch{

final Object val;

public BlackBranchVal(Object key, Object val,

Node left, Node right){
super(key, left, right);
this.val = val;
}

public Object val(){

return val;
}

Node redden(){
return new RedBranchVal(key, val, left, right);
}

———-

1.3.6 defclass Red

— PersistentTreeMap Red Class —

static class Red extends Node{

6 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION

public Red(Object key){

super(key);
}

Node addLeft(Node ins){

return red(key, val(), ins, right());
}

Node addRight(Node ins){

return red(key, val(), left(), ins);
}

Node removeLeft(Node del){

return red(key, val(), del, right());
}

Node removeRight(Node del){

return red(key, val(), left(), del);
}

Node blacken(){
return new Black(key);
}

Node redden(){
throw new UnsupportedOperationException("Invariant violation");
}

Node replace(Object key, Object val, Node left, Node right){

return red(key, val, left, right);
}

———-

1.3.7 defclass RedVal

— PersistentTreeMap RedVal Class —

static class RedVal extends Red{

final Object val;

public RedVal(Object key, Object val){

super(key);
this.val = val;
}
1.3. PERSISTENT RED BLACK TREES 7

public Object val(){

return val;
}

Node blacken(){
return new BlackVal(key, val);
}

———-

1.3.8 defclass RedBranch

— PersistentTreeMap RedBranch Class —

static class RedBranch extends Red{

final Node left;

final Node right;

public RedBranch(Object key, Node left, Node right){

super(key);
this.left = left;
this.right = right;
}

public Node left(){

return left;
}

public Node right(){

return right;
}

Node balanceLeft(Node parent){

if(left instanceof Red)
return red(key, val(), left.blacken(),
black(parent.key, parent.val(),
right, parent.right()));
else if(right instanceof Red)
return red(right.key, right.val(),
black(key, val(), left, right.left()),
black(parent.key, parent.val(),
right.right(), parent.right()));
else
8 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION

return super.balanceLeft(parent);

Node balanceRight(Node parent){

if(right instanceof Red)
return red(key, val(),
black(parent.key, parent.val(),
parent.left(), left),
right.blacken());
else if(left instanceof Red)
return red(left.key, left.val(),
black(parent.key, parent.val(),
parent.left(), left.left()),
black(key, val(), left.right(), right));
else
return super.balanceRight(parent);
}

Node blacken(){
return new BlackBranch(key, left, right);
}

———-

1.3.9 defclass RedBranchVal

— PersistentTreeMap RedBranchVal Class —

static class RedBranchVal extends RedBranch{

final Object val;

public RedBranchVal(Object key, Object val, Node left, Node right){

super(key, left, right);
this.val = val;
}

public Object val(){

return val;
}

Node blacken(){
return new BlackBranchVal(key, val, left, right);
}
}
1.4. IMMUTABLE DATA STRUCTURES 9

———-

1.3.10 defclass PersistentTreeMap

1.4 Immutable Data Structures

1.4.1 Lists

1.4.2 Vectors

1.4.3 Hashmaps

1.4.4 Seqs

1.4.5 defclass Seq

— PersistentTreeMap Seq Class —

static public class Seq extends ASeq{

final ISeq stack;
final boolean asc;
final int cnt;

public Seq(ISeq stack, boolean asc){

this.stack = stack;
this.asc = asc;
this.cnt = -1;
}

public Seq(ISeq stack, boolean asc, int cnt){

this.stack = stack;
this.asc = asc;
this.cnt = cnt;
}

Seq(IPersistentMap meta, ISeq stack, boolean asc, int cnt){

super(meta);
this.stack = stack;
this.asc = asc;
this.cnt = cnt;
}

static Seq create(Node t, boolean asc, int cnt){

10 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION

return new Seq(push(t, null, asc), asc, cnt);

}

static ISeq push(Node t, ISeq stack, boolean asc){

while(t != null)
{
stack = RT.cons(t, stack);
t = asc ? t.left() : t.right();
}
return stack;
}

public Object first(){

return stack.first();
}

public ISeq next(){

Node t = (Node) stack.first();
ISeq nextstack =
push(asc ? t.right() : t.left(), stack.next(), asc);
if(nextstack != null)
{
return new Seq(nextstack, asc, cnt - 1);
}
return null;
}

public int count(){

if(cnt < 0)
return super.count();
return cnt;
}

public Obj withMeta(IPersistentMap meta){

return new Seq(meta, stack, asc, cnt);
}
}

———-
1.4. IMMUTABLE DATA STRUCTURES 11
12 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION

1.5 Records

1.6 Java Interoperability

1.7 Recursion

1.8 Argument Deconstruction

1.9 The Read-Eval-Print Loop

1.10 Special Forms

1.11 Reader Macros

1.12 Namespaces

1.13 Dynamic Comopilation

1.14 Ahead-Of-Time Comopilation

1.15 Lazy Evaluation

1.16 Metadata

1.17 Concurrency

1.18 Software Transactional Memory

1.19 Vars

1.20 Atoms

1.21 Refs

1.22 Agents

1.23 Promise and Deliver

1.24 Futures

1.25 MultiMethods

1.26 Prototypes

1.27 Proxies
1.29. ITERATORS 13

— PersistentTreeMap NodeIterator Class —

static public class NodeIterator implements Iterator{

Stack stack = new Stack();
boolean asc;

NodeIterator(Node t, boolean asc){

this.asc = asc;
push(t);
}

16 CHAPTER 1. FROM IDEAS TO IMPLEMENTATION
Chapter 2

Writing Idiomatic Clojure

17
18 CHAPTER 2. WRITING IDIOMATIC CLOJURE
Chapter 3

The Ants Demo

19
20 CHAPTER 3. THE ANTS DEMO
Chapter 4

Parallel Processing

4.1 MPI Message Passing

4.1.1 The N-colony Ant Demo

4.2 MapReduce

21
22 CHAPTER 4. PARALLEL PROCESSING
Chapter 5

The ant build sequence

5.1 ant.build

— build.xml —
<project name="clojure" default="all" xmlns:mvn="urn:maven-artifact-ant">

<description>
Build with "ant jar" and then start the
REPL with: "java -cp clojure.jar clojure.main".
You will need to install the Maven Ant
Tasks to ${ant.home}/lib in order to execute
the nightly-build or stable-build targets.
</description>

<property name="src" location="src"/>

23
24 CHAPTER 5. THE ANT BUILD SEQUENCE

<property name="cvm" value="${clojure.version.major}"/>

<filterset id="clojure-version-filterset">
<filter token="clojure-version" value="${clojure.version.label}"/>
</filterset>

<property name="clojure_noversion_jar" location="clojure.jar"/>

<property name="slim_noversion_jar" location="clojure-slim.jar"/>
<property name="src_noversion_jar" location="clojure-sources.jar"/>
<property name="clojure_jar"
location="clojure-${clojure.version.label}.jar"/>
<property name="slim_jar"
location="clojure-slim-${clojure.version.label}.jar"/>
<property name="src_jar"
5.1. ANT.BUILD 25

location="clojure-sources-${clojure.version.label}.jar"/>

<target name="init" depends="clean">

<target name="compile-java" depends="init"

description="Compile Java sources.">
<javac srcdir="${jsrc}" destdir="${build}" includeJavaRuntime="yes"
debug="true" target="1.5"/>
</target>

<target name="compile-clojure" depends="compile-java"

description="Compile Clojure sources.">
<java classname="clojure.lang.Compile"
classpath="${build}:${cljsrc}"
failonerror="true"
fork="true">
<sysproperty key="clojure.compile.path" value="${build}"/>

<arg value="clojure.core"/>
<arg value="clojure.core.protocols"/>
<arg value="clojure.main"/>
<arg value="clojure.set"/>
<arg value="clojure.xml"/>
<arg value="clojure.zip"/>
<arg value="clojure.inspector"/>
<arg value="clojure.walk"/>
<arg value="clojure.stacktrace"/>
<arg value="clojure.template"/>
<arg value="clojure.test"/>
26 CHAPTER 5. THE ANT BUILD SEQUENCE

<target name="clojure-jar" depends="build"

description="Create clojure jar file.">
5.1. ANT.BUILD 27

<jar jarfile="${clojure_jar}" basedir="${build}">

<target name="clojure-jar-slim" depends="build"

description=
"Create clojure-slim jar file (omits compiled Clojure code).">
<jar jarfile="${slim_jar}">
<fileset dir="${build}" includes="clojure/asm/**"/>
<fileset dir="${build}" includes="clojure/lang/**"/>
<fileset dir="${build}" includes="clojure/main.class"/>
<fileset dir="${cljsrc}">
<include name="**/*.clj"/>
<include name="clojure/version.properties"/>
</fileset>
<manifest>
<attribute name="Main-Class" value="clojure.main"/>
<attribute name="Class-Path" value="."/>
</manifest>
</jar>
<copy file="${slim_jar}" tofile="${slim_noversion_jar}" />
</target>

<target name="clojure-jar-sources" depends="build"

description="Create a JAR of Java sources.">
<jar jarfile="${src_jar}" basedir="${jsrc}" includes="**/*">
<fileset dir="${cljsrc}"
includes="clojure/version.properties"/>
</jar>
<copy file="${src_jar}" tofile="${src_noversion_jar}" />
</target>

<target name="clean"
description="Remove autogenerated files and directories.">
<delete dir="${build}"/>
<delete dir="${test-classes}"/>
<delete dir="${dist}"/>
28 CHAPTER 5. THE ANT BUILD SEQUENCE

<target name="nightly-build" depends="ci-build"

description="Build and deploy to nightly (snapshot) repository.">
<sequential>
<typedef resource="org/apache/maven/artifact/ant/antlib.xml"
uri="urn:maven-artifact-ant"/>
<mvn:deploy file="${clojure_jar}">
<pom file="pom.xml"/>
<attach file="${src_jar}" classifier="sources"/>
<attach file="${slim_jar}" classifier="slim"/>
<remoteRepository url="file:${snapshot.repo.dir}"/>
</mvn:deploy>
</sequential>
</target>

<target name="release" depends="ci-build,dist"

description="Build and deploy to remote stable repository.">
<sequential>
<typedef resource="org/apache/maven/artifact/ant/antlib.xml"
uri="urn:maven-artifact-ant"/>
<mvn:install-provider artifactId="wagon-ssh" version="1.0-beta-2"/>
<echo message="Deploying to ${deployment.url}"/>
<mvn:deploy file="${clojure_jar}">
<pom file="pom.xml"/>
<attach file="${src_jar}" classifier="sources"/>
<attach file="${slim_jar}" classifier="slim"/>
<remoteRepository url="${deployment.url}">
<authentication username="root"
privateKey="${user.home}/.ssh/id_rsa"/>
</remoteRepository>
</mvn:deploy>
</sequential>
</target>

<target name="ci-build" depends="clean,all,setup-maven"

description=
"Continous integration build, installed to local repository.">
<mvn:install file="${clojure_jar}">
<pom file="pom.xml"/>
5.2. THE EXECUTION 29

<attach file="${src_jar}" classifier="sources"/>

<target name="dist" depends="clean,clojure-jar"

description="Build distribution ZIP file.">
<property name="distdir"
value="${dist}/clojure-${clojure.version.label}"/>
<mkdir dir="${distdir}"/>
<copy todir="${distdir}" includeEmptyDirs="false">
<fileset dir="${basedir}">
<exclude name="pom.xml"/>
<exclude name="**/.git/**"/>
<exclude name="**/*.class"/>
<exclude name="**/*.iml"/>
<exclude name="**/*.ipr"/>
<exclude name="**/*.iws"/>
<exclude name="**/*.jar"/>
</fileset>
</copy>
<copy file="${clojure_noversion_jar}" todir="${distdir}"/>
<zip basedir="${dist}"
destfile="clojure-${clojure.version.label}.zip"/>
</target>
</project>

———-

5.2 The Execution

ant -v build
Apache Ant version 1.7.1 compiled on November 10 2008
Buildfile: build.xml
Detected Java version: 1.6 in: /usr/lib/jvm/java-6-sun-1.6.0.13/jre
Detected OS: Linux
parsing buildfile BASE/build.xml
with URI = file:BASE/build.xml
Project base dir set to: BASE
[antlib:org.apache.tools.ant] Could not load definitions from resource
org/apache/tools/ant/antlib.xml. It could not be found.
[property] Loading BASE/src/clj/clojure/version.properties
Build sequence for target(s) ‘build’ is
[clean, init, compile-java, compile-clojure, build]
Complete build sequence is
[clean, init, compile-java, compile-clojure, build, setup-maven,
init-version, compile-tests, test, clojure-jar, clojure-jar-slim,
clojure-jar-sources, all, ci-build, nightly-build, debug, dist,
30 CHAPTER 5. THE ANT BUILD SEQUENCE

release, ]

clean:
[delete] Could not find file BASE/pom.xml to delete.

init:
[mkdir] Created dir: BASE/classes
Project base dir set to: BASE
[antcall] calling target(s) [init-version] in build file
BASE/build.xml
parsing buildfile BASE/build.xml with
URI = file:BASE/build.xml
Project base dir set to: BASE
Override ignored for property "src"
Override ignored for property "test"
Override ignored for property "jsrc"
Override ignored for property "cljsrc"
Override ignored for property "build"
Override ignored for property "test-classes"
Override ignored for property "dist"
Override ignored for property "deployment.url"
[property] Loading BASE/src/clj/clojure/version.properties
Override ignored for property "clojure.version.qualifier"
Override ignored for property "clojure.version.major"
Override ignored for property "clojure.version.interim"
Override ignored for property "clojure.version.incremental"
Override ignored for property "clojure.version.minor"
Override ignored for property "clojure.version.incremental.label"
Override ignored for property "clojure.version.qualifier.label"
Override ignored for property "clojure.version.interim.label"
Override ignored for property "clojure.version.label"
Override ignored for property "clojure_noversion_jar"
Override ignored for property "slim_noversion_jar"
Override ignored for property "src_noversion_jar"
Override ignored for property "clojure_jar"
Override ignored for property "slim_jar"
Override ignored for property "src_jar"
Override ignored for property "snapshot.repo.dir"
Override ignored for property "stable.repo.dir"
Build sequence for target(s) ‘init-version’ is [init-version]
Complete build sequence is
[init-version, setup-maven, clean, init, compile-java,
compile-clojure, build, compile-tests, test, clojure-jar,
clojure-jar-slim, clojure-jar-sources, all, ci-build,
nightly-build, debug, dist, release, ]
[antcall] Entering BASE/build.xml...
Build sequence for target(s) ‘init-version’ is [init-version]
Complete build sequence is
[init-version, setup-maven, clean, init, compile-java,
compile-clojure, build, compile-tests, test, clojure-jar,
5.2. THE EXECUTION 31

clojure-jar-slim, clojure-jar-sources, all, ci-build,

nightly-build, debug, dist, release, ]

init-version:
[copy] Copying 1 file to BASE
[copy] Copying BASE/pom-template.xml to BASE/pom.xml
Replacing: @clojure-version@ -> 1.3.0-master-SNAPSHOT
[chmod] Current OS is Linux
[chmod] Executing ’chmod’ with arguments:
[chmod] ’ugo-w’
[chmod] ’BASE/pom.xml’
[chmod]
[chmod] The ’ characters around the executable and arguments are
[chmod] not part of the command.
[chmod] Applied chmod to 1 file and 0 directories.
[antcall] Exiting BASE/build.xml.

compile-java:
[javac] clojure/asm/AnnotationVisitor.java added as
clojure/asm/AnnotationVisitor.class doesn’t exist.
[javac] clojure/asm/AnnotationWriter.java added as
clojure/asm/AnnotationWriter.class doesn’t exist.
[javac] clojure/asm/Attribute.java added as
clojure/asm/Attribute.class doesn’t exist.
[javac] clojure/asm/ByteVector.java added as
clojure/asm/ByteVector.class doesn’t exist.
[javac] clojure/asm/ClassAdapter.java added as
clojure/asm/ClassAdapter.class doesn’t exist.
[javac] clojure/asm/ClassReader.java added as
clojure/asm/ClassReader.class doesn’t exist.
[javac] clojure/asm/ClassVisitor.java added as
clojure/asm/ClassVisitor.class doesn’t exist.
[javac] clojure/asm/ClassWriter.java added as
clojure/asm/ClassWriter.class doesn’t exist.
[javac] clojure/asm/Edge.java added as
clojure/asm/Edge.class doesn’t exist.
[javac] clojure/asm/FieldVisitor.java added as
clojure/asm/FieldVisitor.class doesn’t exist.
[javac] clojure/asm/FieldWriter.java added as
clojure/asm/FieldWriter.class doesn’t exist.
[javac] clojure/asm/Frame.java added as
clojure/asm/Frame.class doesn’t exist.
[javac] clojure/asm/Handler.java added as
clojure/asm/Handler.class doesn’t exist.
[javac] clojure/asm/Item.java added as
clojure/asm/Item.class doesn’t exist.
[javac] clojure/asm/Label.java added as
clojure/asm/Label.class doesn’t exist.
[javac] clojure/asm/MethodAdapter.java added as
clojure/asm/MethodAdapter.class doesn’t exist.
32 CHAPTER 5. THE ANT BUILD SEQUENCE

[javac] clojure/asm/MethodVisitor.java added as

clojure/asm/MethodVisitor.class doesn’t exist.
[javac] clojure/asm/MethodWriter.java added as
clojure/asm/MethodWriter.class doesn’t exist.
[javac] clojure/asm/Opcodes.java added as
clojure/asm/Opcodes.class doesn’t exist.
[javac] clojure/asm/Type.java added as
clojure/asm/Type.class doesn’t exist.
[javac] clojure/asm/commons/AdviceAdapter.java added as
clojure/asm/commons/AdviceAdapter.class doesn’t exist.
[javac] clojure/asm/commons/AnalyzerAdapter.java added as
clojure/asm/commons/AnalyzerAdapter.class doesn’t exist.
[javac] clojure/asm/commons/CodeSizeEvaluator.java added as
clojure/asm/commons/CodeSizeEvaluator.class doesn’t exist.
[javac] clojure/asm/commons/EmptyVisitor.java added as
clojure/asm/commons/EmptyVisitor.class doesn’t exist.
[javac] clojure/asm/commons/GeneratorAdapter.java added as
clojure/asm/commons/GeneratorAdapter.class doesn’t exist.
[javac] clojure/asm/commons/LocalVariablesSorter.java added as
clojure/asm/commons/LocalVariablesSorter.class doesn’t exist.
[javac] clojure/asm/commons/Method.java added as
clojure/asm/commons/Method.class doesn’t exist.
[javac] clojure/asm/commons/SerialVersionUIDAdder.java added as
clojure/asm/commons/SerialVersionUIDAdder.class
doesn’t exist.
[javac] clojure/asm/commons/StaticInitMerger.java added as
clojure/asm/commons/StaticInitMerger.class doesn’t exist.
[javac] clojure/asm/commons/TableSwitchGenerator.java added as
clojure/asm/commons/TableSwitchGenerator.class doesn’t exist.
[javac] BASE/src/jvm/clojure/asm/commons/package.html
skipped - don’t know how to handle it
[javac] BASE/src/jvm/clojure/asm/package.html
skipped - don’t know how to handle it
[javac] clojure/lang/AFn.java added as
clojure/lang/AFn.class doesn’t exist.
[javac] clojure/lang/AFunction.java added as
clojure/lang/AFunction.class doesn’t exist.
[javac] clojure/lang/AMapEntry.java added as
clojure/lang/AMapEntry.class doesn’t exist.
[javac] clojure/lang/APersistentMap.java added as
clojure/lang/APersistentMap.class doesn’t exist.
[javac] clojure/lang/APersistentSet.java added as
clojure/lang/APersistentSet.class doesn’t exist.
[javac] clojure/lang/APersistentVector.java added as
clojure/lang/APersistentVector.class doesn’t exist.
[javac] clojure/lang/ARef.java added as
clojure/lang/ARef.class doesn’t exist.
[javac] clojure/lang/AReference.java added as
clojure/lang/AReference.class doesn’t exist.
[javac] clojure/lang/ASeq.java added as
5.2. THE EXECUTION 33

clojure/lang/ASeq.class doesn’t exist.

[javac] clojure/lang/ATransientMap.java added as
clojure/lang/ATransientMap.class doesn’t exist.
[javac] clojure/lang/ATransientSet.java added as
clojure/lang/ATransientSet.class doesn’t exist.
[javac] clojure/lang/Agent.java added as
clojure/lang/Agent.class doesn’t exist.
[javac] clojure/lang/ArityException.java added as
clojure/lang/ArityException.class doesn’t exist.
[javac] clojure/lang/ArrayChunk.java added as
clojure/lang/ArrayChunk.class doesn’t exist.
[javac] clojure/lang/ArraySeq.java added as
clojure/lang/ArraySeq.class doesn’t exist.
[javac] clojure/lang/Associative.java added as
clojure/lang/Associative.class doesn’t exist.
[javac] clojure/lang/Atom.java added as
clojure/lang/Atom.class doesn’t exist.
[javac] clojure/lang/BigInt.java added as
clojure/lang/BigInt.class doesn’t exist.
[javac] clojure/lang/Binding.java added as
clojure/lang/Binding.class doesn’t exist.
[javac] clojure/lang/Box.java added as
clojure/lang/Box.class doesn’t exist.
[javac] clojure/lang/ChunkBuffer.java added as
clojure/lang/ChunkBuffer.class doesn’t exist.
[javac] clojure/lang/ChunkedCons.java added as
clojure/lang/ChunkedCons.class doesn’t exist.
[javac] clojure/lang/Compile.java added as
clojure/lang/Compile.class doesn’t exist.
[javac] clojure/lang/Compiler.java added as
clojure/lang/Compiler.class doesn’t exist.
[javac] clojure/lang/Cons.java added as
clojure/lang/Cons.class doesn’t exist.
[javac] clojure/lang/Counted.java added as
clojure/lang/Counted.class doesn’t exist.
[javac] clojure/lang/Delay.java added as
clojure/lang/Delay.class doesn’t exist.
[javac] clojure/lang/DynamicClassLoader.java added as
clojure/lang/DynamicClassLoader.class doesn’t exist.
[javac] clojure/lang/EnumerationSeq.java added as
clojure/lang/EnumerationSeq.class doesn’t exist.
[javac] clojure/lang/Fn.java added as
clojure/lang/Fn.class doesn’t exist.
[javac] clojure/lang/IChunk.java added as
clojure/lang/IChunk.class doesn’t exist.
[javac] clojure/lang/IChunkedSeq.java added as
clojure/lang/IChunkedSeq.class doesn’t exist.
[javac] clojure/lang/IDeref.java added as
clojure/lang/IDeref.class doesn’t exist.
[javac] clojure/lang/IEditableCollection.java added as
34 CHAPTER 5. THE ANT BUILD SEQUENCE

clojure/lang/IEditableCollection.class doesn’t exist.

[javac] clojure/lang/IFn.java added as
clojure/lang/IFn.class doesn’t exist.
[javac] clojure/lang/IKeywordLookup.java added as
clojure/lang/IKeywordLookup.class doesn’t exist.
[javac] clojure/lang/ILookup.java added as
clojure/lang/ILookup.class doesn’t exist.
[javac] clojure/lang/ILookupSite.java added as
clojure/lang/ILookupSite.class doesn’t exist.
[javac] clojure/lang/ILookupThunk.java added as
clojure/lang/ILookupThunk.class doesn’t exist.
[javac] clojure/lang/IMapEntry.java added as
clojure/lang/IMapEntry.class doesn’t exist.
[javac] clojure/lang/IMeta.java added as
clojure/lang/IMeta.class doesn’t exist.
[javac] clojure/lang/IObj.java added as
clojure/lang/IObj.class doesn’t exist.
[javac] clojure/lang/IPersistentCollection.java added as
clojure/lang/IPersistentCollection.class doesn’t exist.
[javac] clojure/lang/IPersistentList.java added as
clojure/lang/IPersistentList.class doesn’t exist.
[javac] clojure/lang/IPersistentMap.java added as
clojure/lang/IPersistentMap.class doesn’t exist.
[javac] clojure/lang/IPersistentSet.java added as
clojure/lang/IPersistentSet.class doesn’t exist.
[javac] clojure/lang/IPersistentStack.java added as
clojure/lang/IPersistentStack.class doesn’t exist.
[javac] clojure/lang/IPersistentVector.java added as
clojure/lang/IPersistentVector.class doesn’t exist.
[javac] clojure/lang/IPromiseImpl.java added as
clojure/lang/IPromiseImpl.class doesn’t exist.
[javac] clojure/lang/IProxy.java added as
clojure/lang/IProxy.class doesn’t exist.
[javac] clojure/lang/IReduce.java added as
clojure/lang/IReduce.class doesn’t exist.
[javac] clojure/lang/IRef.java added as
clojure/lang/IRef.class doesn’t exist.
[javac] clojure/lang/IReference.java added as
clojure/lang/IReference.class doesn’t exist.
[javac] clojure/lang/ISeq.java added as
clojure/lang/ISeq.class doesn’t exist.
[javac] clojure/lang/ITransientAssociative.java added as
clojure/lang/ITransientAssociative.class doesn’t exist.
[javac] clojure/lang/ITransientCollection.java added as
clojure/lang/ITransientCollection.class doesn’t exist.
[javac] clojure/lang/ITransientMap.java added as
clojure/lang/ITransientMap.class doesn’t exist.
[javac] clojure/lang/ITransientSet.java added as
clojure/lang/ITransientSet.class doesn’t exist.
[javac] clojure/lang/ITransientVector.java added as
5.2. THE EXECUTION 35

clojure/lang/ITransientVector.class doesn’t exist.

[javac] clojure/lang/Indexed.java added as
clojure/lang/Indexed.class doesn’t exist.
[javac] clojure/lang/IndexedSeq.java added as
clojure/lang/IndexedSeq.class doesn’t exist.
[javac] clojure/lang/IteratorSeq.java added as
clojure/lang/IteratorSeq.class doesn’t exist.
[javac] clojure/lang/Keyword.java added as
clojure/lang/Keyword.class doesn’t exist.
[javac] clojure/lang/KeywordLookupSite.java added as
clojure/lang/KeywordLookupSite.class doesn’t exist.
[javac] clojure/lang/LazilyPersistentVector.java added as
clojure/lang/LazilyPersistentVector.class doesn’t exist.
[javac] clojure/lang/LazySeq.java added as
clojure/lang/LazySeq.class doesn’t exist.
[javac] clojure/lang/LineNumberingPushbackReader.java added as
clojure/lang/LineNumberingPushbackReader.class doesn’t exist.
[javac] clojure/lang/LispReader.java added as
clojure/lang/LispReader.class doesn’t exist.
[javac] clojure/lang/LockingTransaction.java added as
clojure/lang/LockingTransaction.class doesn’t exist.
[javac] clojure/lang/MapEntry.java added as
clojure/lang/MapEntry.class doesn’t exist.
[javac] clojure/lang/MapEquivalence.java added as
clojure/lang/MapEquivalence.class doesn’t exist.
[javac] clojure/lang/MethodImplCache.java added as
clojure/lang/MethodImplCache.class doesn’t exist.
[javac] clojure/lang/MultiFn.java added as
clojure/lang/MultiFn.class doesn’t exist.
[javac] clojure/lang/Named.java added as
clojure/lang/Named.class doesn’t exist.
[javac] clojure/lang/Namespace.java added as
clojure/lang/Namespace.class doesn’t exist.
[javac] clojure/lang/Numbers.java added as
clojure/lang/Numbers.class doesn’t exist.
[javac] clojure/lang/Obj.java added as
clojure/lang/Obj.class doesn’t exist.
[javac] clojure/lang/PersistentArrayMap.java added as
clojure/lang/PersistentArrayMap.class doesn’t exist.
[javac] clojure/lang/PersistentHashMap.java added as
clojure/lang/PersistentHashMap.class doesn’t exist.
[javac] clojure/lang/PersistentHashSet.java added as
clojure/lang/PersistentHashSet.class doesn’t exist.
[javac] clojure/lang/PersistentList.java added as
clojure/lang/PersistentList.class doesn’t exist.
[javac] clojure/lang/PersistentQueue.java added as
clojure/lang/PersistentQueue.class doesn’t exist.
[javac] clojure/lang/PersistentStructMap.java added as
clojure/lang/PersistentStructMap.class doesn’t exist.
[javac] clojure/lang/PersistentTreeMap.java added as
36 CHAPTER 5. THE ANT BUILD SEQUENCE

clojure/lang/PersistentTreeMap.class doesn’t exist.

[javac] clojure/lang/PersistentTreeSet.java added as
clojure/lang/PersistentTreeSet.class doesn’t exist.
[javac] clojure/lang/PersistentVector.java added as
clojure/lang/PersistentVector.class doesn’t exist.
[javac] clojure/lang/ProxyHandler.java added as
clojure/lang/ProxyHandler.class doesn’t exist.
[javac] clojure/lang/RT.java added as
clojure/lang/RT.class doesn’t exist.
[javac] clojure/lang/Range.java added as
clojure/lang/Range.class doesn’t exist.
[javac] clojure/lang/Ratio.java added as
clojure/lang/Ratio.class doesn’t exist.
[javac] clojure/lang/Ref.java added as
clojure/lang/Ref.class doesn’t exist.
[javac] clojure/lang/Reflector.java added as
clojure/lang/Reflector.class doesn’t exist.
[javac] clojure/lang/Repl.java added as
clojure/lang/Repl.class doesn’t exist.
[javac] clojure/lang/RestFn.java added as
clojure/lang/RestFn.class doesn’t exist.
[javac] clojure/lang/Reversible.java added as
clojure/lang/Reversible.class doesn’t exist.
[javac] clojure/lang/Script.java added as
clojure/lang/Script.class doesn’t exist.
[javac] clojure/lang/SeqEnumeration.java added as
clojure/lang/SeqEnumeration.class doesn’t exist.
[javac] clojure/lang/SeqIterator.java added as
clojure/lang/SeqIterator.class doesn’t exist.
[javac] clojure/lang/Seqable.java added as
clojure/lang/Seqable.class doesn’t exist.
[javac] clojure/lang/Sequential.java added as
clojure/lang/Sequential.class doesn’t exist.
[javac] clojure/lang/Settable.java added as
clojure/lang/Settable.class doesn’t exist.
[javac] clojure/lang/Sorted.java added as
clojure/lang/Sorted.class doesn’t exist.
[javac] clojure/lang/StringSeq.java added as
clojure/lang/StringSeq.class doesn’t exist.
[javac] clojure/lang/Symbol.java added as
clojure/lang/Symbol.class doesn’t exist.
[javac] clojure/lang/TransactionalHashMap.java added as
clojure/lang/TransactionalHashMap.class doesn’t exist.
[javac] clojure/lang/Util.java added as
clojure/lang/Util.class doesn’t exist.
[javac] clojure/lang/Var.java added as
clojure/lang/Var.class doesn’t exist.
[javac] clojure/lang/XMLHandler.java added as
clojure/lang/XMLHandler.class doesn’t exist.
[javac] clojure/main.java added as
5.2. THE EXECUTION 37

clojure/main.class doesn’t exist.

[javac] Compiling 139 source files to BASE/classes
[javac] Using modern compiler
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/jre/jre/lib/rt.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/Classes/jce.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/Classes/jsse.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/core.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/graphics.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/security.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/server.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/xml.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/Classes/classes.jar from path
as it doesn’t exist
dropping /usr/lib/jvm/java-6-sun-1.6.0.13/Classes/ui.jar from path
as it doesn’t exist
[javac] Compilation arguments:
[javac] ’-d’
[javac] ’BASE/classes’
[javac] ’-classpath’
[javac] ’BASE/classes:
/usr/share/ant/lib/ant-launcher.jar:
/usr/share/java/xmlParserAPIs.jar:
/usr/share/java/xercesImpl.jar:
/usr/share/ant/lib/ant-antlr.jar:
/usr/share/ant/lib/velocity.jar:
/usr/share/ant/lib/ant.jar:
/usr/share/ant/lib/commons-collections.jar:
/usr/share/ant/lib/werken.xpath.jar:
/usr/share/ant/lib/ant-jsch.jar:
/usr/share/ant/lib/ant-apache-regexp.jar:
/usr/share/ant/lib/jsch.jar:
/usr/share/ant/lib/ant-apache-oro.jar:
/usr/share/ant/lib/ant-jdepend.jar:
/usr/share/ant/lib/bcel.jar:
/usr/share/ant/lib/ant-jmf.jar:
/usr/share/ant/lib/ant-javamail.jar:
/usr/share/ant/lib/ant-commons-net.jar:
/usr/share/ant/lib/jdom0.jar:
/usr/share/ant/lib/ant-apache-bsf.jar:
/usr/share/ant/lib/ant-swing.jar:
/usr/share/ant/lib/logkit.jar:
/usr/share/ant/lib/ant-commons-logging.jar:
38 CHAPTER 5. THE ANT BUILD SEQUENCE

/usr/share/ant/lib/ant-apache-log4j.jar:
/usr/share/ant/lib/ant-apache-resolver.jar:
/usr/share/ant/lib/ant-trax.jar:
/usr/share/ant/lib/ant-apache-bcel.jar:
/usr/share/ant/lib/ant-junit.jar:
/usr/share/ant/lib/ant-nodeps.jar:
/usr/lib/jvm/java-6-sun-1.6.0.13/lib/tools.jar:
/usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/rt.jar:
/usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/jce.jar:
/usr/lib/jvm/java-6-sun-1.6.0.13/jre/lib/jsse.jar’
[javac]’-sourcepath’
[javac]’BASE/src/jvm’
[javac]’-target’
[javac]’1.5’
[javac]’-g’
[javac]
[javac] The ’ characters around the executable and arguments are
[javac] not part of the command.
[javac] Files to be compiled:
BASE/src/jvm/clojure/asm/AnnotationVisitor.java
BASE/src/jvm/clojure/asm/AnnotationWriter.java
BASE/src/jvm/clojure/asm/Attribute.java
BASE/src/jvm/clojure/asm/ByteVector.java
BASE/src/jvm/clojure/asm/ClassAdapter.java
BASE/src/jvm/clojure/asm/ClassReader.java
BASE/src/jvm/clojure/asm/ClassVisitor.java
BASE/src/jvm/clojure/asm/ClassWriter.java
BASE/src/jvm/clojure/asm/Edge.java
BASE/src/jvm/clojure/asm/FieldVisitor.java
BASE/src/jvm/clojure/asm/FieldWriter.java
BASE/src/jvm/clojure/asm/Frame.java
BASE/src/jvm/clojure/asm/Handler.java
BASE/src/jvm/clojure/asm/Item.java
BASE/src/jvm/clojure/asm/Label.java
BASE/src/jvm/clojure/asm/MethodAdapter.java
BASE/src/jvm/clojure/asm/MethodVisitor.java
BASE/src/jvm/clojure/asm/MethodWriter.java
BASE/src/jvm/clojure/asm/Opcodes.java
BASE/src/jvm/clojure/asm/Type.java
BASE/src/jvm/clojure/asm/commons/AdviceAdapter.java
BASE/src/jvm/clojure/asm/commons/AnalyzerAdapter.java
BASE/src/jvm/clojure/asm/commons/CodeSizeEvaluator.java
BASE/src/jvm/clojure/asm/commons/EmptyVisitor.java
BASE/src/jvm/clojure/asm/commons/GeneratorAdapter.java
BASE/src/jvm/clojure/asm/commons/LocalVariablesSorter.java
BASE/src/jvm/clojure/asm/commons/Method.java
BASE/src/jvm/clojure/asm/commons/SerialVersionUIDAdder.java
BASE/src/jvm/clojure/asm/commons/StaticInitMerger.java
BASE/src/jvm/clojure/asm/commons/TableSwitchGenerator.java
BASE/src/jvm/clojure/lang/AFn.java
5.2. THE EXECUTION 39

BASE/src/jvm/clojure/lang/AFunction.java
BASE/src/jvm/clojure/lang/AMapEntry.java
BASE/src/jvm/clojure/lang/APersistentMap.java
BASE/src/jvm/clojure/lang/APersistentSet.java
BASE/src/jvm/clojure/lang/APersistentVector.java
BASE/src/jvm/clojure/lang/ARef.java
BASE/src/jvm/clojure/lang/AReference.java
BASE/src/jvm/clojure/lang/ASeq.java
BASE/src/jvm/clojure/lang/ATransientMap.java
BASE/src/jvm/clojure/lang/ATransientSet.java
BASE/src/jvm/clojure/lang/Agent.java
BASE/src/jvm/clojure/lang/ArityException.java
BASE/src/jvm/clojure/lang/ArrayChunk.java
BASE/src/jvm/clojure/lang/ArraySeq.java
BASE/src/jvm/clojure/lang/Associative.java
BASE/src/jvm/clojure/lang/Atom.java
BASE/src/jvm/clojure/lang/BigInt.java
BASE/src/jvm/clojure/lang/Binding.java
BASE/src/jvm/clojure/lang/Box.java
BASE/src/jvm/clojure/lang/ChunkBuffer.java
BASE/src/jvm/clojure/lang/ChunkedCons.java
BASE/src/jvm/clojure/lang/Compile.java
BASE/src/jvm/clojure/lang/Compiler.java
BASE/src/jvm/clojure/lang/Cons.java
BASE/src/jvm/clojure/lang/Counted.java
BASE/src/jvm/clojure/lang/Delay.java
BASE/src/jvm/clojure/lang/DynamicClassLoader.java
BASE/src/jvm/clojure/lang/EnumerationSeq.java
BASE/src/jvm/clojure/lang/Fn.java
BASE/src/jvm/clojure/lang/IChunk.java
BASE/src/jvm/clojure/lang/IChunkedSeq.java
BASE/src/jvm/clojure/lang/IDeref.java
BASE/src/jvm/clojure/lang/IEditableCollection.java
BASE/src/jvm/clojure/lang/IFn.java
BASE/src/jvm/clojure/lang/IKeywordLookup.java
BASE/src/jvm/clojure/lang/ILookup.java
BASE/src/jvm/clojure/lang/ILookupSite.java
BASE/src/jvm/clojure/lang/ILookupThunk.java
BASE/src/jvm/clojure/lang/IMapEntry.java
BASE/src/jvm/clojure/lang/IMeta.java
BASE/src/jvm/clojure/lang/IObj.java
BASE/src/jvm/clojure/lang/IPersistentCollection.java
BASE/src/jvm/clojure/lang/IPersistentList.java
BASE/src/jvm/clojure/lang/IPersistentMap.java
BASE/src/jvm/clojure/lang/IPersistentSet.java
BASE/src/jvm/clojure/lang/IPersistentStack.java
BASE/src/jvm/clojure/lang/IPersistentVector.java
BASE/src/jvm/clojure/lang/IPromiseImpl.java
BASE/src/jvm/clojure/lang/IProxy.java
BASE/src/jvm/clojure/lang/IReduce.java
40 CHAPTER 5. THE ANT BUILD SEQUENCE

BASE/src/jvm/clojure/lang/IRef.java
BASE/src/jvm/clojure/lang/IReference.java
BASE/src/jvm/clojure/lang/ISeq.java
BASE/src/jvm/clojure/lang/ITransientAssociative.java
BASE/src/jvm/clojure/lang/ITransientCollection.java
BASE/src/jvm/clojure/lang/ITransientMap.java
BASE/src/jvm/clojure/lang/ITransientSet.java
BASE/src/jvm/clojure/lang/ITransientVector.java
BASE/src/jvm/clojure/lang/Indexed.java
BASE/src/jvm/clojure/lang/IndexedSeq.java
BASE/src/jvm/clojure/lang/IteratorSeq.java
BASE/src/jvm/clojure/lang/Keyword.java
BASE/src/jvm/clojure/lang/KeywordLookupSite.java
BASE/src/jvm/clojure/lang/LazilyPersistentVector.java
BASE/src/jvm/clojure/lang/LazySeq.java
BASE/src/jvm/clojure/lang/LineNumberingPushbackReader.java
BASE/src/jvm/clojure/lang/LispReader.java
BASE/src/jvm/clojure/lang/LockingTransaction.java
BASE/src/jvm/clojure/lang/MapEntry.java
BASE/src/jvm/clojure/lang/MapEquivalence.java
BASE/src/jvm/clojure/lang/MethodImplCache.java
BASE/src/jvm/clojure/lang/MultiFn.java
BASE/src/jvm/clojure/lang/Named.java
BASE/src/jvm/clojure/lang/Namespace.java
BASE/src/jvm/clojure/lang/Numbers.java
BASE/src/jvm/clojure/lang/Obj.java
BASE/src/jvm/clojure/lang/PersistentArrayMap.java
BASE/src/jvm/clojure/lang/PersistentHashMap.java
BASE/src/jvm/clojure/lang/PersistentHashSet.java
BASE/src/jvm/clojure/lang/PersistentList.java
BASE/src/jvm/clojure/lang/PersistentQueue.java
BASE/src/jvm/clojure/lang/PersistentStructMap.java
BASE/src/jvm/clojure/lang/PersistentTreeMap.java
BASE/src/jvm/clojure/lang/PersistentTreeSet.java
BASE/src/jvm/clojure/lang/PersistentVector.java
BASE/src/jvm/clojure/lang/ProxyHandler.java
BASE/src/jvm/clojure/lang/RT.java
BASE/src/jvm/clojure/lang/Range.java
BASE/src/jvm/clojure/lang/Ratio.java
BASE/src/jvm/clojure/lang/Ref.java
BASE/src/jvm/clojure/lang/Reflector.java
BASE/src/jvm/clojure/lang/Repl.java
BASE/src/jvm/clojure/lang/RestFn.java
BASE/src/jvm/clojure/lang/Reversible.java
BASE/src/jvm/clojure/lang/Script.java
BASE/src/jvm/clojure/lang/SeqEnumeration.java
BASE/src/jvm/clojure/lang/SeqIterator.java
BASE/src/jvm/clojure/lang/Seqable.java
BASE/src/jvm/clojure/lang/Sequential.java
BASE/src/jvm/clojure/lang/Settable.java
5.2. THE EXECUTION 41

BASE/src/jvm/clojure/lang/Sorted.java
BASE/src/jvm/clojure/lang/StringSeq.java
BASE/src/jvm/clojure/lang/Symbol.java
BASE/src/jvm/clojure/lang/TransactionalHashMap.java
BASE/src/jvm/clojure/lang/Util.java
BASE/src/jvm/clojure/lang/Var.java
BASE/src/jvm/clojure/lang/XMLHandler.java
BASE/src/jvm/clojure/main.java
[javac] Note: Some input files use unchecked or unsafe operations.
[javac] Note: Recompile with -Xlint:unchecked for details.

compile-clojure:
[java] Executing ’/usr/lib/jvm/java-6-sun-1.6.0.13/jre/bin/java’
with arguments:
[java] ’-Dclojure.compile.path=BASE/classes’
[java] ’-classpath’
[java] ’BASE/classes:BASE/src/clj’
[java] ’clojure.lang.Compile’
[java] ’clojure.core’
[java] ’clojure.core.protocols’
[java] ’clojure.main’
[java] ’clojure.set’
[java] ’clojure.xml’
[java] ’clojure.zip’
[java] ’clojure.inspector’
[java] ’clojure.walk’
[java] ’clojure.stacktrace’
[java] ’clojure.template’
[java] ’clojure.test’
[java] ’clojure.test.tap’
[java] ’clojure.test.junit’
[java] ’clojure.pprint’
[java] ’clojure.java.io’
[java] ’clojure.repl’
[java] ’clojure.java.browse’
[java] ’clojure.java.javadoc’
[java] ’clojure.java.shell’
[java] ’clojure.java.browse-ui’
[java] ’clojure.string’
[java] ’clojure.data’
[java] ’clojure.reflect’
[java]
[java] The ’ characters around the executable and arguments are
[java] not part of the command.
[java] Compiling clojure.core to BASE/classes
[java] Compiling clojure.core.protocols to BASE/classes
[java] Compiling clojure.main to BASE/classes
[java] Compiling clojure.set to BASE/classes
[java] Compiling clojure.xml to BASE/classes
[java] Compiling clojure.zip to BASE/classes
42 CHAPTER 5. THE ANT BUILD SEQUENCE

[java] Compiling clojure.inspector to BASE/classes

[java] Compiling clojure.walk to BASE/classes
[java] Compiling clojure.stacktrace to BASE/classes
[java] Compiling clojure.template to BASE/classes
[java] Compiling clojure.test to BASE/classes
[java] Compiling clojure.test.tap to BASE/classes
[java] Compiling clojure.test.junit to BASE/classes
[java] Compiling clojure.pprint to BASE/classes
[java] Compiling clojure.java.io to BASE/classes
[java] Compiling clojure.repl to BASE/classes
[java] Compiling clojure.java.browse to BASE/classes
[java] Compiling clojure.java.javadoc to BASE/classes
[java] Compiling clojure.java.shell to BASE/classes
[java] Compiling clojure.java.browse-ui to BASE/classes
[java] Compiling clojure.string to BASE/classes
[java] Compiling clojure.data to BASE/classes
[java] Compiling clojure.reflect to BASE/classes

build:

BUILD SUCCESSFUL
Total time: 33 seconds
Chapter 6

jvm/clojure/asm/

6.1 AnnotationVisitor.java

— AnnotationVisitor.java —
\getchunk{France Telecom Copyright}
package clojure.asm;

/**
* A visitor to visit a Java annotation. The methods of this interface
* must be called in the following order: (<tt>visit<tt> |
* <tt>visitEnum<tt> | <tt>visitAnnotation<tt> | <tt>visitArray<tt>)*
* <tt>visitEnd<tt>.
*
* @author Eric Bruneton
* @author Eugene Kuleshov
*/
public interface AnnotationVisitor{

/**
* Visits a primitive value of the annotation.
*
* @param name the value name.
* @param value the actual value, whose type must be {@link Byte},
* {@link Boolean}, {@link Character}, {@link Short},
* {@link Integer}, {@link Long}, {@link Float},
* {@link Double}, {@link String} or {@link Type}. This
* value can also be an array of byte, boolean, short,
* char, int, long, float or double values (this is
* equivalent to using {@link #visitArray visitArray}
* and visiting each array element in turn, but is more
* convenient).

43
44 CHAPTER 6. JVM/CLOJURE/ASM/

*/
void visit(String name, Object value);

/**
* Visits an enumeration value of the annotation.
*
* @param name the value name.
* @param desc the class descriptor of the enumeration class.
* @param value the actual enumeration value.
*/
void visitEnum(String name, String desc, String value);

/**
* Visits a nested annotation value of the annotation.
*
* @param name the value name.
* @param desc the class descriptor of the nested annotation class.
* @return a visitor to visit the actual nested annotation value, or
* <tt>null</tt> if this visitor is not interested in visiting
* this nested annotation. The nested annotation value must be
* fully visited before calling other methods on this annotation
* visitor.
*/
AnnotationVisitor visitAnnotation(String name, String desc);

/**
* Visits an array value of the annotation. Note that arrays of primitive
* types (such as byte, boolean, short, char, int, long, float or double)
* can be passed as value to {@link #visit visit}. This is what
* {@link ClassReader} does.
*
* @param name the value name.
* @return a visitor to visit the actual array value elements, or
* <tt>null</tt> if this visitor is not interested in visiting
* these values. The ’name’ parameters passed to the methods of
* this visitor are ignored. All the array values must be
* visited before calling other methods on this annotation
* visitor.
*/
AnnotationVisitor visitArray(String name);

/**
* Visits the end of the annotation.
*/
void visitEnd();
}

———-
6.2. ANNOTATIONWRITER.JAVA 45

6.2 AnnotationWriter.java

— AnnotationWriter.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* An {@link AnnotationVisitor} that generates annotations in
* bytecode form.
*
* @author Eric Bruneton
* @author Eugene Kuleshov
*/
final class AnnotationWriter implements AnnotationVisitor{

/**
* The class writer to which this annotation must be added.
*/
private final ClassWriter cw;

/**
* The number of values in this annotation.
*/
private int size;

/**
* <tt>true<tt> if values are named, <tt>false</tt> otherwise. Annotation
* writers used for annotation default and annotation arrays use unnamed
* values.
*/
private final boolean named;

/**
* The annotation values in bytecode form. This byte vector only contains
* the values themselves, i.e. the number of values must be stored as a
* unsigned short just before these bytes.
*/
private final ByteVector bv;

/**
* The byte vector to be used to store the number of values of this
* annotation. See {@link #bv}.
*/
private final ByteVector parent;

/**
* Where the number of values of this annotation must be stored in
46 CHAPTER 6. JVM/CLOJURE/ASM/

* {@link #parent}.
*/
private final int offset;

/**
* Next annotation writer. This field is used to store annotation lists.
*/
AnnotationWriter next;

/**
* Previous annotation writer. This field is used to store annotation
* lists.
*/
AnnotationWriter prev;

// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------

/**
* Constructs a new {@link AnnotationWriter}.
*
* @param cw the class writer to which this annotation must be added.
* @param named <tt>true<tt> if values are named,
* <tt>false</tt> otherwise.
* @param bv where the annotation values must be stored.
* @param parent where the number of annotation values must be stored.
* @param offset where in <tt>parent</tt> the number of annotation values
* must be stored.
*/
AnnotationWriter(
final ClassWriter cw,
final boolean named,
final ByteVector bv,
final ByteVector parent,
final int offset){
this.cw = cw;
this.named = named;
this.bv = bv;
this.parent = parent;
this.offset = offset;
}

// -------------------------------------------------------------------
// Implementation of the AnnotationVisitor interface
// -------------------------------------------------------------------

public void visit(final String name, final Object value){

++size;
if(named)
6.2. ANNOTATIONWRITER.JAVA 47

{
bv.putShort(cw.newUTF8(name));
}
if(value instanceof String)
{
bv.put12(’s’, cw.newUTF8((String) value));
}
else if(value instanceof Byte)
{
bv.put12(’B’, cw.newInteger(((Byte) value).byteValue()).index);
}
else if(value instanceof Boolean)
{
int v = ((Boolean) value).booleanValue() ? 1 : 0;
bv.put12(’Z’, cw.newInteger(v).index);
}
else if(value instanceof Character)
{
bv.put12(’C’,
cw.newInteger(((Character) value).charValue()).index);
}
else if(value instanceof Short)
{
bv.put12(’S’, cw.newInteger(((Short) value).shortValue()).index);
}
else if(value instanceof Type)
{
bv.put12(’c’, cw.newUTF8(((Type) value).getDescriptor()));
}
else if(value instanceof byte[])
{
byte[] v = (byte[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’B’, cw.newInteger(v[i]).index);
}
}
else if(value instanceof boolean[])
{
boolean[] v = (boolean[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’Z’, cw.newInteger(v[i] ? 1 : 0).index);
}
}
else if(value instanceof short[])
{
short[] v = (short[]) value;
48 CHAPTER 6. JVM/CLOJURE/ASM/

bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’S’, cw.newInteger(v[i]).index);
}
}
else if(value instanceof char[])
{
char[] v = (char[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’C’, cw.newInteger(v[i]).index);
}
}
else if(value instanceof int[])
{
int[] v = (int[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’I’, cw.newInteger(v[i]).index);
}
}
else if(value instanceof long[])
{
long[] v = (long[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’J’, cw.newLong(v[i]).index);
}
}
else if(value instanceof float[])
{
float[] v = (float[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’F’, cw.newFloat(v[i]).index);
}
}
else if(value instanceof double[])
{
double[] v = (double[]) value;
bv.put12(’[’, v.length);
for(int i = 0; i < v.length; i++)
{
bv.put12(’D’, cw.newDouble(v[i]).index);
}
6.2. ANNOTATIONWRITER.JAVA 49

}
else
{
Item i = cw.newConstItem(value);
bv.put12(".s.IFJDCS".charAt(i.type), i.index);
}
}

public void visitEnum(

final String name,
final String desc,
final String value){
++size;
if(named)
{
bv.putShort(cw.newUTF8(name));
}
bv.put12(’e’, cw.newUTF8(desc)).putShort(cw.newUTF8(value));
}

public AnnotationVisitor visitAnnotation(

final String name,
final String desc){
++size;
if(named)
{
bv.putShort(cw.newUTF8(name));
}
// write tag and type, and reserve space for values count
bv.put12(’@’, cw.newUTF8(desc)).putShort(0);
return new AnnotationWriter(cw, true, bv, bv, bv.length - 2);
}

public AnnotationVisitor visitArray(final String name){

++size;
if(named)
{
bv.putShort(cw.newUTF8(name));
}
// write tag, and reserve space for array size
bv.put12(’[’, 0);
return new AnnotationWriter(cw, false, bv, bv, bv.length - 2);
}

public void visitEnd(){

if(parent != null)
{
byte[] data = parent.data;
data[offset] = (byte) (size >>> 8);
data[offset + 1] = (byte) size;
50 CHAPTER 6. JVM/CLOJURE/ASM/

}
}

// -------------------------------------------------------------------
// Utility methods
// -------------------------------------------------------------------

/**
* Returns the size of this annotation writer list.
*
* @return the size of this annotation writer list.
*/
int getSize(){
int size = 0;
AnnotationWriter aw = this;
while(aw != null)
{
size += aw.bv.length;
aw = aw.next;
}
return size;
}

/**
* Puts the annotations of this annotation writer list into the given
* byte vector.
*
* @param out where the annotations must be put.
*/
void put(final ByteVector out){
int n = 0;
int size = 2;
AnnotationWriter aw = this;
AnnotationWriter last = null;
while(aw != null)
{
++n;
size += aw.bv.length;
aw.visitEnd(); // in case user forgot to call visitEnd
aw.prev = last;
last = aw;
aw = aw.next;
}
out.putInt(size);
out.putShort(n);
aw = last;
while(aw != null)
{
out.putByteArray(aw.bv.data, 0, aw.bv.length);
aw = aw.prev;
6.3. ATTRIBUTE.JAVA 51

}
}

/**
* Puts the given annotation lists into the given byte vector.
*
* @param panns an array of annotation writer lists.
* @param out where the annotations must be put.
*/
static void put(final AnnotationWriter[] panns, final ByteVector out){
int size = 1 + 2 * panns.length;
for(int i = 0; i < panns.length; ++i)
{
size += panns[i] == null ? 0 : panns[i].getSize();
}
out.putInt(size).putByte(panns.length);
for(int i = 0; i < panns.length; ++i)
{
AnnotationWriter aw = panns[i];
AnnotationWriter last = null;
int n = 0;
while(aw != null)
{
++n;
aw.visitEnd(); // in case user forgot to call visitEnd
aw.prev = last;
last = aw;
aw = aw.next;
}
out.putShort(n);
aw = last;
while(aw != null)
{
out.putByteArray(aw.bv.data, 0, aw.bv.length);
aw = aw.prev;
}
}
}
}

———-

6.3 Attribute.java

— Attribute.java —

\getchunk{France Telecom Copyright}

52 CHAPTER 6. JVM/CLOJURE/ASM/

package clojure.asm;

/**
* A non standard class, field, method or code attribute.
*
* @author Eric Bruneton
* @author Eugene Kuleshov
*/
public class Attribute{

/**
* The type of this attribute.
*/
public final String type;

/**
* The raw value of this attribute, used only for unknown attributes.
*/
byte[] value;

/**
* The next attribute in this attribute list. May be <tt>null</tt>.
*/
Attribute next;

/**
* Constructs a new empty attribute.
*
* @param type the type of the attribute.
*/
protected Attribute(final String type){
this.type = type;
}

/**
* Returns <tt>true</tt> if this type of attribute is unknown.
* The default implementation of this method always returns
* <tt>true</tt>.
*
* @return <tt>true</tt> if this type of attribute is unknown.
*/
public boolean isUnknown(){
return true;
}

/**
* Returns <tt>true</tt> if this type of attribute is a code attribute.
*
* @return <tt>true</tt> if this type of attribute is a code attribute.
*/
6.3. ATTRIBUTE.JAVA 53

public boolean isCodeAttribute(){

return false;
}

/**
* Returns the labels corresponding to this attribute.
*
* @return the labels corresponding to this attribute, or
* <tt>null</tt> if this attribute is not a code attribute
* that contains labels.
*/
protected Label[] getLabels(){
return null;
}

/**
* Reads a {@link #type type} attribute. This method must return
* new {@link Attribute} object, of type {@link #type type},
* corresponding to the <tt>len</tt> bytes starting at the given offset,
* in the given class reader.
*
* @param cr the class that contains the attribute to be read.
* @param off index of the first byte of the attribute’s content
* in {@link ClassReader#b cr.b}. The 6 attribute header
* bytes, containing the type and the length of the
* attribute, are not taken into account
* here.
* @param len the length of the attribute’s content.
* @param buf buffer to be used to call
* {@link ClassReader#readUTF8 readUTF8},
* {@link ClassReader#readClass(int,char[]) readClass} or
* {@link ClassReader#readConst readConst}.
* @param codeOff index of the first byte of code’s attribute content in
* {@link ClassReader#b cr.b}, or -1 if the attribute to
* be read is not a code attribute. The 6 attribute header
* bytes, containing the type and the length of the
* attribute, are not taken into account here.
* @param labels the labels of the method’s code, or <tt>null</tt>
* if the attribute to be read is not a code attribute.
* @return a new {@link Attribute} object corresponding to the
* given bytes.
*/
protected Attribute read(
final ClassReader cr,
final int off,
final int len,
final char[] buf,
final int codeOff,
final Label[] labels){
Attribute attr = new Attribute(type);
54 CHAPTER 6. JVM/CLOJURE/ASM/

attr.value = new byte[len];

System.arraycopy(cr.b, off, attr.value, 0, len);
return attr;
}

/**
* Returns the byte array form of this attribute.
*
* @param cw the class to which this attribute must be added.
* This parameter can be used to add to the constant
* pool of this class the items that corresponds to
* this attribute.
* @param code the bytecode of the method corresponding to this code
* attribute, or <tt>null</tt> if this attribute is not
* a code attributes.
* @param len the length of the bytecode of the method
* corresponding to this code attribute, or
* <tt>null</tt> if this attribute is not a code
* attribute.
* @param maxStack the maximum stack size of the method corresponding to
* this code attribute, or -1 if this attribute is not
* a code attribute.
* @param maxLocals the maximum number of local variables of the method
* corresponding to this code attribute, or -1 if this
* attribute is not a code attribute.
* @return the byte array form of this attribute.
*/
protected ByteVector write(
final ClassWriter cw,
final byte[] code,
final int len,
final int maxStack,
final int maxLocals){
ByteVector v = new ByteVector();
v.data = value;
v.length = value.length;
return v;
}

/**
* Returns the length of the attribute list that begins with this
* attribute.
*
* @return the length of the attribute list that begins with this
* attribute.
*/
final int getCount(){
int count = 0;
Attribute attr = this;
while(attr != null)
6.3. ATTRIBUTE.JAVA 55

{
count += 1;
attr = attr.next;
}
return count;
}

/**
* Returns the size of all the attributes in this attribute list.
*
* @param cw the class writer to be used to convert the attributes
* into byte arrays, with the {@link #write write}
* method.
* @param code the bytecode of the method corresponding to these
* code attributes, or <tt>null</tt> if these
* attributes are not code attributes.
* @param len the length of the bytecode of the method
* corresponding to these code attributes, or
* <tt>null</tt> if these attributes are not code
* attributes.
* @param maxStack the maximum stack size of the method corresponding to
* these code attributes, or -1 if these attributes are
* not code attributes.
* @param maxLocals the maximum number of local variables of the method
* corresponding to these code attributes, or -1 if
* these attributes are not code attributes.
* @return the size of all the attributes in this attribute list.
* This size includes the size of the attribute headers.
*/
final int getSize(
final ClassWriter cw,
final byte[] code,
final int len,
final int maxStack,
final int maxLocals){
Attribute attr = this;
int size = 0;
while(attr != null)
{
cw.newUTF8(attr.type);
size +=
attr.write(cw,code,len,maxStack,maxLocals).length + 6;
attr = attr.next;
}
return size;
}

/**
* Writes all the attributes of this attribute list in the given byte
* vector.
56 CHAPTER 6. JVM/CLOJURE/ASM/

*
* @param cw the class writer to be used to convert the attributes
* into byte arrays, with the {@link #write write}
* method.
* @param code the bytecode of the method corresponding to these
* code attributes, or <tt>null</tt> if these attributes
* are not code attributes.
* @param len the length of the bytecode of the method
* corresponding to these code attributes, or
* <tt>null</tt> if these attributes are not code
* attributes.
* @param maxStack the maximum stack size of the method corresponding to
* these code attributes, or -1 if these attributes are
* not code attributes.
* @param maxLocals the maximum number of local variables of the method
* corresponding to these code attributes, or -1 if
* these attributes are not code attributes.
* @param out where the attributes must be written.
*/
final void put(
final ClassWriter cw,
final byte[] code,
final int len,
final int maxStack,
final int maxLocals,
final ByteVector out){
Attribute attr = this;
while(attr != null)
{
ByteVector b = attr.write(cw, code, len, maxStack, maxLocals);
out.putShort(cw.newUTF8(attr.type)).putInt(b.length);
out.putByteArray(b.data, 0, b.length);
attr = attr.next;
}
}
}

———-

6.4 ByteVector.java

— ByteVector.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
6.4. BYTEVECTOR.JAVA 57

* A dynamically extensible vector of bytes. This class is roughly

* equivalent to a DataOutputStream on top of a ByteArrayOutputStream,
* but is more efficient.
*
* @author Eric Bruneton
*/
public class ByteVector{

/**
* The content of this vector.
*/
byte[] data;

/**
* Actual number of bytes in this vector.
*/
int length;

/**
* Constructs a new {@link ByteVector ByteVector} with a default initial
* size.
*/
public ByteVector(){
data = new byte[64];
}

/**
* Constructs a new {@link ByteVector ByteVector} with the given initial
* size.
*
* @param initialSize the initial size of the byte vector to be
* constructed.
*/
public ByteVector(final int initialSize){
data = new byte[initialSize];
}

/**
* Puts a byte into this byte vector. The byte vector is automatically
* enlarged if necessary.
*
* @param b a byte.
* @return this byte vector.
*/
public ByteVector putByte(final int b){
int length = this.length;
if(length + 1 > data.length)
{
enlarge(1);
}
58 CHAPTER 6. JVM/CLOJURE/ASM/

data[length++] = (byte) b;
this.length = length;
return this;
}

/**
* Puts two bytes into this byte vector. The byte vector is automatically
* enlarged if necessary.
*
* @param b1 a byte.
* @param b2 another byte.
* @return this byte vector.
*/
ByteVector put11(final int b1, final int b2){
int length = this.length;
if(length + 2 > data.length)
{
enlarge(2);
}
byte[] data = this.data;
data[length++] = (byte) b1;
data[length++] = (byte) b2;
this.length = length;
return this;
}

/**
* Puts a short into this byte vector. The byte vector is automatically
* enlarged if necessary.
*
* @param s a short.
* @return this byte vector.
*/
public ByteVector putShort(final int s){
int length = this.length;
if(length + 2 > data.length)
{
enlarge(2);
}
byte[] data = this.data;
data[length++] = (byte) (s >>> 8);
data[length++] = (byte) s;
this.length = length;
return this;
}

/**
* Puts a byte and a short into this byte vector. The byte vector is
* automatically enlarged if necessary.
*
6.4. BYTEVECTOR.JAVA 59

* @param b a byte.
* @param s a short.
* @return this byte vector.
*/
ByteVector put12(final int b, final int s){
int length = this.length;
if(length + 3 > data.length)
{
enlarge(3);
}
byte[] data = this.data;
data[length++] = (byte) b;
data[length++] = (byte) (s >>> 8);
data[length++] = (byte) s;
this.length = length;
return this;
}

/**
* Puts an int into this byte vector. The byte vector is automatically
* enlarged if necessary.
*
* @param i an int.
* @return this byte vector.
*/
public ByteVector putInt(final int i){
int length = this.length;
if(length + 4 > data.length)
{
enlarge(4);
}
byte[] data = this.data;
data[length++] = (byte) (i >>> 24);
data[length++] = (byte) (i >>> 16);
data[length++] = (byte) (i >>> 8);
data[length++] = (byte) i;
this.length = length;
return this;
}

/**
* Puts a long into this byte vector. The byte vector is automatically
* enlarged if necessary.
*
* @param l a long.
* @return this byte vector.
*/
public ByteVector putLong(final long l){
int length = this.length;
if(length + 8 > data.length)
60 CHAPTER 6. JVM/CLOJURE/ASM/

{
enlarge(8);
}
byte[] data = this.data;
int i = (int) (l >>> 32);
data[length++] = (byte) (i >>> 24);
data[length++] = (byte) (i >>> 16);
data[length++] = (byte) (i >>> 8);
data[length++] = (byte) i;
i = (int) l;
data[length++] = (byte) (i >>> 24);
data[length++] = (byte) (i >>> 16);
data[length++] = (byte) (i >>> 8);
data[length++] = (byte) i;
this.length = length;
return this;
}

/**
* Puts an UTF8 string into this byte vector. The byte vector is
* automatically enlarged if necessary.
*
* @param s a String.
* @return this byte vector.
*/
public ByteVector putUTF8(final String s){
int charLength = s.length();
if(length + 2 + charLength > data.length)
{
enlarge(2 + charLength);
}
int len = length;
byte[] data = this.data;
// optimistic algorithm: instead of computing the byte length
// and then serializing the string (which requires two loops),
// we assume the byte length is equal to char length (which is
// the most frequent case), and we start serializing the string
// right away. During the serialization, if we find that this
// assumption is wrong, we continue with the general method.
data[len++] = (byte) (charLength >>> 8);
data[len++] = (byte) charLength;
for(int i = 0; i < charLength; ++i)
{
char c = s.charAt(i);
if(c >= ’\001’ && c <= ’\177’)
{
data[len++] = (byte) c;
}
else
{
6.4. BYTEVECTOR.JAVA 61

int byteLength = i;
for(int j = i; j < charLength; ++j)
{
c = s.charAt(j);
if(c >= ’\001’ && c <= ’\177’)
{
byteLength++;
}
else if(c > ’\u07FF’)
{
byteLength += 3;
}
else
{
byteLength += 2;
}
}
data[length] = (byte) (byteLength >>> 8);
data[length + 1] = (byte) byteLength;
if(length + 2 + byteLength > data.length)
{
length = len;
enlarge(2 + byteLength);
data = this.data;
}
for(int j = i; j < charLength; ++j)
{
c = s.charAt(j);
if(c >= ’\001’ && c <= ’\177’)
{
data[len++] = (byte) c;
}
else if(c > ’\u07FF’)
{
data[len++] =
(byte) (0xE0 | c >> 12 & 0xF);
data[len++] =
(byte) (0x80 | c >> 6 & 0x3F);
data[len++] =
(byte) (0x80 | c & 0x3F);
}
else
{
data[len++] =
(byte) (0xC0 | c >> 6 & 0x1F);
data[len++] =
(byte) (0x80 | c & 0x3F);
}
}
break;
62 CHAPTER 6. JVM/CLOJURE/ASM/

}
}
length = len;
return this;
}

/**
* Puts an array of bytes into this byte vector. The byte vector is
* automatically enlarged if necessary.
*
* @param b an array of bytes. May be <tt>null</tt> to put <tt>len</tt>
* null bytes into this byte vector.
* @param off index of the fist byte of b that must be copied.
* @param len number of bytes of b that must be copied.
* @return this byte vector.
*/
public ByteVector putByteArray(final byte[] b, final int off,
final int len){
if(length + len > data.length)
{
enlarge(len);
}
if(b != null)
{
System.arraycopy(b, off, data, length, len);
}
length += len;
return this;
}

/**
* Enlarge this byte vector so that it can receive n more bytes.
*
* @param size number of additional bytes that this byte vector should be
* able to receive.
*/
private void enlarge(final int size){
int length1 = 2 * data.length;
int length2 = length + size;
byte[] newData = new byte[length1 > length2 ? length1 : length2];
System.arraycopy(data, 0, newData, 0, length);
data = newData;
}
}

———-
6.5. CLASSADAPTER.JAVA 63

6.5 ClassAdapter.java

— ClassAdapter.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* An empty {@link ClassVisitor} that delegates to another
* {@link ClassVisitor}. This class can be used as a super class to
* quickly implement usefull class adapter classes, just by overriding
* the necessary methods.
*
* @author Eric Bruneton
*/
public class ClassAdapter implements ClassVisitor{

/**
* The {@link ClassVisitor} to which this adapter delegates calls.
*/
protected ClassVisitor cv;

/**
* Constructs a new {@link ClassAdapter} object.
*
* @param cv the class visitor to which this adapter must delegate calls.
*/
public ClassAdapter(final ClassVisitor cv){
this.cv = cv;
}

public void visit(

final int version,
final int access,
final String name,
final String signature,
final String superName,
final String[] interfaces){
cv.visit(version, access, name, signature, superName, interfaces);
}

public void visitSource(final String source, final String debug){

cv.visitSource(source, debug);
}

public void visitOuterClass(

final String owner,
final String name,
64 CHAPTER 6. JVM/CLOJURE/ASM/

final String desc){

cv.visitOuterClass(owner, name, desc);
}

public AnnotationVisitor visitAnnotation(

final String desc,
final boolean visible){
return cv.visitAnnotation(desc, visible);
}

public void visitAttribute(final Attribute attr){

cv.visitAttribute(attr);
}

public void visitInnerClass(

final String name,
final String outerName,
final String innerName,
final int access){
cv.visitInnerClass(name, outerName, innerName, access);
}

public FieldVisitor visitField(

final int access,
final String name,
final String desc,
final String signature,
final Object value){
return cv.visitField(access, name, desc, signature, value);
}

public MethodVisitor visitMethod(

final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions){
return cv.visitMethod(access, name, desc, signature, exceptions);
}

public void visitEnd(){

cv.visitEnd();
}
}

———-
6.6. CLASSREADER.JAVA 65

6.6 ClassReader.java

— ClassReader.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

import java.io.InputStream;
import java.io.IOException;

/**
* A Java class parser to make a {@link ClassVisitor} visit an
* existing class. This class parses a byte array conforming to
* the Java class file format and calls the appropriate visit
* methods of a given class visitor for each field, method and
* bytecode instruction encountered.
*
* @author Eric Bruneton
* @author Eugene Kuleshov
*/
public class ClassReader{

/**
* Flag to skip method code. If this class is set <code>CODE</code>
* attribute won’t be visited. This can be used, for example, to retrieve
* annotations for methods and method parameters.
*/
public final static int SKIP_CODE = 1;

/**
* Flag to skip the debug information in the class. If this flag is set
* the debug information of the class is not visited, i.e. the
* {@link MethodVisitor#visitLocalVariable visitLocalVariable} and
* {@link MethodVisitor#visitLineNumber visitLineNumber} methods
* will not be called.
*/
public final static int SKIP_DEBUG = 2;

/**
* Flag to skip the stack map frames in the class. If this flag is set
* the stack map frames of the class is not visited, i.e. the
* {@link MethodVisitor#visitFrame visitFrame} method will not be called.
* This flag is useful when the {@link ClassWriter#COMPUTE_FRAMES} option
* is used: it avoids visiting frames that will be ignored and
* recomputed from scratch in the class writer.
*/
public final static int SKIP_FRAMES = 4;
66 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Flag to expand the stack map frames. By default stack map frames are
* visited in their original format (i.e. "expanded" for classes whose
* version is less than V1_6, and "compressed" for the other classes).
* If this flag is set, stack map frames are always visited in
* expanded format (this option adds a decompression/recompression
* step in ClassReader and ClassWriter which degrades performances
* quite a lot).
*/
public final static int EXPAND_FRAMES = 8;

/**
* The class to be parsed. The content of this array must not be
* modified. This field is intended for {@link Attribute} sub classes,
* and is normally not needed by class generators or adapters.
*/
public final byte[] b;

/**
* The start index of each constant pool item in {@link #b b}, plus one.
* The one byte offset skips the constant pool item tag that indicates
* its type.
*/
private final int[] items;

/**
* The String objects corresponding to the CONSTANT_Utf8 items.
* This cache avoids multiple parsing of a given CONSTANT_Utf8
* constant pool item, which GREATLY improves performances (by a
* factor 2 to 3). This caching strategy could be extended to all
* constant pool items, but its benefit would not be so great for
* these items (because they are much less expensive to parse than
* CONSTANT_Utf8 items).
*/
private final String[] strings;

/**
* Maximum length of the strings contained in the constant pool of the
* class.
*/
private final int maxStringLength;

/**
* Start index of the class header information (access, name...) in
* {@link #b b}.
*/
public final int header;

// -------------------------------------------------------------------
// Constructors
6.6. CLASSREADER.JAVA 67

// ------------------------------------------------------------------

/**
* Constructs a new {@link ClassReader} object.
*
* @param b the bytecode of the class to be read.
*/
public ClassReader(final byte[] b){
this(b, 0, b.length);
}

/**
* Constructs a new {@link ClassReader} object.
*
* @param b the bytecode of the class to be read.
* @param off the start offset of the class data.
* @param len the length of the class data.
*/
public ClassReader(final byte[] b, final int off, final int len){
this.b = b;
// parses the constant pool
items = new int[readUnsignedShort(off + 8)];
int n = items.length;
strings = new String[n];
int max = 0;
int index = off + 10;
for(int i = 1; i < n; ++i)
{
items[i] = index + 1;
int size;
switch(b[index])
{
case ClassWriter.FIELD:
case ClassWriter.METH:
case ClassWriter.IMETH:
case ClassWriter.INT:
case ClassWriter.FLOAT:
case ClassWriter.NAME_TYPE:
size = 5;
break;
case ClassWriter.LONG:
case ClassWriter.DOUBLE:
size = 9;
++i;
break;
case ClassWriter.UTF8:
size = 3 + readUnsignedShort(index + 1);
if(size > max)
{
max = size;
68 CHAPTER 6. JVM/CLOJURE/ASM/

}
break;
// case ClassWriter.CLASS:
// case ClassWriter.STR:
default:
size = 3;
break;
}
index += size;
}
maxStringLength = max;
// the class header information starts just after the constant pool
header = index;
}

/**
* Returns the class’s access flags (see {@link Opcodes}). This value may
* not reflect Deprecated and Synthetic flags when bytecode is before 1.5
* and those flags are represented by attributes.
*
* @return the class access flags
* @see ClassVisitor#visit(int,int,String,String,String,String[])
*/
public int getAccess(){
return readUnsignedShort(header);
}

/**
* Returns the internal name of the class (see
* {@link Type#getInternalName() getInternalName}).
*
* @return the internal class name
* @see ClassVisitor#visit(int,int,String,String,String,String[])
*/
public String getClassName(){
return readClass(header + 2, new char[maxStringLength]);
}

/**
* Returns the internal of name of the super class (see
* {@link Type#getInternalName() getInternalName}). For interfaces, the
* super class is {@link Object}.
*
* @return the internal name of super class, or <tt>null</tt> for
* {@link Object} class.
* @see ClassVisitor#visit(int,int,String,String,String,String[])
*/
public String getSuperName(){
int n = items[readUnsignedShort(header + 4)];
return n == 0 ? null : readUTF8(n, new char[maxStringLength]);
6.6. CLASSREADER.JAVA 69

/**
* Returns the internal names of the class’s interfaces (see
* {@link Type#getInternalName() getInternalName}).
*
* @return the array of internal names for all implemented interfaces or
* <tt>null</tt>.
* @see ClassVisitor#visit(int,int,String,String,String,String[])
*/
public String[] getInterfaces(){
int index = header + 6;
int n = readUnsignedShort(index);
String[] interfaces = new String[n];
if(n > 0)
{
char[] buf = new char[maxStringLength];
for(int i = 0; i < n; ++i)
{
index += 2;
interfaces[i] = readClass(index, buf);
}
}
return interfaces;
}

/**
* Copies the constant pool data into the given {@link ClassWriter}.
* Should be called before the {@link #accept(ClassVisitor,int)} method.
*
* @param classWriter the {@link ClassWriter} to copy constant pool into.
*/
void copyPool(final ClassWriter classWriter){
char[] buf = new char[maxStringLength];
int ll = items.length;
Item[] items2 = new Item[ll];
for(int i = 1; i < ll; i++)
{
int index = items[i];
int tag = b[index - 1];
Item item = new Item(i);
int nameType;
switch(tag)
{
case ClassWriter.FIELD:
case ClassWriter.METH:
case ClassWriter.IMETH:
nameType = items[readUnsignedShort(index + 2)];
item.set(tag,
readClass(index, buf),
70 CHAPTER 6. JVM/CLOJURE/ASM/

readUTF8(nameType, buf),
readUTF8(nameType + 2, buf));
break;

case ClassWriter.INT:
item.set(readInt(index));
break;

case ClassWriter.FLOAT:
item.set(Float.intBitsToFloat(readInt(index)));
break;

case ClassWriter.NAME_TYPE:
item.set(tag,
readUTF8(index, buf),
readUTF8(index + 2, buf),
null);
break;

case ClassWriter.LONG:
item.set(readLong(index));
++i;
break;

case ClassWriter.DOUBLE:
item.set(Double.longBitsToDouble(readLong(index)));
++i;
break;

case ClassWriter.UTF8:
{
String s = strings[i];
if(s == null)
{
index = items[i];
s = strings[i] = readUTF(index + 2,
readUnsignedShort(index),
buf);
}
item.set(tag, s, null, null);
}
break;

// case ClassWriter.STR:
// case ClassWriter.CLASS:
default:
item.set(tag, readUTF8(index, buf), null, null);
break;
}
6.6. CLASSREADER.JAVA 71

int index2 = item.hashCode % items2.length;

item.next = items2[index2];
items2[index2] = item;
}

int off = items[1] - 1;

classWriter.pool.putByteArray(b, off, header - off);
classWriter.items = items2;
classWriter.threshold = (int) (0.75d * ll);
classWriter.index = ll;
}

/**
* Constructs a new {@link ClassReader} object.
*
* @param is an input stream from which to read the class.
* @throws IOException if a problem occurs during reading.
*/
public ClassReader(final InputStream is) throws IOException{
this(readClass(is));
}

/**
* Constructs a new {@link ClassReader} object.
*
* @param name the fully qualified name of the class to be read.
* @throws IOException if an exception occurs during reading.
*/
public ClassReader(final String name) throws IOException{
this(ClassLoader.getSystemResourceAsStream(name.replace(’.’, ’/’)
+ ".class"));
}

/**
* Reads the bytecode of a class.
*
* @param is an input stream from which to read the class.
* @return the bytecode read from the given input stream.
* @throws IOException if a problem occurs during reading.
*/
private static byte[] readClass(final InputStream is) throws IOException{
if(is == null)
{
throw new IOException("Class not found");
}
byte[] b = new byte[is.available()];
int len = 0;
while(true)
{
int n = is.read(b, len, b.length - len);
72 CHAPTER 6. JVM/CLOJURE/ASM/

if(n == -1)
{
if(len < b.length)
{
byte[] c = new byte[len];
System.arraycopy(b, 0, c, 0, len);
b = c;
}
return b;
}
len += n;
if(len == b.length)
{
byte[] c = new byte[b.length + 1000];
System.arraycopy(b, 0, c, 0, len);
b = c;
}
}
}

// -------------------------------------------------------------------
// Public methods
// -------------------------------------------------------------------

/**
* Makes the given visitor visit the Java class of this
* {@link ClassReader}. This class is the one specified in the
* constructor (see {@link #ClassReader(byte[]) ClassReader}).
*
* @param classVisitor the visitor that must visit this class.
* @param flags option flags that can be used to modify
* the default behavior of this class. See
* {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}.
*/
public void accept(final ClassVisitor classVisitor, final int flags){
accept(classVisitor, new Attribute[0], flags);
}

/**
* Makes the given visitor visit the Java class of this
* {@link ClassReader}. This class is the one specified in the
* constructor (see {@link #ClassReader(byte[]) ClassReader}).
*
* @param classVisitor the visitor that must visit this class.
* @param attrs prototypes of the attributes that must be parsed
* during the visit of the class. Any attribute whose
* type is not equal to the type of one the
* prototypes will not be parsed: its byte array
* value will be passed unchanged to the ClassWriter.
* This may corrupt it if this value contains
6.6. CLASSREADER.JAVA 73

* references to the constant pool, or has syntactic

* or semantic links with a class element that has
* been transformed by a class adapter between the
* reader and the writer.
* @param flags option flags that can be used to modify the
* default behavior of this class. See
* {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}.
*/
public void accept(
final ClassVisitor classVisitor,
final Attribute[] attrs,
final int flags){
byte[] b = this.b; // the bytecode array
char[] c = new char[maxStringLength]; // buffer used to read strings
int i, j, k; // loop variables
int u, v, w; // indexes in b
Attribute attr;

int access;
String name;
String desc;
String attrName;
String signature;
int anns = 0;
int ianns = 0;
Attribute cattrs = null;

// visits the header

u = header;
access = readUnsignedShort(u);
name = readClass(u + 2, c);
v = items[readUnsignedShort(u + 4)];
String superClassName = v == 0 ? null : readUTF8(v, c);
String[] implementedItfs = new String[readUnsignedShort(u + 6)];
w = 0;
u += 8;
for(i = 0; i < implementedItfs.length; ++i)
{
implementedItfs[i] = readClass(u, c);
u += 2;
}

boolean skipCode = (flags & SKIP_CODE) != 0;

boolean skipDebug = (flags & SKIP_DEBUG) != 0;
boolean unzip = (flags & EXPAND_FRAMES) != 0;

// skips fields and methods

v = u;
i = readUnsignedShort(v);
v += 2;
74 CHAPTER 6. JVM/CLOJURE/ASM/

for(; i > 0; --i)

{
j = readUnsignedShort(v + 6);
v += 8;
for(; j > 0; --j)
{
v += 6 + readInt(v + 2);
}
}
i = readUnsignedShort(v);
v += 2;
for(; i > 0; --i)
{
j = readUnsignedShort(v + 6);
v += 8;
for(; j > 0; --j)
{
v += 6 + readInt(v + 2);
}
}
// reads the class’s attributes
signature = null;
String sourceFile = null;
String sourceDebug = null;
String enclosingOwner = null;
String enclosingName = null;
String enclosingDesc = null;

i = readUnsignedShort(v);
v += 2;
for(; i > 0; --i)
{
attrName = readUTF8(v, c);
// tests are sorted in decreasing frequency order
// (based on frequencies observed on typical classes)
if(attrName.equals("SourceFile"))
{
sourceFile = readUTF8(v + 6, c);
}
else if(attrName.equals("InnerClasses"))
{
w = v + 6;
}
else if(attrName.equals("EnclosingMethod"))
{
enclosingOwner = readClass(v + 6, c);
int item = readUnsignedShort(v + 8);
if(item != 0)
{
enclosingName = readUTF8(items[item], c);
6.6. CLASSREADER.JAVA 75

enclosingDesc = readUTF8(items[item] + 2, c);

}
}
else if(attrName.equals("Signature"))
{
signature = readUTF8(v + 6, c);
}
else if(attrName.equals("RuntimeVisibleAnnotations"))
{
anns = v + 6;
}
else if(attrName.equals("Deprecated"))
{
access |= Opcodes.ACC_DEPRECATED;
}
else if(attrName.equals("Synthetic"))
{
access |= Opcodes.ACC_SYNTHETIC;
}
else if(attrName.equals("SourceDebugExtension"))
{
int len = readInt(v + 2);
sourceDebug = readUTF(v + 6, len, new char[len]);
}
else if(attrName.equals("RuntimeInvisibleAnnotations"))
{
ianns = v + 6;
}
else
{
attr = readAttribute(attrs,
attrName,
v + 6,
readInt(v + 2),
c,
-1,
null);
if(attr != null)
{
attr.next = cattrs;
cattrs = attr;
}
}
v += 6 + readInt(v + 2);
}
// calls the visit method
classVisitor.visit(readInt(4),
access,
name,
signature,
76 CHAPTER 6. JVM/CLOJURE/ASM/

superClassName,
implementedItfs);

// calls the visitSource method

if(!skipDebug && (sourceFile != null || sourceDebug != null))
{
classVisitor.visitSource(sourceFile, sourceDebug);
}

// calls the visitOuterClass method

if(enclosingOwner != null)
{
classVisitor.visitOuterClass(enclosingOwner,
enclosingName,
enclosingDesc);
}

// visits the class annotations

for(i = 1; i >= 0; --i)
{
v = i == 0 ? ianns : anns;
if(v != 0)
{
j = readUnsignedShort(v);
v += 2;
for(; j > 0; --j)
{
v = readAnnotationValues(v + 2, c, true,
classVisitor.visitAnnotation(readUTF8(v, c), i != 0));
}
}
}

// visits the class attributes

while(cattrs != null)
{
attr = cattrs.next;
cattrs.next = null;
classVisitor.visitAttribute(cattrs);
cattrs = attr;
}

// calls the visitInnerClass method

if(w != 0)
{
i = readUnsignedShort(w);
w += 2;
for(; i > 0; --i)
{
classVisitor.visitInnerClass(
6.6. CLASSREADER.JAVA 77

readUnsignedShort(w) == 0
? null
: readClass(w, c), readUnsignedShort(w + 2) == 0
? null
: readClass(w + 2, c), readUnsignedShort(w + 4) == 0
? null
: readUTF8(w + 4, c),
readUnsignedShort(w + 6));
w += 8;
}
}

// visits the fields

i = readUnsignedShort(u);
u += 2;
for(; i > 0; --i)
{
access = readUnsignedShort(u);
name = readUTF8(u + 2, c);
desc = readUTF8(u + 4, c);
// visits the field’s attributes and looks for a ConstantValue
// attribute
int fieldValueItem = 0;
signature = null;
anns = 0;
ianns = 0;
cattrs = null;

j = readUnsignedShort(u + 6);
u += 8;
for(; j > 0; --j)
{
attrName = readUTF8(u, c);
// tests are sorted in decreasing frequency order
// (based on frequencies observed on typical classes)
if(attrName.equals("ConstantValue"))
{
fieldValueItem = readUnsignedShort(u + 6);
}
else if(attrName.equals("Signature"))
{
signature = readUTF8(u + 6, c);
}
else if(attrName.equals("Deprecated"))
{
access |= Opcodes.ACC_DEPRECATED;
}
else if(attrName.equals("Synthetic"))
{
access |= Opcodes.ACC_SYNTHETIC;
78 CHAPTER 6. JVM/CLOJURE/ASM/

}
else if(attrName.equals("RuntimeVisibleAnnotations"))
{
anns = u + 6;
}
else if(attrName.equals("RuntimeInvisibleAnnotations"))
{
ianns = u + 6;
}
else
{
attr = readAttribute(attrs,
attrName,
u + 6,
readInt(u + 2),
c,
-1,
null);
if(attr != null)
{
attr.next = cattrs;
cattrs = attr;
}
}
u += 6 + readInt(u + 2);
}
// visits the field
FieldVisitor fv =
classVisitor.visitField(access, name, desc, signature,
fieldValueItem == 0 ? null : readConst(fieldValueItem, c));
// visits the field annotations and attributes
if(fv != null)
{
for(j = 1; j >= 0; --j)
{
v = j == 0 ? ianns : anns;
if(v != 0)
{
k = readUnsignedShort(v);
v += 2;
for(; k > 0; --k)
{
v = readAnnotationValues(v + 2, c, true,
fv.visitAnnotation(readUTF8(v, c), j != 0));
}
}
}
while(cattrs != null)
{
attr = cattrs.next;
6.6. CLASSREADER.JAVA 79

cattrs.next = null;
fv.visitAttribute(cattrs);
cattrs = attr;
}
fv.visitEnd();
}
}

// visits the methods

i = readUnsignedShort(u);
u += 2;
for(; i > 0; --i)
{
int u0 = u + 6;
access = readUnsignedShort(u);
name = readUTF8(u + 2, c);
desc = readUTF8(u + 4, c);
signature = null;
anns = 0;
ianns = 0;
int dann = 0;
int mpanns = 0;
int impanns = 0;
cattrs = null;
v = 0;
w = 0;

// looks for Code and Exceptions attributes

j = readUnsignedShort(u + 6);
u += 8;
for(; j > 0; --j)
{
attrName = readUTF8(u, c);
int attrSize = readInt(u + 2);
u += 6;
// tests are sorted in decreasing frequency order
// (based on frequencies observed on typical classes)
if(attrName.equals("Code"))
{
if(!skipCode)
{
v = u;
}
}
else if(attrName.equals("Exceptions"))
{
w = u;
}
else if(attrName.equals("Signature"))
{
80 CHAPTER 6. JVM/CLOJURE/ASM/

signature = readUTF8(u, c);

}
else if(attrName.equals("Deprecated"))
{
access |= Opcodes.ACC_DEPRECATED;
}
else if(attrName.equals("RuntimeVisibleAnnotations"))
{
anns = u;
}
else if(attrName.equals("AnnotationDefault"))
{
dann = u;
}
else if(attrName.equals("Synthetic"))
{
access |= Opcodes.ACC_SYNTHETIC;
}
else if(attrName.equals("RuntimeInvisibleAnnotations"))
{
ianns = u;
}
else if(attrName.equals(
"RuntimeVisibleParameterAnnotations"))
{
mpanns = u;
}
else if(attrName.equals(
"RuntimeInvisibleParameterAnnotations"))
{
impanns = u;
}
else
{
attr = readAttribute(attrs,
attrName,
u,
attrSize,
c,
-1,
null);
if(attr != null)
{
attr.next = cattrs;
cattrs = attr;
}
}
u += attrSize;
}
// reads declared exceptions
6.6. CLASSREADER.JAVA 81

String[] exceptions;
if(w == 0)
{
exceptions = null;
}
else
{
exceptions = new String[readUnsignedShort(w)];
w += 2;
for(j = 0; j < exceptions.length; ++j)
{
exceptions[j] = readClass(w, c);
w += 2;
}
}

// visits the method’s code, if any

MethodVisitor mv = classVisitor.visitMethod(access,
name,
desc,
signature,
exceptions);

if(mv != null)
{
/*
* if the returned MethodVisitor is in fact a MethodWriter, it
* means there is no method adapter between the reader and the
* writer. If, in addition, the writer’s constant pool was
* copied from this reader (mw.cw.cr == this), and the
* signature and exceptions of the method have not been
* changed, then it is possible to skip all visit events and
* just copy the original code of the method to the writer
* (the access, name and descriptor can have been changed,
* this is not important since they are not copied as is from
* the reader).
*/
if(mv instanceof MethodWriter)
{
MethodWriter mw = (MethodWriter) mv;
if(mw.cw.cr == this)
{
if(signature == mw.signature)
{
boolean sameExceptions = false;
if(exceptions == null)
{
sameExceptions = mw.exceptionCount == 0;
}
else
82 CHAPTER 6. JVM/CLOJURE/ASM/

{
if(exceptions.length == mw.exceptionCount)
{
sameExceptions = true;
for(j = exceptions.length - 1; j >= 0; --j)
{
w -= 2;
if(mw.exceptions[j] !=
readUnsignedShort(w))
{
sameExceptions = false;
break;
}
}
}
}
if(sameExceptions)
{
/*
* we do not copy directly the code into
* MethodWriter to save a byte array copy
* operation. The real copy will be done in
* ClassWriter.toByteArray().
*/
mw.classReaderOffset = u0;
mw.classReaderLength = u - u0;
continue;
}
}
}
}

if(dann != 0)
{
AnnotationVisitor dv = mv.visitAnnotationDefault();
readAnnotationValue(dann, c, null, dv);
if(dv != null)
{
dv.visitEnd();
}
}
for(j = 1; j >= 0; --j)
{
w = j == 0 ? ianns : anns;
if(w != 0)
{
k = readUnsignedShort(w);
w += 2;
for(; k > 0; --k)
{
6.6. CLASSREADER.JAVA 83

w = readAnnotationValues(w + 2, c, true,
mv.visitAnnotation(readUTF8(w, c), j != 0));
}
}
}
if(mpanns != 0)
{
readParameterAnnotations(mpanns, c, true, mv);
}
if(impanns != 0)
{
readParameterAnnotations(impanns, c, false, mv);
}
while(cattrs != null)
{
attr = cattrs.next;
cattrs.next = null;
mv.visitAttribute(cattrs);
cattrs = attr;
}
}

if(mv != null && v != 0)

{
int maxStack = readUnsignedShort(v);
int maxLocals = readUnsignedShort(v + 2);
int codeLength = readInt(v + 4);
v += 8;

int codeStart = v;
int codeEnd = v + codeLength;

mv.visitCode();

// 1st phase: finds the labels

int label;
Label[] labels = new Label[codeLength + 1];
while(v < codeEnd)
{
int opcode = b[v] & 0xFF;
switch(ClassWriter.TYPE[opcode])
{
case ClassWriter.NOARG_INSN:
case ClassWriter.IMPLVAR_INSN:
v += 1;
break;
case ClassWriter.LABEL_INSN:
label = v - codeStart + readShort(v + 1);
if(labels[label] == null)
{
84 CHAPTER 6. JVM/CLOJURE/ASM/

labels[label] = new Label();

}
v += 3;
break;
case ClassWriter.LABELW_INSN:
label = v - codeStart + readInt(v + 1);
if(labels[label] == null)
{
labels[label] = new Label();
}
v += 5;
break;
case ClassWriter.WIDE_INSN:
opcode = b[v + 1] & 0xFF;
if(opcode == Opcodes.IINC)
{
v += 6;
}
else
{
v += 4;
}
break;
case ClassWriter.TABL_INSN:
// skips 0 to 3 padding bytes
w = v - codeStart;
v = v + 4 - (w & 3);
// reads instruction
label = w + readInt(v);
if(labels[label] == null)
{
labels[label] = new Label();
}
j = readInt(v + 8) - readInt(v + 4) + 1;
v += 12;
for(; j > 0; --j)
{
label = w + readInt(v);
v += 4;
if(labels[label] == null)
{
labels[label] = new Label();
}
}
break;
case ClassWriter.LOOK_INSN:
// skips 0 to 3 padding bytes
w = v - codeStart;
v = v + 4 - (w & 3);
// reads instruction
6.6. CLASSREADER.JAVA 85

label = w + readInt(v);
if(labels[label] == null)
{
labels[label] = new Label();
}
j = readInt(v + 4);
v += 8;
for(; j > 0; --j)
{
label = w + readInt(v + 4);
v += 8;
if(labels[label] == null)
{
labels[label] = new Label();
}
}
break;
case ClassWriter.VAR_INSN:
case ClassWriter.SBYTE_INSN:
case ClassWriter.LDC_INSN:
v += 2;
break;
case ClassWriter.SHORT_INSN:
case ClassWriter.LDCW_INSN:
case ClassWriter.FIELDORMETH_INSN:
case ClassWriter.TYPE_INSN:
case ClassWriter.IINC_INSN:
v += 3;
break;
case ClassWriter.ITFMETH_INSN:
v += 5;
break;
// case MANA_INSN:
default:
v += 4;
break;
}
}
// parses the try catch entries
j = readUnsignedShort(v);
v += 2;
for(; j > 0; --j)
{
label = readUnsignedShort(v);
Label start = labels[label];
if(start == null)
{
labels[label] = start = new Label();
}
label = readUnsignedShort(v + 2);
86 CHAPTER 6. JVM/CLOJURE/ASM/

Label end = labels[label];

if(end == null)
{
labels[label] = end = new Label();
}
label = readUnsignedShort(v + 4);
Label handler = labels[label];
if(handler == null)
{
labels[label] = handler = new Label();
}
int type = readUnsignedShort(v + 6);
if(type == 0)
{
mv.visitTryCatchBlock(start, end, handler, null);
}
else
{
mv.visitTryCatchBlock(start,
end,
handler,
readUTF8(items[type], c));
}
v += 8;
}
// parses the local variable, line number tables, and code
// attributes
int varTable = 0;
int varTypeTable = 0;
int stackMap = 0;
int frameCount = 0;
int frameMode = 0;
int frameOffset = 0;
int frameLocalCount = 0;
int frameLocalDiff = 0;
int frameStackCount = 0;
Object[] frameLocal = null;
Object[] frameStack = null;
boolean zip = true;
cattrs = null;
j = readUnsignedShort(v);
v += 2;
for(; j > 0; --j)
{
attrName = readUTF8(v, c);
if(attrName.equals("LocalVariableTable"))
{
if(!skipDebug)
{
varTable = v + 6;
6.6. CLASSREADER.JAVA 87

k = readUnsignedShort(v + 6);
w = v + 8;
for(; k > 0; --k)
{
label = readUnsignedShort(w);
if(labels[label] == null)
{
labels[label] = new Label(true);
}
label += readUnsignedShort(w + 2);
if(labels[label] == null)
{
labels[label] = new Label(true);
}
w += 10;
}
}
}
else if(attrName.equals("LocalVariableTypeTable"))
{
varTypeTable = v + 6;
}
else if(attrName.equals("LineNumberTable"))
{
if(!skipDebug)
{
k = readUnsignedShort(v + 6);
w = v + 8;
for(; k > 0; --k)
{
label = readUnsignedShort(w);
if(labels[label] == null)
{
labels[label] = new Label(true);
}
labels[label].line=readUnsignedShort(w + 2);
w += 4;
}
}
}
else if(attrName.equals("StackMapTable"))
{
if((flags & SKIP_FRAMES) == 0)
{
stackMap = v + 8;
frameCount = readUnsignedShort(v + 6);
}
/*
* here we do not extract the labels corresponding to
* the attribute content. This would require a full
88 CHAPTER 6. JVM/CLOJURE/ASM/

* parsing of the attribute, which would need to be

* repeated in the second phase (see below). Instead the
* content of the attribute is read one frame at a time
* (i.e. after a frame has been visited, the next frame
* is read), and the labels it contains are also
* extracted one frame at a time. Thanks to the ordering
* of frames, having only a "one frame lookahead" is not
* a problem, i.e. it is not possible to see an offset
* smaller than the offset of the current insn and for
* which no Label exist.
*/
// TODO true for frame offsets,
// but for UNINITIALIZED type offsets?
}
else if(attrName.equals("StackMap"))
{
if((flags & SKIP_FRAMES) == 0)
{
stackMap = v + 8;
frameCount = readUnsignedShort(v + 6);
zip = false;
}
/*
* IMPORTANT! here we assume that the frames are
* ordered, as in the StackMapTable attribute,
* although this is not guaranteed by the
* attribute format.
*/
}
else
{
for(k = 0; k < attrs.length; ++k)
{
if(attrs[k].type.equals(attrName))
{
attr = attrs[k].read(this,
v + 6,
readInt(v + 2),
c,
codeStart - 8,
labels);
if(attr != null)
{
attr.next = cattrs;
cattrs = attr;
}
}
}
}
v += 6 + readInt(v + 2);
6.6. CLASSREADER.JAVA 89

// 2nd phase: visits each instruction

if(stackMap != 0)
{
// creates the very first (implicit) frame from the
// method descriptor
frameLocal = new Object[maxLocals];
frameStack = new Object[maxStack];
if(unzip)
{
int local = 0;
if((access & Opcodes.ACC_STATIC) == 0)
{
if(name.equals("<init>"))
{
frameLocal[local++] = Opcodes.UNINITIALIZED_THIS;
}
else
{
frameLocal[local++] = readClass(header + 2, c);
}
}
j = 1;
loop:
while(true)
{
k = j;
switch(desc.charAt(j++))
{
case’Z’:
case’C’:
case’B’:
case’S’:
case’I’:
frameLocal[local++] = Opcodes.INTEGER;
break;
case’F’:
frameLocal[local++] = Opcodes.FLOAT;
break;
case’J’:
frameLocal[local++] = Opcodes.LONG;
break;
case’D’:
frameLocal[local++] = Opcodes.DOUBLE;
break;
case’[’:
while(desc.charAt(j) == ’[’)
{
++j;
90 CHAPTER 6. JVM/CLOJURE/ASM/

}
if(desc.charAt(j) == ’L’)
{
++j;
while(desc.charAt(j) != ’;’)
{
++j;
}
}
frameLocal[local++] =
desc.substring(k, ++j);
break;
case’L’:
while(desc.charAt(j) != ’;’)
{
++j;
}
frameLocal[local++] =
desc.substring(k + 1, j++);
break;
default:
break loop;
}
}
frameLocalCount = local;
}
/*
* for the first explicit frame the offset is not
* offset_delta + 1 but only offset_delta; setting the
* implicit frame offset to -1 allow the use of the
* "offset_delta + 1" rule in all cases
*/
frameOffset = -1;
}
v = codeStart;
Label l;
while(v < codeEnd)
{
w = v - codeStart;

l = labels[w];
if(l != null)
{
mv.visitLabel(l);
if(!skipDebug && l.line > 0)
{
mv.visitLineNumber(l.line, l);
}
}
6.6. CLASSREADER.JAVA 91

while(frameLocal != null
&& (frameOffset == w || frameOffset == -1))
{
// if there is a frame for this offset,
// makes the visitor visit it,
// and reads the next frame if there is one.
if(!zip || unzip)
{
mv.visitFrame(Opcodes.F_NEW,
frameLocalCount,
frameLocal,
frameStackCount,
frameStack);
}
else if(frameOffset != -1)
{
mv.visitFrame(frameMode,
frameLocalDiff,
frameLocal,
frameStackCount,
frameStack);
}

if(frameCount > 0)
{
int tag, delta, n;
if(zip)
{
tag = b[stackMap++] & 0xFF;
}
else
{
tag = MethodWriter.FULL_FRAME;
frameOffset = -1;
}
frameLocalDiff = 0;
if(tag <
MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME)
{
delta = tag;
frameMode = Opcodes.F_SAME;
frameStackCount = 0;
}
else if(tag < MethodWriter.RESERVED)
{
delta = tag
- MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME;
stackMap = readFrameType(frameStack,
0,
stackMap,
92 CHAPTER 6. JVM/CLOJURE/ASM/

c,
labels);
frameMode = Opcodes.F_SAME1;
frameStackCount = 1;
}
else
{
delta = readUnsignedShort(stackMap);
stackMap += 2;
if(tag ==
MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
{
stackMap = readFrameType(frameStack,
0,
stackMap,
c,
labels);
frameMode = Opcodes.F_SAME1;
frameStackCount = 1;
}
else if(tag >= MethodWriter.CHOP_FRAME &&
tag < MethodWriter.SAME_FRAME_EXTENDED)
{
frameMode = Opcodes.F_CHOP;
frameLocalDiff =
MethodWriter.SAME_FRAME_EXTENDED
- tag;
frameLocalCount -= frameLocalDiff;
frameStackCount = 0;
}
else if(tag ==
MethodWriter.SAME_FRAME_EXTENDED)
{
frameMode = Opcodes.F_SAME;
frameStackCount = 0;
}
else if(tag < MethodWriter.FULL_FRAME)
{
j = unzip ? frameLocalCount : 0;
for(k = tag
- MethodWriter.SAME_FRAME_EXTENDED;
k > 0; k--)
{
stackMap = readFrameType(frameLocal,
j++,
stackMap,
c,
labels);
}
frameMode = Opcodes.F_APPEND;
6.6. CLASSREADER.JAVA 93

frameLocalDiff = tag
- MethodWriter.SAME_FRAME_EXTENDED;
frameLocalCount += frameLocalDiff;
frameStackCount = 0;
}
else
{ // if (tag == FULL_FRAME) {
frameMode = Opcodes.F_FULL;
n = frameLocalDiff
= frameLocalCount
= readUnsignedShort(stackMap);
stackMap += 2;
for(j = 0; n > 0; n--)
{
stackMap = readFrameType(frameLocal,
j++,
stackMap,
c,
labels);
}
n = frameStackCount
= readUnsignedShort(stackMap);
stackMap += 2;
for(j = 0; n > 0; n--)
{
stackMap = readFrameType(frameStack,
j++,
stackMap,
c,
labels);
}
}
}
frameOffset += delta + 1;
if(labels[frameOffset] == null)
{
labels[frameOffset] = new Label();
}

--frameCount;
}
else
{
frameLocal = null;
}
}

int opcode = b[v] & 0xFF;

switch(ClassWriter.TYPE[opcode])
{
94 CHAPTER 6. JVM/CLOJURE/ASM/

case ClassWriter.NOARG_INSN:
mv.visitInsn(opcode);
v += 1;
break;
case ClassWriter.IMPLVAR_INSN:
if(opcode > Opcodes.ISTORE)
{
opcode -= 59; // ISTORE_0
mv.visitVarInsn(
Opcodes.ISTORE + (opcode >> 2),
opcode & 0x3);
}
else
{
opcode -= 26; // ILOAD_0
mv.visitVarInsn(
Opcodes.ILOAD + (opcode >> 2),
opcode & 0x3);
}
v += 1;
break;
case ClassWriter.LABEL_INSN:
mv.visitJumpInsn(opcode,
labels[w + readShort(v + 1)]);
v += 3;
break;
case ClassWriter.LABELW_INSN:
mv.visitJumpInsn(opcode - 33,
labels[w + readInt(v + 1)]);
v += 5;
break;
case ClassWriter.WIDE_INSN:
opcode = b[v + 1] & 0xFF;
if(opcode == Opcodes.IINC)
{
mv.visitIincInsn(readUnsignedShort(v + 2),
readShort(v + 4));
v += 6;
}
else
{
mv.visitVarInsn(opcode,
readUnsignedShort(v + 2));
v += 4;
}
break;
case ClassWriter.TABL_INSN:
// skips 0 to 3 padding bytes
v = v + 4 - (w & 3);
// reads instruction
6.6. CLASSREADER.JAVA 95

label = w + readInt(v);
int min = readInt(v + 4);
int max = readInt(v + 8);
v += 12;
Label[] table = new Label[max - min + 1];
for(j = 0; j < table.length; ++j)
{
table[j] = labels[w + readInt(v)];
v += 4;
}
mv.visitTableSwitchInsn(min,
max,
labels[label],
table);
break;
case ClassWriter.LOOK_INSN:
// skips 0 to 3 padding bytes
v = v + 4 - (w & 3);
// reads instruction
label = w + readInt(v);
j = readInt(v + 4);
v += 8;
int[] keys = new int[j];
Label[] values = new Label[j];
for(j = 0; j < keys.length; ++j)
{
keys[j] = readInt(v);
values[j] = labels[w + readInt(v + 4)];
v += 8;
}
mv.visitLookupSwitchInsn(labels[label],
keys,
values);
break;
case ClassWriter.VAR_INSN:
mv.visitVarInsn(opcode, b[v + 1] & 0xFF);
v += 2;
break;
case ClassWriter.SBYTE_INSN:
mv.visitIntInsn(opcode, b[v + 1]);
v += 2;
break;
case ClassWriter.SHORT_INSN:
mv.visitIntInsn(opcode, readShort(v + 1));
v += 3;
break;
case ClassWriter.LDC_INSN:
mv.visitLdcInsn(readConst(b[v + 1] & 0xFF, c));
v += 2;
break;
96 CHAPTER 6. JVM/CLOJURE/ASM/

case ClassWriter.LDCW_INSN:
mv.visitLdcInsn(
readConst(readUnsignedShort(v + 1), c));
v += 3;
break;
case ClassWriter.FIELDORMETH_INSN:
case ClassWriter.ITFMETH_INSN:
int cpIndex = items[readUnsignedShort(v + 1)];
String iowner = readClass(cpIndex, c);
cpIndex = items[readUnsignedShort(cpIndex + 2)];
String iname = readUTF8(cpIndex, c);
String idesc = readUTF8(cpIndex + 2, c);
if(opcode < Opcodes.INVOKEVIRTUAL)
{
mv.visitFieldInsn(opcode,iowner,iname,idesc);
}
else
{
mv.visitMethodInsn(opcode,iowner,iname,idesc);
}
if(opcode == Opcodes.INVOKEINTERFACE)
{
v += 5;
}
else
{
v += 3;
}
break;
case ClassWriter.TYPE_INSN:
mv.visitTypeInsn(opcode, readClass(v + 1, c));
v += 3;
break;
case ClassWriter.IINC_INSN:
mv.visitIincInsn(b[v + 1] & 0xFF, b[v + 2]);
v += 3;
break;
// case MANA_INSN:
default:
mv.visitMultiANewArrayInsn(readClass(v + 1, c),
b[v + 3] & 0xFF);
v += 4;
break;
}
}
l = labels[codeEnd - codeStart];
if(l != null)
{
mv.visitLabel(l);
}
6.6. CLASSREADER.JAVA 97

// visits the local variable tables

if(!skipDebug && varTable != 0)
{
int[] typeTable = null;
if(varTypeTable != 0)
{
k = readUnsignedShort(varTypeTable) * 3;
w = varTypeTable + 2;
typeTable = new int[k];
while(k > 0)
{
typeTable[--k]= w + 6; // signature
typeTable[--k]= readUnsignedShort(w + 8); //index
typeTable[--k]= readUnsignedShort(w); // start
w += 10;
}
}
k = readUnsignedShort(varTable);
w = varTable + 2;
for(; k > 0; --k)
{
int start = readUnsignedShort(w);
int length = readUnsignedShort(w + 2);
int index = readUnsignedShort(w + 8);
String vsignature = null;
if(typeTable != null)
{
for(int a = 0; a < typeTable.length; a += 3)
{
if(typeTable[a] == start
&& typeTable[a + 1] == index)
{
vsignature=readUTF8(typeTable[a + 2], c);
break;
}
}
}
mv.visitLocalVariable(readUTF8(w + 4, c),
readUTF8(w + 6, c),
vsignature,
labels[start],
labels[start + length],
index);
w += 10;
}
}
// visits the other attributes
while(cattrs != null)
{
attr = cattrs.next;
98 CHAPTER 6. JVM/CLOJURE/ASM/

cattrs.next = null;
mv.visitAttribute(cattrs);
cattrs = attr;
}
// visits the max stack and max locals values
mv.visitMaxs(maxStack, maxLocals);
}

if(mv != null)
{
mv.visitEnd();
}
}

// visits the end of the class

classVisitor.visitEnd();
}

/**
* Reads parameter annotations and makes the given visitor visit them.
*
* @param v start offset in {@link #b b} of the annotations to
* be read.
* @param buf buffer to be used to call {@link #readUTF8 readUTF8},
* {@link #readClass(int,char[]) readClass} or
* {@link #readConst readConst}.
* @param visible <tt>true</tt> if the annotations to be read are visible
* at runtime.
* @param mv the visitor that must visit the annotations.
*/
private void readParameterAnnotations(
int v,
final char[] buf,
final boolean visible,
final MethodVisitor mv){
int n = b[v++] & 0xFF;
for(int i = 0; i < n; ++i)
{
int j = readUnsignedShort(v);
v += 2;
for(; j > 0; --j)
{
v = readAnnotationValues(v + 2, buf, true,
mv.visitParameterAnnotation(i,readUTF8(v, buf),visible));
}
}
}

/**
* Reads the values of an annotation and makes the given visitor
6.6. CLASSREADER.JAVA 99

* visit them.
*
* @param v the start offset in {@link #b b} of the values to be
* read (including the unsigned short that gives the
* number of values).
* @param buf buffer to be used to call {@link #readUTF8 readUTF8},
* {@link #readClass(int,char[]) readClass} or
* {@link #readConst readConst}.
* @param named if the annotation values are named or not.
* @param av the visitor that must visit the values.
* @return the end offset of the annotation values.
*/
private int readAnnotationValues(
int v,
final char[] buf,
final boolean named,
final AnnotationVisitor av){
int i = readUnsignedShort(v);
v += 2;
if(named)
{
for(; i > 0; --i)
{
v = readAnnotationValue(v + 2, buf, readUTF8(v, buf), av);
}
}
else
{
for(; i > 0; --i)
{
v = readAnnotationValue(v, buf, null, av);
}
}
if(av != null)
{
av.visitEnd();
}
return v;
}

/**
* Reads a value of an annotation and makes the given visitor visit it.
*
* @param v the start offset in {@link #b b} of the value to be
* read (not including the value name constant pool
* index).
* @param buf buffer to be used to call {@link #readUTF8 readUTF8},
* {@link #readClass(int,char[]) readClass} or
* {@link #readConst readConst}.
* @param name the name of the value to be read.
100 CHAPTER 6. JVM/CLOJURE/ASM/

* @param av the visitor that must visit the value.

* @return the end offset of the annotation value.
*/
private int readAnnotationValue(
int v,
final char[] buf,
final String name,
final AnnotationVisitor av){
int i;
if(av == null)
{
switch(b[v] & 0xFF)
{
case’e’: // enum_const_value
return v + 5;
case’@’: // annotation_value
return readAnnotationValues(v + 3, buf, true, null);
case’[’: // array_value
return readAnnotationValues(v + 1, buf, false, null);
default:
return v + 3;
}
}
switch(b[v++] & 0xFF)
{
case’I’: // pointer to CONSTANT_Integer
case’J’: // pointer to CONSTANT_Long
case’F’: // pointer to CONSTANT_Float
case’D’: // pointer to CONSTANT_Double
av.visit(name, readConst(readUnsignedShort(v), buf));
v += 2;
break;
case’B’: // pointer to CONSTANT_Byte
av.visit(name,
new Byte((byte)
readInt(items[readUnsignedShort(v)])));
v += 2;
break;
case’Z’: // pointer to CONSTANT_Boolean
av.visit(name, readInt(items[readUnsignedShort(v)]) == 0
? Boolean.FALSE
: Boolean.TRUE);
v += 2;
break;
case’S’: // pointer to CONSTANT_Short
av.visit(name,
new Short((short)
readInt(items[readUnsignedShort(v)])));
v += 2;
break;
6.6. CLASSREADER.JAVA 101

case’C’: // pointer to CONSTANT_Char

av.visit(name,
new Character((char)
readInt(items[readUnsignedShort(v)])));
v += 2;
break;
case’s’: // pointer to CONSTANT_Utf8
av.visit(name, readUTF8(v, buf));
v += 2;
break;
case’e’: // enum_const_value
av.visitEnum(name, readUTF8(v, buf), readUTF8(v + 2, buf));
v += 4;
break;
case’c’: // class_info
av.visit(name, Type.getType(readUTF8(v, buf)));
v += 2;
break;
case’@’: // annotation_value
v = readAnnotationValues(v + 2, buf, true,
av.visitAnnotation(name, readUTF8(v, buf)));
break;
case’[’: // array_value
int size = readUnsignedShort(v);
v += 2;
if(size == 0)
{
return readAnnotationValues(v - 2,
buf,
false,
av.visitArray(name));
}
switch(this.b[v++] & 0xFF)
{
case’B’:
byte[] bv = new byte[size];
for(i = 0; i < size; i++)
{
bv[i] =
(byte) readInt(items[readUnsignedShort(v)]);
v += 3;
}
av.visit(name, bv);
--v;
break;
case’Z’:
boolean[] zv = new boolean[size];
for(i = 0; i < size; i++)
{
zv[i] =
102 CHAPTER 6. JVM/CLOJURE/ASM/

readInt(items[readUnsignedShort(v)]) != 0;
v += 3;
}
av.visit(name, zv);
--v;
break;
case’S’:
short[] sv = new short[size];
for(i = 0; i < size; i++)
{
sv[i] =
(short) readInt(items[readUnsignedShort(v)]);
v += 3;
}
av.visit(name, sv);
--v;
break;
case’C’:
char[] cv = new char[size];
for(i = 0; i < size; i++)
{
cv[i] =
(char) readInt(items[readUnsignedShort(v)]);
v += 3;
}
av.visit(name, cv);
--v;
break;
case’I’:
int[] iv = new int[size];
for(i = 0; i < size; i++)
{
iv[i] = readInt(items[readUnsignedShort(v)]);
v += 3;
}
av.visit(name, iv);
--v;
break;
case’J’:
long[] lv = new long[size];
for(i = 0; i < size; i++)
{
lv[i] = readLong(items[readUnsignedShort(v)]);
v += 3;
}
av.visit(name, lv);
--v;
break;
case’F’:
float[] fv = new float[size];
6.6. CLASSREADER.JAVA 103

for(i = 0; i < size; i++)

{
fv[i] =
Float.intBitsToFloat(
readInt(items[readUnsignedShort(v)]));
v += 3;
}
av.visit(name, fv);
--v;
break;
case’D’:
double[] dv = new double[size];
for(i = 0; i < size; i++)
{
dv[i] =
Double.longBitsToDouble(
readLong(items[readUnsignedShort(v)]));
v += 3;
}
av.visit(name, dv);
--v;
break;
default:
v = readAnnotationValues(v - 3,
buf,
false,
av.visitArray(name));
}
}
return v;
}

private int readFrameType(

final Object[] frame,
final int index,
int v,
final char[] buf,
final Label[] labels){
int type = b[v++] & 0xFF;
switch(type)
{
case 0:
frame[index] = Opcodes.TOP;
break;
case 1:
frame[index] = Opcodes.INTEGER;
break;
case 2:
frame[index] = Opcodes.FLOAT;
break;
104 CHAPTER 6. JVM/CLOJURE/ASM/

case 3:
frame[index] = Opcodes.DOUBLE;
break;
case 4:
frame[index] = Opcodes.LONG;
break;
case 5:
frame[index] = Opcodes.NULL;
break;
case 6:
frame[index] = Opcodes.UNINITIALIZED_THIS;
break;
case 7: // Object
frame[index] = readClass(v, buf);
v += 2;
break;
default: // Uninitialized
int offset = readUnsignedShort(v);
if(labels[offset] == null)
{
labels[offset] = new Label();
}
frame[index] = labels[offset];
v += 2;
}
return v;
}

/**
* Reads an attribute in {@link #b b}.
*
* @param attrs prototypes of the attributes that must be parsed during
* the visit of the class. Any attribute whose type is not
* equal to the type of one the prototypes is ignored
* (i.e. an empty {@link Attribute} instance is returned).
* @param type the type of the attribute.
* @param off index of the first byte of the attribute’s content in
* {@link #b b}. The 6 attribute header bytes, containing
* the type and the length of the attribute, are not taken
* into account here (they have already been read).
* @param len the length of the attribute’s content.
* @param buf buffer to be used to call {@link #readUTF8 readUTF8},
* {@link #readClass(int,char[]) readClass} or
* {@link #readConst readConst}.
* @param codeOff index of the first byte of code’s attribute content in
* {@link #b b}, or -1 if the attribute to be read is not
* a code attribute. The 6 attribute header bytes,
* containing the type and the length of the attribute,
* are not taken into account here.
* @param labels the labels of the method’s code, or <tt>null</tt> if
6.6. CLASSREADER.JAVA 105

* the attribute to be read is not a code attribute.

* @return the attribute that has been read, or <tt>null</tt> to skip
* this attribute.
*/
private Attribute readAttribute(
final Attribute[] attrs,
final String type,
final int off,
final int len,
final char[] buf,
final int codeOff,
final Label[] labels){
for(int i = 0; i < attrs.length; ++i)
{
if(attrs[i].type.equals(type))
{
return attrs[i].read(this, off, len, buf, codeOff, labels);
}
}
return new Attribute(type).read(this, off, len, null, -1, null);
}

// -------------------------------------------------------------------
// Utility methods: low level parsing
// -------------------------------------------------------------------

/**
* Returns the start index of the constant pool item in {@link #b b},
* plus one. This method is intended for {@link Attribute} sub
* classes, and is normally not needed by class generators or
* adapters.
*
* @param item the index a constant pool item.
* @return the start index of the constant pool item in {@link #b b},
* plus one.
*/
public int getItem(final int item){
return items[item];
}

/**
* Reads a byte value in {@link #b b}. This method is intended for
* {@link Attribute} sub classes, and is normally not needed by class
* generators or adapters.
*
* @param index the start index of the value to be read in {@link #b b}.
* @return the read value.
*/
public int readByte(final int index){
return b[index] & 0xFF;
106 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Reads an unsigned short value in {@link #b b}. This method is
* intended for {@link Attribute} sub classes, and is normally not
* needed by class generators or adapters.
*
* @param index the start index of the value to be read in {@link #b b}.
* @return the read value.
*/
public int readUnsignedShort(final int index){
byte[] b = this.b;
return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
}

/**
* Reads a signed short value in {@link #b b}. This method is intended
* for {@link Attribute} sub classes, and is normally not needed by class
* generators or adapters.
*
* @param index the start index of the value to be read in {@link #b b}.
* @return the read value.
*/
public short readShort(final int index){
byte[] b = this.b;
return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
}

/**
* Reads a signed int value in {@link #b b}. This method is intended
* for {@link Attribute} sub classes, and is normally not needed by
* class generators or adapters.
*
* @param index the start index of the value to be read in {@link #b b}.
* @return the read value.
*/
public int readInt(final int index){
byte[] b = this.b;
return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
| ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
}

/**
* Reads a signed long value in {@link #b b}. This method is intended
* for {@link Attribute} sub classes, and is normally not needed by class
* generators or adapters.
*
* @param index the start index of the value to be read in {@link #b b}.
* @return the read value.
*/
6.6. CLASSREADER.JAVA 107

public long readLong(final int index){

long l1 = readInt(index);
long l0 = readInt(index + 4) & 0xFFFFFFFFL;
return (l1 << 32) | l0;
}

/**
* Reads an UTF8 string constant pool item in {@link #b b}. This
* method is intended for {@link Attribute} sub classes, and is normally
* not needed by class generators or adapters.
*
* @param index the start index of an unsigned short value in
* {@link #b b}, whose value is the index of an UTF8
* constant pool item.
* @param buf buffer to be used to read the item. This buffer must be
* sufficiently large. It is not automatically resized.
* @return the String corresponding to the specified UTF8 item.
*/
public String readUTF8(int index, final char[] buf){
int item = readUnsignedShort(index);
String s = strings[item];
if(s != null)
{
return s;
}
index = items[item];
return strings[item] =
readUTF(index + 2, readUnsignedShort(index), buf);
}

/**
* Reads UTF8 string in {@link #b b}.
*
* @param index start offset of the UTF8 string to be read.
* @param utfLen length of the UTF8 string to be read.
* @param buf buffer to be used to read the string. This buffer must
* be sufficiently large. It is not automatically resized.
* @return the String corresponding to the specified UTF8 string.
*/
private String readUTF(int index, final int utfLen, final char[] buf){
int endIndex = index + utfLen;
byte[] b = this.b;
int strLen = 0;
int c, d, e;
while(index < endIndex)
{
c = b[index++] & 0xFF;
switch(c >> 4)
{
case 0:
108 CHAPTER 6. JVM/CLOJURE/ASM/

case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
// 0xxxxxxx
buf[strLen++] = (char) c;
break;
case 12:
case 13:
// 110x xxxx 10xx xxxx
d = b[index++];
buf[strLen++] = (char) (((c & 0x1F) << 6) | (d & 0x3F));
break;
default:
// 1110 xxxx 10xx xxxx 10xx xxxx
d = b[index++];
e = b[index++];
buf[strLen++] =
(char) (((c & 0x0F) << 12)
| ((d & 0x3F) << 6) | (e & 0x3F));
break;
}
}
return new String(buf, 0, strLen);
}

/**
* Reads a class constant pool item in {@link #b b}. This method
* is intended for {@link Attribute} sub classes, and is normally not
* needed by class generators or adapters.
*
* @param index the start index of an unsigned short value in
* {@link #b b}, whose value is the index of a class
* constant pool item.
* @param buf buffer to be used to read the item. This buffer must be
* sufficiently large. It is not automatically resized.
* @return the String corresponding to the specified class item.
*/
public String readClass(final int index, final char[] buf){
// computes the start index of the CONSTANT_Class item in b
// and reads the CONSTANT_Utf8 item designated by
// the first two bytes of this CONSTANT_Class item
return readUTF8(items[readUnsignedShort(index)], buf);
}

/**
* Reads a numeric or string constant pool item in {@link #b b}.
6.7. CLASSVISITOR.JAVA 109

* This method is intended for {@link Attribute} sub classes,

* and is normally not needed by class generators or adapters.
*
* @param item the index of a constant pool item.
* @param buf buffer to be used to read the item. This buffer must be
* sufficiently large. It is not automatically resized.
* @return the {@link Integer}, {@link Float}, {@link Long},
* {@link Double}, {@link String} or {@link Type} corresponding
* to the given constant pool item.
*/
public Object readConst(final int item, final char[] buf){
int index = items[item];
switch(b[index - 1])
{
case ClassWriter.INT:
return new Integer(readInt(index));
case ClassWriter.FLOAT:
return new Float(Float.intBitsToFloat(readInt(index)));
case ClassWriter.LONG:
return new Long(readLong(index));
case ClassWriter.DOUBLE:
return new Double(Double.longBitsToDouble(readLong(index)));
case ClassWriter.CLASS:
String s = readUTF8(index, buf);
return s.charAt(0) == ’[’
? Type.getType(s)
: Type.getObjectType(s);
// case ClassWriter.STR:
default:
return readUTF8(index, buf);
}
}
}

———-

6.7 ClassVisitor.java

— ClassVisitorjava —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* A visitor to visit a Java class. The methods of this interface
* must be called in the following order: <tt>visit</tt>
* [ <tt>visitSource</tt> ] [ <tt>visitOuterClass</tt> ]
110 CHAPTER 6. JVM/CLOJURE/ASM/

* ( <tt>visitAnnotation</tt> | <tt>visitAttribute</tt> )*
* (<tt>visitInnerClass</tt> | <tt>visitField</tt> |
* <tt>visitMethod</tt> )* <tt>visitEnd</tt>.
*
* @author Eric Bruneton
*/
public interface ClassVisitor{

/**
* Visits the header of the class.
*
* @param version the class version.
* @param access the class’s access flags (see {@link Opcodes}). This
* parameter also indicates if the class is deprecated.
* @param name the internal name of the class (see
* {@link Type#getInternalName() getInternalName}).
* @param signature the signature of this class. May be <tt>null</tt> if
* the class is not a generic one, and does not extend
* or implement generic classes or interfaces.
* @param superName the internal of name of the super class (see
* {@link Type#getInternalName() getInternalName}).
* For interfaces, the super class is {@link Object}.
* May be <tt>null</tt>, but only for the
* {@link Object} class.
* @param interfaces the internal names of the class’s interfaces (see
* {@link Type#getInternalName() getInternalName}).
* May be <tt>null</tt>.
*/
void visit(
int version,
int access,
String name,
String signature,
String superName,
String[] interfaces);

/**
* Visits the source of the class.
*
* @param source the name of the source file from which the class was
* compiled. May be <tt>null</tt>.
* @param debug additional debug information to compute the
* correspondance between source and compiled elements of
* the class. May be <tt>null</tt>.
*/
void visitSource(String source, String debug);

/**
* Visits the enclosing class of the class. This method must be called
* only if the class has an enclosing class.
6.7. CLASSVISITOR.JAVA 111

*
* @param owner internal name of the enclosing class of the class.
* @param name the name of the method that contains the class, or
* <tt>null</tt> if the class is not enclosed in a method
* of its enclosing class.
* @param desc the descriptor of the method that contains the class, or
* <tt>null</tt> if the class is not enclosed in a method of
* its enclosing class.
*/
void visitOuterClass(String owner, String name, String desc);

/**
* Visits an annotation of the class.
*
* @param desc the class descriptor of the annotation class.
* @param visible <tt>true</tt> if the annotation is visible at runtime.
* @return a visitor to visit the annotation values, or <tt>null</tt> if
* this visitor is not interested in visiting this annotation.
*/
AnnotationVisitor visitAnnotation(String desc, boolean visible);

/**
* Visits a non standard attribute of the class.
*
* @param attr an attribute.
*/
void visitAttribute(Attribute attr);

/**
* Visits information about an inner class. This inner class is not
* necessarily a member of the class being visited.
*
* @param name the internal name of an inner class (see
* {@link Type#getInternalName() getInternalName}).
* @param outerName the internal name of the class to which the inner
* class belongs (see {@link Type#getInternalName()
* getInternalName}). May be <tt>null</tt> for not
* member classes.
* @param innerName the (simple) name of the inner class inside its
* enclosing class. May be <tt>null</tt> for anonymous
* inner classes.
* @param access the access flags of the inner class as originally
* declared in the enclosing class.
*/
void visitInnerClass(
String name,
String outerName,
String innerName,
int access);
112 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Visits a field of the class.
*
* @param access the field’s access flags (see {@link Opcodes}).
* This parameter also indicates if the field is
* synthetic and/or deprecated.
* @param name the field’s name.
* @param desc the field’s descriptor (see {@link Type Type}).
* @param signature the field’s signature. May be <tt>null</tt> if the
* field’s type does not use generic types.
* @param value the field’s initial value. This parameter, which may
* be <tt>null</tt> if the field does not have an
* initial value, must be an {@link Integer}, a
* {@link Float}, a {@link Long}, a {@link Double} or
* a {@link String} (for <tt>int</tt>, <tt>float</tt>,
* <tt>long</tt> or <tt>String</tt> fields
* respectively). This parameter is only used for
* static fields. Its value is ignored for non
* static fields, which must be initialized through
* bytecode instructions in constructors or methods.
* @return a visitor to visit field annotations and attributes, or
* <tt>null</tt> if this class visitor is not interested in
* visiting these annotations and attributes.
*/
FieldVisitor visitField(
int access,
String name,
String desc,
String signature,
Object value);

/**
* Visits a method of the class. This method must return a new
* {@link MethodVisitor} instance (or <tt>null</tt>) each time it is
* called, i.e., it should not return a previously returned visitor.
*
* @param access the method’s access flags (see {@link Opcodes}).
* This parameter also indicates if the method is
* synthetic and/or deprecated.
* @param name the method’s name.
* @param desc the method’s descriptor (see {@link Type Type}).
* @param signature the method’s signature. May be <tt>null</tt> if the
* method parameters, return type and exceptions do not
* use generic types.
* @param exceptions the internal names of the method’s exception classes
* (see
* {@link Type#getInternalName() getInternalName}).
* May be <tt>null</tt>.
* @return an object to visit the byte code of the method, or
* <tt>null</tt> if this class visitor is not interested in
6.8. CLASSWRITER.JAVA 113

* visiting the code of this method.

*/
MethodVisitor visitMethod(
int access,
String name,
String desc,
String signature,
String[] exceptions);

/**
* Visits the end of the class. This method, which is the last one to be
* called, is used to inform the visitor that all the fields and methods
* of the class have been visited.
*/
void visitEnd();
}

———-

6.8 ClassWriter.java

— ClassWriter.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* A {@link ClassVisitor} that generates classes in bytecode form.
* More precisely this visitor generates a byte array conforming to
* the Java class file format. It can be used alone, to generate a
* Java class "from scratch", or with one or more
* {@link ClassReader ClassReader} and adapter class visitor
* to generate a modified class from one or more existing Java classes.
*
* @author Eric Bruneton
*/
public class ClassWriter implements ClassVisitor{

/**
* Flag to automatically compute the maximum stack size and the
* maximum number of local variables of methods. If this flag is set,
* then the arguments of the {@link MethodVisitor#visitMaxs visitMaxs}
* method of the {@link MethodVisitor} returned by the
* {@link #visitMethod visitMethod} method will be ignored, and
* computed automatically from the signature and the bytecode of
* each method.
*
114 CHAPTER 6. JVM/CLOJURE/ASM/

* @see #ClassWriter(int)
*/
public final static int COMPUTE_MAXS = 1;

/**
* Flag to automatically compute the stack map frames of methods from
* scratch. If this flag is set, then the calls to the
* {@link MethodVisitor#visitFrame} method are ignored, and the stack map
* frames are recomputed from the methods bytecode. The arguments of the
* {@link MethodVisitor#visitMaxs visitMaxs} method are also ignored and
* recomputed from the bytecode. In other words, computeFrames implies
* computeMaxs.
*
* @see #ClassWriter(int)
*/
public final static int COMPUTE_FRAMES = 2;

/**
* The type of instructions without any argument.
*/
final static int NOARG_INSN = 0;

/**
* The type of instructions with an signed byte argument.
*/
final static int SBYTE_INSN = 1;

/**
* The type of instructions with an signed short argument.
*/
final static int SHORT_INSN = 2;

/**
* The type of instructions with a local variable index argument.
*/
final static int VAR_INSN = 3;

/**
* The type of instructions with an implicit local variable index
* argument.
*/
final static int IMPLVAR_INSN = 4;

/**
* The type of instructions with a type descriptor argument.
*/
final static int TYPE_INSN = 5;

/**
* The type of field and method invocations instructions.
6.8. CLASSWRITER.JAVA 115

*/
final static int FIELDORMETH_INSN = 6;

/**
* The type of the INVOKEINTERFACE instruction.
*/
final static int ITFMETH_INSN = 7;

/**
* The type of instructions with a 2 bytes bytecode offset label.
*/
final static int LABEL_INSN = 8;

/**
* The type of instructions with a 4 bytes bytecode offset label.
*/
final static int LABELW_INSN = 9;

/**
* The type of the LDC instruction.
*/
final static int LDC_INSN = 10;

/**
* The type of the LDC_W and LDC2_W instructions.
*/
final static int LDCW_INSN = 11;

/**
* The type of the IINC instruction.
*/
final static int IINC_INSN = 12;

/**
* The type of the TABLESWITCH instruction.
*/
final static int TABL_INSN = 13;

/**
* The type of the LOOKUPSWITCH instruction.
*/
final static int LOOK_INSN = 14;

/**
* The type of the MULTIANEWARRAY instruction.
*/
final static int MANA_INSN = 15;

/**
* The type of the WIDE instruction.
116 CHAPTER 6. JVM/CLOJURE/ASM/

*/
final static int WIDE_INSN = 16;

/**
* The instruction types of all JVM opcodes.
*/
static byte[] TYPE;

/**
* The type of CONSTANT_Class constant pool items.
*/
final static int CLASS = 7;

/**
* The type of CONSTANT_Fieldref constant pool items.
*/
final static int FIELD = 9;

/**
* The type of CONSTANT_Methodref constant pool items.
*/
final static int METH = 10;

/**
* The type of CONSTANT_InterfaceMethodref constant pool items.
*/
final static int IMETH = 11;

/**
* The type of CONSTANT_String constant pool items.
*/
final static int STR = 8;

/**
* The type of CONSTANT_Integer constant pool items.
*/
final static int INT = 3;

/**
* The type of CONSTANT_Float constant pool items.
*/
final static int FLOAT = 4;

/**
* The type of CONSTANT_Long constant pool items.
*/
final static int LONG = 5;

/**
* The type of CONSTANT_Double constant pool items.
6.8. CLASSWRITER.JAVA 117

*/
final static int DOUBLE = 6;

/**
* The type of CONSTANT_NameAndType constant pool items.
*/
final static int NAME_TYPE = 12;

/**
* The type of CONSTANT_Utf8 constant pool items.
*/
final static int UTF8 = 1;

/**
* Normal type Item stored in the ClassWriter
* {@link ClassWriter#typeTable}, instead of the constant pool,
* in order to avoid clashes with normal constant pool items in
* the ClassWriter constant pool’s hash table.
*/
final static int TYPE_NORMAL = 13;

/**
* Uninitialized type Item stored in the ClassWriter
* {@link ClassWriter#typeTable}, instead of the constant pool, in
* order to avoid clashes with normal constant pool items in the
* ClassWriter constant pool’s hash table.
*/
final static int TYPE_UNINIT = 14;

/**
* Merged type Item stored in the ClassWriter
* {@link ClassWriter#typeTable}, instead of the constant pool, in
* order to avoid clashes with normal constant pool items in the
* ClassWriter constant pool’s hash table.
*/
final static int TYPE_MERGED = 15;

/**
* The class reader from which this class writer was constructed, if any.
*/
ClassReader cr;

/**
* Minor and major version numbers of the class to be generated.
*/
int version;

/**
* Index of the next item to be added in the constant pool.
*/
118 CHAPTER 6. JVM/CLOJURE/ASM/

int index;

/**
* The constant pool of this class.
*/
ByteVector pool;

/**
* The constant pool’s hash table data.
*/
Item[] items;

/**
* The threshold of the constant pool’s hash table.
*/
int threshold;

/**
* A reusable key used to look for items in the {@link #items} hash
* table.
*/
Item key;

/**
* A reusable key used to look for items in the {@link #items} hash
* table.
*/
Item key2;

/**
* A reusable key used to look for items in the {@link #items} hash
* table.
*/
Item key3;

/**
* A type table used to temporarily store internal names that will
* not necessarily be stored in the constant pool. This type table
* is used by the control flow and data flow analysis algorithm
* used to compute stack map frames from scratch. This array
* associates to each index <tt>i</tt> the Item whose index is
* <tt>i</tt>. All Item objects stored in this array are also stored
* in the {@link #items} hash table. These two arrays allow to retrieve
* an Item from its index or, conversly, to get the index of an Item
* from its value. Each Item stores an internal name in its
* {@link Item#strVal1} field.
*/
Item[] typeTable;

/**
6.8. CLASSWRITER.JAVA 119

* Number of elements in the {@link #typeTable} array.

*/
private short typeCount; // TODO int?

/**
* The access flags of this class.
*/
private int access;

/**
* The constant pool item that contains the internal name of this
* class.
*/
private int name;

/**
* The internal name of this class.
*/
String thisName;

/**
* The constant pool item that contains the signature of this class.
*/
private int signature;

/**
* The constant pool item that contains the internal name of the super
* class of this class.
*/
private int superName;

/**
* Number of interfaces implemented or extended by this class or
* interface.
*/
private int interfaceCount;

/**
* The interfaces implemented or extended by this class or interface.
* More precisely, this array contains the indexes of the constant
* pool items that contain the internal names of these interfaces.
*/
private int[] interfaces;

/**
* The index of the constant pool item that contains the name of the
* source file from which this class was compiled.
*/
private int sourceFile;
120 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* The SourceDebug attribute of this class.
*/
private ByteVector sourceDebug;

/**
* The constant pool item that contains the name of the enclosing class
* of this class.
*/
private int enclosingMethodOwner;

/**
* The constant pool item that contains the name and descriptor of the
* enclosing method of this class.
*/
private int enclosingMethod;

/**
* The runtime visible annotations of this class.
*/
private AnnotationWriter anns;

/**
* The runtime invisible annotations of this class.
*/
private AnnotationWriter ianns;

/**
* The non standard attributes of this class.
*/
private Attribute attrs;

/**
* The number of entries in the InnerClasses attribute.
*/
private int innerClassesCount;

/**
* The InnerClasses attribute.
*/
private ByteVector innerClasses;

/**
* The fields of this class. These fields are stored in a linked list
* of {@link FieldWriter} objects, linked to each other by their
* {@link FieldWriter#next} field. This field stores the first element
* of this list.
*/
FieldWriter firstField;
6.8. CLASSWRITER.JAVA 121

/**
* The fields of this class. These fields are stored in a linked list
* of {@link FieldWriter} objects, linked to each other by their
* {@link FieldWriter#next} field. This field stores the last element
* of this list.
*/
FieldWriter lastField;

/**
* The methods of this class. These methods are stored in a linked list
* of {@link MethodWriter} objects, linked to each other by their
* {@link MethodWriter#next} field. This field stores the first element
* of this list.
*/
MethodWriter firstMethod;

/**
* The methods of this class. These methods are stored in a linked list
* of {@link MethodWriter} objects, linked to each other by their
* {@link MethodWriter#next} field. This field stores the last element
* of this list.
*/
MethodWriter lastMethod;

/**
* <tt>true</tt> if the maximum stack size and number of local variables
* must be automatically computed.
*/
private boolean computeMaxs;

/**
* <tt>true</tt> if the stack map frames must be recomputed from scratch.
*/
private boolean computeFrames;

/**
* <tt>true</tt> if the stack map tables of this class are invalid. The
* {@link MethodWriter#resizeInstructions} method cannot transform
* existing stack map tables, and so produces potentially invalid
* classes when it is executed. In this case the class is reread
* and rewritten with the {@link #COMPUTE_FRAMES} option (the
* resizeInstructions method can resize stack map tables when this
* option is used).
*/
boolean invalidFrames;

// -------------------------------------------------------------------
// Static initializer
// -------------------------------------------------------------------
122 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Computes the instruction types of JVM opcodes.
*/
static
{
int i;
byte[] b = new byte[220];
String s =
"AAAAAAAAAAAAAAAABCKLLDDDDDEEEEEEEEEEEEEEEEEEEEAAAAAAAADD"
+ "DDDEEEEEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ "AAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAIIIIIIIIIIIIIIIIDNOAA"
+ "AAAAGGGGGGGHAFBFAAFFAAQPIIJJIIIIIIIIIIIIIIIIII";
for(i = 0; i < b.length; ++i)
{
b[i] = (byte) (s.charAt(i) - ’A’);
}
TYPE = b;

// code to generate the above string

//
// // SBYTE_INSN instructions
// b[Constants.NEWARRAY] = SBYTE_INSN;
// b[Constants.BIPUSH] = SBYTE_INSN;
//
// // SHORT_INSN instructions
// b[Constants.SIPUSH] = SHORT_INSN;
//
// // (IMPL)VAR_INSN instructions
// b[Constants.RET] = VAR_INSN;
// for (i = Constants.ILOAD; i <= Constants.ALOAD; ++i) {
// b[i] = VAR_INSN;
// }
// for (i = Constants.ISTORE; i <= Constants.ASTORE; ++i) {
// b[i] = VAR_INSN;
// }
// for (i = 26; i <= 45; ++i) { // ILOAD_0 to ALOAD_3
// b[i] = IMPLVAR_INSN;
// }
// for (i = 59; i <= 78; ++i) { // ISTORE_0 to ASTORE_3
// b[i] = IMPLVAR_INSN;
// }
//
// // TYPE_INSN instructions
// b[Constants.NEW] = TYPE_INSN;
// b[Constants.ANEWARRAY] = TYPE_INSN;
// b[Constants.CHECKCAST] = TYPE_INSN;
// b[Constants.INSTANCEOF] = TYPE_INSN;
//
// // (Set)FIELDORMETH_INSN instructions
// for (i = Constants.GETSTATIC; i <= Constants.INVOKESTATIC; ++i) {
6.8. CLASSWRITER.JAVA 123

// b[i] = FIELDORMETH_INSN;
// }
// b[Constants.INVOKEINTERFACE] = ITFMETH_INSN;
//
// // LABEL(W)_INSN instructions
// for (i = Constants.IFEQ; i <= Constants.JSR; ++i) {
// b[i] = LABEL_INSN;
// }
// b[Constants.IFNULL] = LABEL_INSN;
// b[Constants.IFNONNULL] = LABEL_INSN;
// b[200] = LABELW_INSN; // GOTO_W
// b[201] = LABELW_INSN; // JSR_W
// // temporary opcodes used internally by ASM - see Label and
// MethodWriter
// for (i = 202; i < 220; ++i) {
// b[i] = LABEL_INSN;
// }
//
// // LDC(_W) instructions
// b[Constants.LDC] = LDC_INSN;
// b[19] = LDCW_INSN; // LDC_W
// b[20] = LDCW_INSN; // LDC2_W
//
// // special instructions
// b[Constants.IINC] = IINC_INSN;
// b[Constants.TABLESWITCH] = TABL_INSN;
// b[Constants.LOOKUPSWITCH] = LOOK_INSN;
// b[Constants.MULTIANEWARRAY] = MANA_INSN;
// b[196] = WIDE_INSN; // WIDE
//
// for (i = 0; i < b.length; ++i) {
// System.err.print((char)(’A’ + b[i]));
// }
// System.err.println();
}

// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------

/**
* Constructs a new {@link ClassWriter} object.
*
* @param flags option flags that can be used to modify the default
* behavior of this class. See {@link #COMPUTE_MAXS},
* {@link #COMPUTE_FRAMES}.
*/
public ClassWriter(final int flags){
index = 1;
pool = new ByteVector();
124 CHAPTER 6. JVM/CLOJURE/ASM/

items = new Item[256];

threshold = (int) (0.75d * items.length);
key = new Item();
key2 = new Item();
key3 = new Item();
this.computeMaxs = (flags & COMPUTE_MAXS) != 0;
this.computeFrames = (flags & COMPUTE_FRAMES) != 0;
}

/**
* Constructs a new {@link ClassWriter} object and enables optimizations
* for "mostly add" bytecode transformations. These optimizations are
* the following:
* 
* <ul> <li>The constant pool from the original class is copied as is
* in the new class, which saves time. New constant pool entries will
* be added at the end if necessary, but unused constant pool entries
* won’t be removed.</li> <li>Methods that are not transformed
* are copied as is in the new class, directly from the original class
* bytecode (i.e. without emitting visit events for all the method
* instructions), which saves a lot of time. Untransformed
* methods are detected by the fact that the {@link ClassReader}
* receives {@link MethodVisitor} objects that come from a
* {@link ClassWriter} (and not from a custom {@link ClassAdapter}
* or any other {@link ClassVisitor} instance).</li> </ul>
*
* @param classReader the {@link ClassReader} used to read the original
* class. It will be used to copy the entire
* constant pool from the original class and also
* to copy other fragments of original bytecode
* where applicable.
* @param flags option flags that can be used to modify the
* default behavior of this class. See
* {@link #COMPUTE_MAXS}, {@link #COMPUTE_FRAMES}.
*/
public ClassWriter(final ClassReader classReader, final int flags){
this(flags);
classReader.copyPool(this);
this.cr = classReader;
}

// -------------------------------------------------------------------
// Implementation of the ClassVisitor interface
// -------------------------------------------------------------------

public void visit(

final int version,
final int access,
final String name,
final String signature,
6.8. CLASSWRITER.JAVA 125

final String superName,

final String[] interfaces){
this.version = version;
this.access = access;
this.name = newClass(name);
thisName = name;
if(signature != null)
{
this.signature = newUTF8(signature);
}
this.superName = superName == null ? 0 : newClass(superName);
if(interfaces != null && interfaces.length > 0)
{
interfaceCount = interfaces.length;
this.interfaces = new int[interfaceCount];
for(int i = 0; i < interfaceCount; ++i)
{
this.interfaces[i] = newClass(interfaces[i]);
}
}
}

public void visitSource(final String file, final String debug){

if(file != null)
{
sourceFile = newUTF8(file);
}
if(debug != null)
{
sourceDebug = new ByteVector().putUTF8(debug);
}
}

public void visitOuterClass(

final String owner,
final String name,
final String desc){
enclosingMethodOwner = newClass(owner);
if(name != null && desc != null)
{
enclosingMethod = newNameType(name, desc);
}
}

public AnnotationVisitor visitAnnotation(

final String desc,
final boolean visible){
ByteVector bv = new ByteVector();
// write type, and reserve space for values count
bv.putShort(newUTF8(desc)).putShort(0);
126 CHAPTER 6. JVM/CLOJURE/ASM/

AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv, 2);

if(visible)
{
aw.next = anns;
anns = aw;
}
else
{
aw.next = ianns;
ianns = aw;
}
return aw;
}

public void visitAttribute(final Attribute attr){

attr.next = attrs;
attrs = attr;
}

public void visitInnerClass(

final String name,
final String outerName,
final String innerName,
final int access){
if(innerClasses == null)
{
innerClasses = new ByteVector();
}
++innerClassesCount;
innerClasses.putShort(name == null ? 0 : newClass(name));
innerClasses.putShort(outerName == null ? 0 : newClass(outerName));
innerClasses.putShort(innerName == null ? 0 : newUTF8(innerName));
innerClasses.putShort(access);
}

public FieldVisitor visitField(

final int access,
final String name,
final String desc,
final String signature,
final Object value){
return new FieldWriter(this, access, name, desc, signature, value);
}

public MethodVisitor visitMethod(

final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions){
6.8. CLASSWRITER.JAVA 127

return new MethodWriter(this,

access,
name,
desc,
signature,
exceptions,
computeMaxs,
computeFrames);
}

public void visitEnd(){

}

// -------------------------------------------------------------------
// Other public methods
// -------------------------------------------------------------------

/**
* Returns the bytecode of the class that was build with this class
* writer.
*
* @return the bytecode of the class that was build with this class
* writer.
*/
public byte[] toByteArray(){
// computes the real size of the bytecode of this class
int size = 24 + 2 * interfaceCount;
int nbFields = 0;
FieldWriter fb = firstField;
while(fb != null)
{
++nbFields;
size += fb.getSize();
fb = fb.next;
}
int nbMethods = 0;
MethodWriter mb = firstMethod;
while(mb != null)
{
++nbMethods;
size += mb.getSize();
mb = mb.next;
}
int attributeCount = 0;
if(signature != 0)
{
++attributeCount;
size += 8;
newUTF8("Signature");
}
128 CHAPTER 6. JVM/CLOJURE/ASM/

if(sourceFile != 0)
{
++attributeCount;
size += 8;
newUTF8("SourceFile");
}
if(sourceDebug != null)
{
++attributeCount;
size += sourceDebug.length + 4;
newUTF8("SourceDebugExtension");
}
if(enclosingMethodOwner != 0)
{
++attributeCount;
size += 10;
newUTF8("EnclosingMethod");
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
++attributeCount;
size += 6;
newUTF8("Deprecated");
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (version & 0xffff) < Opcodes.V1_5)
{
++attributeCount;
size += 6;
newUTF8("Synthetic");
}
if(innerClasses != null)
{
++attributeCount;
size += 8 + innerClasses.length;
newUTF8("InnerClasses");
}
if(anns != null)
{
++attributeCount;
size += 8 + anns.getSize();
newUTF8("RuntimeVisibleAnnotations");
}
if(ianns != null)
{
++attributeCount;
size += 8 + ianns.getSize();
newUTF8("RuntimeInvisibleAnnotations");
}
if(attrs != null)
6.8. CLASSWRITER.JAVA 129

{
attributeCount += attrs.getCount();
size += attrs.getSize(this, null, 0, -1, -1);
}
size += pool.length;
// allocates a byte vector of this size, in order to
// avoid unnecessary arraycopy operations in the
// ByteVector.enlarge() method
ByteVector out = new ByteVector(size);
out.putInt(0xCAFEBABE).putInt(version);
out.putShort(index).putByteArray(pool.data, 0, pool.length);
out.putShort(access).putShort(name).putShort(superName);
out.putShort(interfaceCount);
for(int i = 0; i < interfaceCount; ++i)
{
out.putShort(interfaces[i]);
}
out.putShort(nbFields);
fb = firstField;
while(fb != null)
{
fb.put(out);
fb = fb.next;
}
out.putShort(nbMethods);
mb = firstMethod;
while(mb != null)
{
mb.put(out);
mb = mb.next;
}
out.putShort(attributeCount);
if(signature != 0)
{
out.putShort(newUTF8("Signature"))
.putInt(2)
.putShort(signature);
}
if(sourceFile != 0)
{
out.putShort(newUTF8("SourceFile"))
.putInt(2)
.putShort(sourceFile);
}
if(sourceDebug != null)
{
int len = sourceDebug.length - 2;
out.putShort(newUTF8("SourceDebugExtension"))
.putInt(len);
out.putByteArray(sourceDebug.data, 2, len);
130 CHAPTER 6. JVM/CLOJURE/ASM/

}
if(enclosingMethodOwner != 0)
{
out.putShort(newUTF8("EnclosingMethod"))
.putInt(4);
out.putShort(enclosingMethodOwner)
.putShort(enclosingMethod);
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
out.putShort(newUTF8("Deprecated")).putInt(0);
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (version & 0xffff) < Opcodes.V1_5)
{
out.putShort(newUTF8("Synthetic")).putInt(0);
}
if(innerClasses != null)
{
out.putShort(newUTF8("InnerClasses"));
out.putInt(innerClasses.length + 2)
.putShort(innerClassesCount);
out.putByteArray(innerClasses.data,
0,innerClasses.length);
}
if(anns != null)
{
out.putShort(newUTF8("RuntimeVisibleAnnotations"));
anns.put(out);
}
if(ianns != null)
{
out.putShort(newUTF8("RuntimeInvisibleAnnotations"));
ianns.put(out);
}
if(attrs != null)
{
attrs.put(this, null, 0, -1, -1, out);
}
if(invalidFrames)
{
ClassWriter cw = new ClassWriter(COMPUTE_FRAMES);
new ClassReader(out.data).accept(cw, ClassReader.SKIP_FRAMES);
return cw.toByteArray();
}
return out.data;
}

// -------------------------------------------------------------------
// Utility methods: constant pool management
6.8. CLASSWRITER.JAVA 131

// -------------------------------------------------------------------

/**
* Adds a number or string constant to the constant pool of the class
* being build. Does nothing if the constant pool already contains
* a similar item.
*
* @param cst the value of the constant to be added to the constant
* pool. This parameter must be an {@link Integer},
* a {@link Float}, a {@link Long}, a {@link Double},
* a {@link String} or a {@link Type}.
* @return a new or already existing constant item with the given value.
*/
Item newConstItem(final Object cst){
if(cst instanceof Integer)
{
int val = ((Integer) cst).intValue();
return newInteger(val);
}
else if(cst instanceof Byte)
{
int val = ((Byte) cst).intValue();
return newInteger(val);
}
else if(cst instanceof Character)
{
int val = ((Character) cst).charValue();
return newInteger(val);
}
else if(cst instanceof Short)
{
int val = ((Short) cst).intValue();
return newInteger(val);
}
else if(cst instanceof Boolean)
{
int val = ((Boolean) cst).booleanValue() ? 1 : 0;
return newInteger(val);
}
else if(cst instanceof Float)
{
float val = ((Float) cst).floatValue();
return newFloat(val);
}
else if(cst instanceof Long)
{
long val = ((Long) cst).longValue();
return newLong(val);
}
else if(cst instanceof Double)
132 CHAPTER 6. JVM/CLOJURE/ASM/

{
double val = ((Double) cst).doubleValue();
return newDouble(val);
}
else if(cst instanceof String)
{
return newString((String) cst);
}
else if(cst instanceof Type)
{
Type t = (Type) cst;
return newClassItem(t.getSort() == Type.OBJECT
? t.getInternalName()
: t.getDescriptor());
}
else
{
throw new IllegalArgumentException("value " + cst);
}
}

/**
* Adds a number or string constant to the constant pool of the class
* being build. Does nothing if the constant pool already contains a
* similar item. This method is intended for {@link Attribute}
* sub classes, and is normally not needed by class generators or
* adapters.
*
* @param cst the value of the constant to be added to the constant pool.
* This parameter must be an {@link Integer}, a {@link Float},
* a {@link Long}, a {@link Double} or a {@link String}.
* @return the index of a new or already existing constant item with the
* given value.
*/
public int newConst(final Object cst){
return newConstItem(cst).index;
}

/**
* Adds an UTF8 string to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
* This method is intended for {@link Attribute} sub classes, and
* is normally not needed by class generators or adapters.
*
* @param value the String value.
* @return the index of a new or already existing UTF8 item.
*/
public int newUTF8(final String value){
key.set(UTF8, value, null, null);
Item result = get(key);
6.8. CLASSWRITER.JAVA 133

if(result == null)
{
pool.putByte(UTF8).putUTF8(value);
result = new Item(index++, key);
put(result);
}
return result.index;
}

/**
* Adds a class reference to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
* This method is intended for {@link Attribute} sub classes, and is
* normally not needed by class generators or adapters.
*
* @param value the internal name of the class.
* @return a new or already existing class reference item.
*/
Item newClassItem(final String value){
key2.set(CLASS, value, null, null);
Item result = get(key2);
if(result == null)
{
pool.put12(CLASS, newUTF8(value));
result = new Item(index++, key2);
put(result);
}
return result;
}

/**
* Adds a class reference to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
* This method is intended for {@link Attribute} sub classes, and is
* normally not needed by class generators or adapters.
*
* @param value the internal name of the class.
* @return the index of a new or already existing class reference item.
*/
public int newClass(final String value){
return newClassItem(value).index;
}

/**
* Adds a field reference to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
*
* @param owner the internal name of the field’s owner class.
* @param name the field’s name.
* @param desc the field’s descriptor.
134 CHAPTER 6. JVM/CLOJURE/ASM/

* @return a new or already existing field reference item.

*/
Item newFieldItem(final String owner,
final String name,
final String desc){
key3.set(FIELD, owner, name, desc);
Item result = get(key3);
if(result == null)
{
put122(FIELD, newClass(owner), newNameType(name, desc));
result = new Item(index++, key3);
put(result);
}
return result;
}

/**
* Adds a field reference to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
* This method is intended for {@link Attribute} sub classes, and is
* normally not needed by class generators or adapters.
*
* @param owner the internal name of the field’s owner class.
* @param name the field’s name.
* @param desc the field’s descriptor.
* @return the index of a new or already existing field reference item.
*/
public int newField(final String owner,
final String name,
final String desc){
return newFieldItem(owner, name, desc).index;
}

/**
* Adds a method reference to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
*
* @param owner the internal name of the method’s owner class.
* @param name the method’s name.
* @param desc the method’s descriptor.
* @param itf <tt>true</tt> if <tt>owner</tt> is an interface.
* @return a new or already existing method reference item.
*/
Item newMethodItem(
final String owner,
final String name,
final String desc,
final boolean itf){
int type = itf ? IMETH : METH;
key3.set(type, owner, name, desc);
6.8. CLASSWRITER.JAVA 135

Item result = get(key3);

if(result == null)
{
put122(type, newClass(owner), newNameType(name, desc));
result = new Item(index++, key3);
put(result);
}
return result;
}

/**
* Adds a method reference to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
* This method is intended for {@link Attribute} sub classes, and is
* normally not needed by class generators or adapters.
*
* @param owner the internal name of the method’s owner class.
* @param name the method’s name.
* @param desc the method’s descriptor.
* @param itf <tt>true</tt> if <tt>owner</tt> is an interface.
* @return the index of a new or already existing method reference item.
*/
public int newMethod(
final String owner,
final String name,
final String desc,
final boolean itf){
return newMethodItem(owner, name, desc, itf).index;
}

/**
* Adds an integer to the constant pool of the class being build. Does
* nothing if the constant pool already contains a similar item.
*
* @param value the int value.
* @return a new or already existing int item.
*/
Item newInteger(final int value){
key.set(value);
Item result = get(key);
if(result == null)
{
pool.putByte(INT).putInt(value);
result = new Item(index++, key);
put(result);
}
return result;
}

/**
136 CHAPTER 6. JVM/CLOJURE/ASM/

* Adds a float to the constant pool of the class being build. Does
* nothing if the constant pool already contains a similar item.
*
* @param value the float value.
* @return a new or already existing float item.
*/
Item newFloat(final float value){
key.set(value);
Item result = get(key);
if(result == null)
{
pool.putByte(FLOAT).putInt(key.intVal);
result = new Item(index++, key);
put(result);
}
return result;
}

/**
* Adds a long to the constant pool of the class being build. Does
* nothing if the constant pool already contains a similar item.
*
* @param value the long value.
* @return a new or already existing long item.
*/
Item newLong(final long value){
key.set(value);
Item result = get(key);
if(result == null)
{
pool.putByte(LONG).putLong(value);
result = new Item(index, key);
put(result);
index += 2;
}
return result;
}

/**
* Adds a double to the constant pool of the class being build. Does
* nothing if the constant pool already contains a similar item.
*
* @param value the double value.
* @return a new or already existing double item.
*/
Item newDouble(final double value){
key.set(value);
Item result = get(key);
if(result == null)
{
6.8. CLASSWRITER.JAVA 137

pool.putByte(DOUBLE).putLong(key.longVal);
result = new Item(index, key);
put(result);
index += 2;
}
return result;
}

/**
* Adds a string to the constant pool of the class being build. Does
* nothing if the constant pool already contains a similar item.
*
* @param value the String value.
* @return a new or already existing string item.
*/
private Item newString(final String value){
key2.set(STR, value, null, null);
Item result = get(key2);
if(result == null)
{
pool.put12(STR, newUTF8(value));
result = new Item(index++, key2);
put(result);
}
return result;
}

/**
* Adds a name and type to the constant pool of the class being build.
* Does nothing if the constant pool already contains a similar item.
* This method is intended for {@link Attribute} sub classes, and
* is normally not needed by class generators or adapters.
*
* @param name a name.
* @param desc a type descriptor.
* @return the index of a new or already existing name and type item.
*/
public int newNameType(final String name, final String desc){
key2.set(NAME_TYPE, name, desc, null);
Item result = get(key2);
if(result == null)
{
put122(NAME_TYPE, newUTF8(name), newUTF8(desc));
result = new Item(index++, key2);
put(result);
}
return result.index;
}

/**
138 CHAPTER 6. JVM/CLOJURE/ASM/

* Adds the given internal name to {@link #typeTable} and returns its
* index. Does nothing if the type table already contains this internal
* name.
*
* @param type the internal name to be added to the type table.
* @return the index of this internal name in the type table.
*/
int addType(final String type){
key.set(TYPE_NORMAL, type, null, null);
Item result = get(key);
if(result == null)
{
result = addType(key);
}
return result.index;
}

/**
* Adds the given "uninitialized" type to {@link #typeTable} and returns
* its index. This method is used for UNINITIALIZED types, made of an
* internal name and a bytecode offset.
*
* @param type the internal name to be added to the type table.
* @param offset the bytecode offset of the NEW instruction that created
* this UNINITIALIZED type value.
* @return the index of this internal name in the type table.
*/
int addUninitializedType(final String type, final int offset){
key.type = TYPE_UNINIT;
key.intVal = offset;
key.strVal1 = type;
key.hashCode =
0x7FFFFFFF & (TYPE_UNINIT + type.hashCode() + offset);
Item result = get(key);
if(result == null)
{
result = addType(key);
}
return result.index;
}

/**
* Adds the given Item to {@link #typeTable}.
*
* @param item the value to be added to the type table.
* @return the added Item, which a new Item instance with the same
* value as the given Item.
*/
private Item addType(final Item item){
++typeCount;
6.8. CLASSWRITER.JAVA 139

Item result = new Item(typeCount, key);

put(result);
if(typeTable == null)
{
typeTable = new Item[16];
}
if(typeCount == typeTable.length)
{
Item[] newTable = new Item[2 * typeTable.length];
System.arraycopy(typeTable, 0,
newTable, 0, typeTable.length);
typeTable = newTable;
}
typeTable[typeCount] = result;
return result;
}

/**
* Returns the index of the common super type of the two given types.
* This method calls {@link #getCommonSuperClass} and caches the result
* in the {@link #items} hash table to speedup future calls with the
* same parameters.
*
* @param type1 index of an internal name in {@link #typeTable}.
* @param type2 index of an internal name in {@link #typeTable}.
* @return the index of the common super type of the two given types.
*/
int getMergedType(final int type1, final int type2){
key2.type = TYPE_MERGED;
key2.longVal = type1 | (((long) type2) << 32);
key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
Item result = get(key2);
if(result == null)
{
String t = typeTable[type1].strVal1;
String u = typeTable[type2].strVal1;
key2.intVal = addType(getCommonSuperClass(t, u));
result = new Item((short) 0, key2);
put(result);
}
return result.intVal;
}

/**
* Returns the common super type of the two given types. The default
* implementation of this method loads the two given classes
* and uses the java.lang.Class methods to find the common super class.
* It can be overriden to compute this common super type in other ways,
* in particular without actually loading any class, or to take into
* account the class that is currently being generated by this
140 CHAPTER 6. JVM/CLOJURE/ASM/

* ClassWriter, which can of course not be loaded since it is under

* construction.
*
* @param type1 the internal name of a class.
* @param type2 the internal name of another class.
* @return the internal name of the common super class of the two given
* classes.
*/
protected String getCommonSuperClass(final String type1,
final String type2){
Class c, d;
try
{
c = Class.forName(type1.replace(’/’, ’.’));
d = Class.forName(type2.replace(’/’, ’.’));
}
catch(ClassNotFoundException e)
{
throw new RuntimeException(e);
}
if(c.isAssignableFrom(d))
{
return type1;
}
if(d.isAssignableFrom(c))
{
return type2;
}
if(c.isInterface() || d.isInterface())
{
return "java/lang/Object";
}
else
{
do
{
c = c.getSuperclass();
} while(!c.isAssignableFrom(d));
return c.getName().replace(’.’, ’/’);
}
}

/**
* Returns the constant pool’s hash table item which is equal to the
* given item.
*
* @param key a constant pool item.
* @return the constant pool’s hash table item which is equal to the
* given item, or <tt>null</tt> if there is no such item.
*/
6.8. CLASSWRITER.JAVA 141

private Item get(final Item key){

Item i = items[key.hashCode % items.length];
while(i != null && !key.isEqualTo(i))
{
i = i.next;
}
return i;
}

/**
* Puts the given item in the constant pool’s hash table. The hash
* table must not already contains this item.
*
* @param i the item to be added to the constant pool’s hash table.
*/
private void put(final Item i){
if(index > threshold)
{
int ll = items.length;
int nl = ll * 2 + 1;
Item[] newItems = new Item[nl];
for(int l = ll - 1; l >= 0; --l)
{
Item j = items[l];
while(j != null)
{
int index = j.hashCode % newItems.length;
Item k = j.next;
j.next = newItems[index];
newItems[index] = j;
j = k;
}
}
items = newItems;
threshold = (int) (nl * 0.75);
}
int index = i.hashCode % items.length;
i.next = items[index];
items[index] = i;
}

/**
* Puts one byte and two shorts into the constant pool.
*
* @param b a byte.
* @param s1 a short.
* @param s2 another short.
*/
private void put122(final int b, final int s1, final int s2){
pool.put12(b, s1).putShort(s2);
142 CHAPTER 6. JVM/CLOJURE/ASM/

}
}

———-

6.9 Edge.java

— Edge.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* An edge in the control flow graph of a method body. See
* {@link Label Label}.
*
* @author Eric Bruneton
*/
class Edge{

/**
* Denotes a normal control flow graph edge.
*/
final static int NORMAL = 0;

/**
* Denotes a control flow graph edge corresponding to an exception
* handler. More precisely any {@link Edge} whose {@link #info} is
* strictly positive corresponds to an exception handler. The actual
* value of {@link #info} is the index, in the {@link ClassWriter}
* type table, of the exception that is catched.
*/
final static int EXCEPTION = 0x7FFFFFFF;

/**
* Information about this control flow graph edge. If
* {@link ClassWriter#COMPUTE_MAXS} is used this field is the
* (relative) stack size in the basic block from which this edge
* originates. This size is equal to the stack size at the "jump"
* instruction to which this edge corresponds, relatively to the
* stack size at the beginning of the originating basic block.
* If {@link ClassWriter#COMPUTE_FRAMES} is used, this field is
* the kind of this control flow graph edge (i.e. NORMAL or EXCEPTION).
*/
int info;

/**
6.10. FIELDVISITOR.JAVA 143

* The successor block of the basic block from which this edge
* originates.
*/
Label successor;

/**
* The next edge in the list of successors of the originating basic
* block. See {@link Label#successors successors}.
*/
Edge next;
}

———-

6.10 FieldVisitor.java

— FieldVisitor.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* A visitor to visit a Java field. The methods of this interface
* must be called in the following order: ( <tt>visitAnnotation</tt> |
* <tt>visitAttribute</tt> )* <tt>visitEnd</tt>.
*
* @author Eric Bruneton
*/
public interface FieldVisitor{

/**
* Visits an annotation of the field.
*
* @param desc the class descriptor of the annotation class.
* @param visible <tt>true</tt> if the annotation is visible at runtime.
* @return a visitor to visit the annotation values, or <tt>null</tt> if
* this visitor is not interested in visiting this annotation.
*/
AnnotationVisitor visitAnnotation(String desc, boolean visible);

/**
* Visits a non standard attribute of the field.
*
* @param attr an attribute.
*/
void visitAttribute(Attribute attr);
144 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Visits the end of the field. This method, which is the last one to be
* called, is used to inform the visitor that all the annotations and
* attributes of the field have been visited.
*/
void visitEnd();
}

———-

6.11 FieldWriter.java

— FieldWriter.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* An {@link FieldVisitor} that generates Java fields in bytecode form.
*
* @author Eric Bruneton
*/
final class FieldWriter implements FieldVisitor{

/**
* Next field writer (see {@link ClassWriter#firstField firstField}).
*/
FieldWriter next;

/**
* The class writer to which this field must be added.
*/
private ClassWriter cw;

/**
* Access flags of this field.
*/
private int access;

/**
* The index of the constant pool item that contains the name of this
* method.
*/
private int name;

/**
* The index of the constant pool item that contains the descriptor of
6.11. FIELDWRITER.JAVA 145

* this field.
*/
private int desc;

/**
* The index of the constant pool item that contains the signature of
* this field.
*/
private int signature;

/**
* The index of the constant pool item that contains the constant value
* of this field.
*/
private int value;

/**
* The runtime visible annotations of this field. May be <tt>null</tt>.
*/
private AnnotationWriter anns;

/**
* The runtime invisible annotations of this field. May be <tt>null</tt>.
*/
private AnnotationWriter ianns;

/**
* The non standard attributes of this field. May be <tt>null</tt>.
*/
private Attribute attrs;

// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------

/**
* Constructs a new {@link FieldWriter}.
*
* @param cw the class writer to which this field must be added.
* @param access the field’s access flags (see {@link Opcodes}).
* @param name the field’s name.
* @param desc the field’s descriptor (see {@link Type}).
* @param signature the field’s signature. May be <tt>null</tt>.
* @param value the field’s constant value. May be <tt>null</tt>.
*/
protected FieldWriter(
final ClassWriter cw,
final int access,
final String name,
final String desc,
146 CHAPTER 6. JVM/CLOJURE/ASM/

final String signature,

final Object value){
if(cw.firstField == null)
{
cw.firstField = this;
}
else
{
cw.lastField.next = this;
}
cw.lastField = this;
this.cw = cw;
this.access = access;
this.name = cw.newUTF8(name);
this.desc = cw.newUTF8(desc);
if(signature != null)
{
this.signature = cw.newUTF8(signature);
}
if(value != null)
{
this.value = cw.newConstItem(value).index;
}
}

// -------------------------------------------------------------------
// Implementation of the FieldVisitor interface
// -------------------------------------------------------------------

public AnnotationVisitor visitAnnotation(

final String desc,
final boolean visible){
ByteVector bv = new ByteVector();
// write type, and reserve space for values count
bv.putShort(cw.newUTF8(desc)).putShort(0);
AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
if(visible)
{
aw.next = anns;
anns = aw;
}
else
{
aw.next = ianns;
ianns = aw;
}
return aw;
}

public void visitAttribute(final Attribute attr){

6.11. FIELDWRITER.JAVA 147

attr.next = attrs;
attrs = attr;
}

public void visitEnd(){

}

// -------------------------------------------------------------------
// Utility methods
// -------------------------------------------------------------------

/**
* Returns the size of this field.
*
* @return the size of this field.
*/
int getSize(){
int size = 8;
if(value != 0)
{
cw.newUTF8("ConstantValue");
size += 8;
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (cw.version & 0xffff) < Opcodes.V1_5)
{
cw.newUTF8("Synthetic");
size += 6;
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
cw.newUTF8("Deprecated");
size += 6;
}
if(signature != 0)
{
cw.newUTF8("Signature");
size += 8;
}
if(anns != null)
{
cw.newUTF8("RuntimeVisibleAnnotations");
size += 8 + anns.getSize();
}
if(ianns != null)
{
cw.newUTF8("RuntimeInvisibleAnnotations");
size += 8 + ianns.getSize();
}
if(attrs != null)
148 CHAPTER 6. JVM/CLOJURE/ASM/

{
size += attrs.getSize(cw, null, 0, -1, -1);
}
return size;
}

/**
* Puts the content of this field into the given byte vector.
*
* @param out where the content of this field must be put.
*/
void put(final ByteVector out){
out.putShort(access).putShort(name).putShort(desc);
int attributeCount = 0;
if(value != 0)
{
++attributeCount;
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (cw.version & 0xffff) < Opcodes.V1_5)
{
++attributeCount;
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
++attributeCount;
}
if(signature != 0)
{
++attributeCount;
}
if(anns != null)
{
++attributeCount;
}
if(ianns != null)
{
++attributeCount;
}
if(attrs != null)
{
attributeCount += attrs.getCount();
}
out.putShort(attributeCount);
if(value != 0)
{
out.putShort(cw.newUTF8("ConstantValue"));
out.putInt(2).putShort(value);
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
6.12. FRAME.JAVA 149

&& (cw.version & 0xffff) < Opcodes.V1_5)

{
out.putShort(cw.newUTF8("Synthetic")).putInt(0);
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
out.putShort(cw.newUTF8("Deprecated")).putInt(0);
}
if(signature != 0)
{
out.putShort(cw.newUTF8("Signature"));
out.putInt(2).putShort(signature);
}
if(anns != null)
{
out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));
anns.put(out);
}
if(ianns != null)
{
out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));
ianns.put(out);
}
if(attrs != null)
{
attrs.put(cw, null, 0, -1, -1, out);
}
}
}

———-

6.12 Frame.java

— Frame.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* Information about the input and output stack map frames of a basic
* block.
*
* @author Eric Bruneton
*/
final class Frame{
150 CHAPTER 6. JVM/CLOJURE/ASM/

/*
* Frames are computed in a two steps process: during the visit
* of each instruction, the state of the frame at the end of
* current basic block is updated by simulating the action of
* the instruction on the previous state of this so called
* "output frame". In visitMaxs, a fix point algorithm is used
* to compute the "input frame" of each basic block, i.e. the
* stack mapframe at the begining of the basic block, starting
* from the input frameof the first basic block (which is
* computed from the method descriptor),and by using the
* previously computed output frames to compute the input
* state of the other blocks.
*
* All output and input frames are stored as arrays of
* integers. Reference and array types are represented by an
* index into a type table (which is not the same as the constant
* pool of the class, in order to avoid adding unnecessary
* constants in the pool - not all computed frames will end up
* being stored in the stack map table). This allows very fast
* type comparisons.
*
* Output stack map frames are computed relatively to the input
* frame of the basic block, which is not yet known when output
* frames are computed. It is therefore necessary to be able to
* represent abstract types such as "the type at position x in
* the input frame locals" or "the type at position x from the
* top of the input frame stack" or even "the type at position
* x in the input frame, with y more (or less) array dimensions".
* This explains the rather complicated type format used in
* output frames.
*
* This format is the following: DIM KIND VALUE (4, 4 and 24
* bits). DIM is a signed number of array dimensions (from -8 to
* 7). KIND is either BASE, LOCAL or STACK. BASE is used for
* types that are not relative to the input frame. LOCAL is used
* for types that are relative to the input local variable types.
* STACK is used for types that are relative to the input stack
* types. VALUE depends on KIND. For LOCAL types, it is an index
* in the input local variable types. For STACK types, it is a
* position relatively to the top of input frame stack. For BASE
* types, it is either one of the constants defined in
* FrameVisitor, or for OBJECT and UNINITIALIZED types, a tag
* and an index in the type table.
*
* Output frames can contain types of any kind and with a
* positive or negative dimension (and even unassigned types,
* represented by 0 - which does not correspond to any valid
* type value). Input frames can only contain BASE types of
* positive or null dimension. In all cases the type table
* contains only internal type names (array type descriptors
6.12. FRAME.JAVA 151

* are forbidden - dimensions must be represented through the

* DIM field).
*
* The LONG and DOUBLE types are always represented by using
* two slots (LONG + TOP or DOUBLE + TOP), for local variable
* types as well as in the operand stack. This is necessary to
* be able to simulate DUPx_y instructions, whose effect would
* be dependent on the actual type values if types were always
* represented by a single slot in the stack (and this is not
* possible, since actual type values are not always known -
* cf LOCAL and STACK type kinds).
*/

/**
* Mask to get the dimension of a frame type. This dimension is a signed
* integer between -8 and 7.
*/
final static int DIM = 0xF0000000;

/**
* Constant to be added to a type to get a type with one more dimension.
*/
final static int ARRAY_OF = 0x10000000;

/**
* Constant to be added to a type to get a type with one less dimension.
*/
final static int ELEMENT_OF = 0xF0000000;

/**
* Mask to get the kind of a frame type.
*
* @see #BASE
* @see #LOCAL
* @see #STACK
*/
final static int KIND = 0xF000000;

/**
* Mask to get the value of a frame type.
*/
final static int VALUE = 0xFFFFFF;

/**
* Mask to get the kind of base types.
*/
final static int BASE_KIND = 0xFF00000;

/**
* Mask to get the value of base types.
152 CHAPTER 6. JVM/CLOJURE/ASM/

*/
final static int BASE_VALUE = 0xFFFFF;

/**
* Kind of the types that are not relative to an input stack map frame.
*/
final static int BASE = 0x1000000;

/**
* Base kind of the base reference types. The BASE_VALUE of such types
* is an index into the type table.
*/
final static int OBJECT = BASE | 0x700000;

/**
* Base kind of the uninitialized base types. The BASE_VALUE of such
* types in an index into the type table (the Item at that index
* contains both an instruction offset and an internal class name).
*/
final static int UNINITIALIZED = BASE | 0x800000;

/**
* Kind of the types that are relative to the local variable types of
* an input stack map frame. The value of such types is a local
* variable index.
*/
private final static int LOCAL = 0x2000000;

/**
* Kind of the the types that are relative to the stack of an input
* stack map frame. The value of such types is a position relatively
* to the top of this stack.
*/
private final static int STACK = 0x3000000;

/**
* The TOP type. This is a BASE type.
*/
final static int TOP = BASE | 0;

/**
* The BOOLEAN type. This is a BASE type mainly used for array types.
*/
final static int BOOLEAN = BASE | 9;

/**
* The BYTE type. This is a BASE type mainly used for array types.
*/
final static int BYTE = BASE | 10;
6.12. FRAME.JAVA 153

/**
* The CHAR type. This is a BASE type mainly used for array types.
*/
final static int CHAR = BASE | 11;

/**
* The SHORT type. This is a BASE type mainly used for array types.
*/
final static int SHORT = BASE | 12;

/**
* The INTEGER type. This is a BASE type.
*/
final static int INTEGER = BASE | 1;

/**
* The FLOAT type. This is a BASE type.
*/
final static int FLOAT = BASE | 2;

/**
* The DOUBLE type. This is a BASE type.
*/
final static int DOUBLE = BASE | 3;

/**
* The LONG type. This is a BASE type.
*/
final static int LONG = BASE | 4;

/**
* The NULL type. This is a BASE type.
*/
final static int NULL = BASE | 5;

/**
* The UNINITIALIZED_THIS type. This is a BASE type.
*/
final static int UNINITIALIZED_THIS = BASE | 6;

/**
* The stack size variation corresponding to each JVM instruction.
* This stack variation is equal to the size of the values produced
* by an instruction, minus the size of the values consumed by this
* instruction.
*/
final static int[] SIZE;

/**
* Computes the stack size variation corresponding to each JVM
154 CHAPTER 6. JVM/CLOJURE/ASM/

* instruction.
*/
static
{
int i;
int[] b = new int[202];
String s =
"EFFFFFFFFGGFFFGGFFFEEFGFGFEEEEEEEEEEEEEEEEEEEEDEDEDDDDD"
+ "CDCDEEEEEEEEEEEEEEEEEEEEBABABBBBDCFFFGGGEDCDCDCDCDCDCDCDCD"
+ "CDCEEEEDDDDDDDCDCDCEFEFDDEEFFDEDEEEBDDBBDDDDDDCCCCCCCCEFED"
+ "DDCDCDEEEEEEEEEEFEEEEEEDDEEDDEE";
for(i = 0; i < b.length; ++i)
{
b[i] = s.charAt(i) - ’E’;
}
SIZE = b;

// code to generate the above string

//
// int NA = 0; // not applicable (unused opcode or variable
// size opcode)
//
// b = new int[] {
// 0, //NOP, // visitInsn
// 1, //ACONST_NULL, // -
// 1, //ICONST_M1, // -
// 1, //ICONST_0, // -
// 1, //ICONST_1, // -
// 1, //ICONST_2, // -
// 1, //ICONST_3, // -
// 1, //ICONST_4, // -
// 1, //ICONST_5, // -
// 2, //LCONST_0, // -
// 2, //LCONST_1, // -
// 1, //FCONST_0, // -
// 1, //FCONST_1, // -
// 1, //FCONST_2, // -
// 2, //DCONST_0, // -
// 2, //DCONST_1, // -
// 1, //BIPUSH, // visitIntInsn
// 1, //SIPUSH, // -
// 1, //LDC, // visitLdcInsn
// NA, //LDC_W, // -
// NA, //LDC2_W, // -
// 1, //ILOAD, // visitVarInsn
// 2, //LLOAD, // -
// 1, //FLOAD, // -
// 2, //DLOAD, // -
// 1, //ALOAD, // -
// NA, //ILOAD_0, // -
6.12. FRAME.JAVA 155

// NA, //ILOAD_1, // -
// NA, //ILOAD_2, // -
// NA, //ILOAD_3, // -
// NA, //LLOAD_0, // -
// NA, //LLOAD_1, // -
// NA, //LLOAD_2, // -
// NA, //LLOAD_3, // -
// NA, //FLOAD_0, // -
// NA, //FLOAD_1, // -
// NA, //FLOAD_2, // -
// NA, //FLOAD_3, // -
// NA, //DLOAD_0, // -
// NA, //DLOAD_1, // -
// NA, //DLOAD_2, // -
// NA, //DLOAD_3, // -
// NA, //ALOAD_0, // -
// NA, //ALOAD_1, // -
// NA, //ALOAD_2, // -
// NA, //ALOAD_3, // -
// -1, //IALOAD, // visitInsn
// 0, //LALOAD, // -
// -1, //FALOAD, // -
// 0, //DALOAD, // -
// -1, //AALOAD, // -
// -1, //BALOAD, // -
// -1, //CALOAD, // -
// -1, //SALOAD, // -
// -1, //ISTORE, // visitVarInsn
// -2, //LSTORE, // -
// -1, //FSTORE, // -
// -2, //DSTORE, // -
// -1, //ASTORE, // -
// NA, //ISTORE_0, // -
// NA, //ISTORE_1, // -
// NA, //ISTORE_2, // -
// NA, //ISTORE_3, // -
// NA, //LSTORE_0, // -
// NA, //LSTORE_1, // -
// NA, //LSTORE_2, // -
// NA, //LSTORE_3, // -
// NA, //FSTORE_0, // -
// NA, //FSTORE_1, // -
// NA, //FSTORE_2, // -
// NA, //FSTORE_3, // -
// NA, //DSTORE_0, // -
// NA, //DSTORE_1, // -
// NA, //DSTORE_2, // -
// NA, //DSTORE_3, // -
// NA, //ASTORE_0, // -
// NA, //ASTORE_1, // -
156 CHAPTER 6. JVM/CLOJURE/ASM/

// NA, //ASTORE_2, // -
// NA, //ASTORE_3, // -
// -3, //IASTORE, // visitInsn
// -4, //LASTORE, // -
// -3, //FASTORE, // -
// -4, //DASTORE, // -
// -3, //AASTORE, // -
// -3, //BASTORE, // -
// -3, //CASTORE, // -
// -3, //SASTORE, // -
// -1, //POP, // -
// -2, //POP2, // -
// 1, //DUP, // -
// 1, //DUP_X1, // -
// 1, //DUP_X2, // -
// 2, //DUP2, // -
// 2, //DUP2_X1, // -
// 2, //DUP2_X2, // -
// 0, //SWAP, // -
// -1, //IADD, // -
// -2, //LADD, // -
// -1, //FADD, // -
// -2, //DADD, // -
// -1, //ISUB, // -
// -2, //LSUB, // -
// -1, //FSUB, // -
// -2, //DSUB, // -
// -1, //IMUL, // -
// -2, //LMUL, // -
// -1, //FMUL, // -
// -2, //DMUL, // -
// -1, //IDIV, // -
// -2, //LDIV, // -
// -1, //FDIV, // -
// -2, //DDIV, // -
// -1, //IREM, // -
// -2, //LREM, // -
// -1, //FREM, // -
// -2, //DREM, // -
// 0, //INEG, // -
// 0, //LNEG, // -
// 0, //FNEG, // -
// 0, //DNEG, // -
// -1, //ISHL, // -
// -1, //LSHL, // -
// -1, //ISHR, // -
// -1, //LSHR, // -
// -1, //IUSHR, // -
// -1, //LUSHR, // -
// -1, //IAND, // -
6.12. FRAME.JAVA 157

// -2, //LAND, // -
// -1, //IOR, // -
// -2, //LOR, // -
// -1, //IXOR, // -
// -2, //LXOR, // -
// 0, //IINC, // visitIincInsn
// 1, //I2L, // visitInsn
// 0, //I2F, // -
// 1, //I2D, // -
// -1, //L2I, // -
// -1, //L2F, // -
// 0, //L2D, // -
// 0, //F2I, // -
// 1, //F2L, // -
// 1, //F2D, // -
// -1, //D2I, // -
// 0, //D2L, // -
// -1, //D2F, // -
// 0, //I2B, // -
// 0, //I2C, // -
// 0, //I2S, // -
// -3, //LCMP, // -
// -1, //FCMPL, // -
// -1, //FCMPG, // -
// -3, //DCMPL, // -
// -3, //DCMPG, // -
// -1, //IFEQ, // visitJumpInsn
// -1, //IFNE, // -
// -1, //IFLT, // -
// -1, //IFGE, // -
// -1, //IFGT, // -
// -1, //IFLE, // -
// -2, //IF_ICMPEQ, // -
// -2, //IF_ICMPNE, // -
// -2, //IF_ICMPLT, // -
// -2, //IF_ICMPGE, // -
// -2, //IF_ICMPGT, // -
// -2, //IF_ICMPLE, // -
// -2, //IF_ACMPEQ, // -
// -2, //IF_ACMPNE, // -
// 0, //GOTO, // -
// 1, //JSR, // -
// 0, //RET, // visitVarInsn
// -1, //TABLESWITCH, // visiTableSwitchInsn
// -1, //LOOKUPSWITCH, // visitLookupSwitch
// -1, //IRETURN, // visitInsn
// -2, //LRETURN, // -
// -1, //FRETURN, // -
// -2, //DRETURN, // -
// -1, //ARETURN, // -
158 CHAPTER 6. JVM/CLOJURE/ASM/

// 0, //RETURN, // -
// NA, //GETSTATIC, // visitFieldInsn
// NA, //PUTSTATIC, // -
// NA, //GETFIELD, // -
// NA, //PUTFIELD, // -
// NA, //INVOKEVIRTUAL, // visitMethodInsn
// NA, //INVOKESPECIAL, // -
// NA, //INVOKESTATIC, // -
// NA, //INVOKEINTERFACE, // -
// NA, //UNUSED, // NOT VISITED
// 1, //NEW, // visitTypeInsn
// 0, //NEWARRAY, // visitIntInsn
// 0, //ANEWARRAY, // visitTypeInsn
// 0, //ARRAYLENGTH, // visitInsn
// NA, //ATHROW, // -
// 0, //CHECKCAST, // visitTypeInsn
// 0, //INSTANCEOF, // -
// -1, //MONITORENTER, // visitInsn
// -1, //MONITOREXIT, // -
// NA, //WIDE, // NOT VISITED
// NA, //MULTIANEWARRAY, // visitMultiANewArrayInsn
// -1, //IFNULL, // visitJumpInsn
// -1, //IFNONNULL, // -
// NA, //GOTO_W, // -
// NA, //JSR_W, // -
// };
// for (i = 0; i < b.length; ++i) {
// System.err.print((char)(’E’ + b[i]));
// }
// System.err.println();
}

/**
* The label (i.e. basic block) to which these input and output stack map
* frames correspond.
*/
Label owner;

/**
* The input stack map frame locals.
*/
int[] inputLocals;

/**
* The input stack map frame stack.
*/
int[] inputStack;

/**
* The output stack map frame locals.
6.12. FRAME.JAVA 159

*/
private int[] outputLocals;

/**
* The output stack map frame stack.
*/
private int[] outputStack;

/**
* Relative size of the output stack. The exact semantics of this field
* depends on the algorithm that is used.
* 
* When only the maximum stack size is computed, this field is the size
* of the output stack relatively to the top of the input stack.
* 
* When the stack map frames are completely computed, this field is the
* actual number of types in {@link #outputStack}.
*/
private int outputStackTop;

/**
* Number of types that are initialized in the basic block.
*
* @see #initializations
*/
private int initializationCount;

/**
* The types that are initialized in the basic block. A constructor
* invocation on an UNINITIALIZED or UNINITIALIZED_THIS type must
* replace every occurence of this type in the local variables
* and in the operand stack. This cannot be done during the first
* phase of the algorithm since, during this phase, the local variables
* and the operand stack are not completely computed. It is therefore
* necessary to store the types on which constructors are invoked in
* the basic block, in order to do this replacement during the second
* phase of the algorithm, where the frames are fully computed. Note
* that this array can contain types that are relative to input locals
* or to the input stack (see below for the description of the
* algorithm).
*/
private int[] initializations;

/**
* Returns the output frame local variable type at the given index.
*
* @param local the index of the local that must be returned.
* @return the output frame local variable type at the given index.
*/
private int get(final int local){
160 CHAPTER 6. JVM/CLOJURE/ASM/

if(outputLocals == null || local >= outputLocals.length)

{
// this local has never been assigned in this basic block,
// so it is still equal to its value in the input frame
return LOCAL | local;
}
else
{
int type = outputLocals[local];
if(type == 0)
{
// this local has never been assigned in this
// basic block, so it is still equal to its value
// in the input frame
type = outputLocals[local] = LOCAL | local;
}
return type;
}
}

/**
* Sets the output frame local variable type at the given index.
*
* @param local the index of the local that must be set.
* @param type the value of the local that must be set.
*/
private void set(final int local, final int type){
// creates and/or resizes the output local variables
// array if necessary
if(outputLocals == null)
{
outputLocals = new int[10];
}
int n = outputLocals.length;
if(local >= n)
{
int[] t = new int[Math.max(local + 1, 2 * n)];
System.arraycopy(outputLocals, 0, t, 0, n);
outputLocals = t;
}
// sets the local variable
outputLocals[local] = type;
}

/**
* Pushes a new type onto the output frame stack.
*
* @param type the type that must be pushed.
*/
private void push(final int type){
6.12. FRAME.JAVA 161

// creates and/or resizes the output stack array if necessary

if(outputStack == null)
{
outputStack = new int[10];
}
int n = outputStack.length;
if(outputStackTop >= n)
{
int[] t = new int[Math.max(outputStackTop + 1, 2 * n)];
System.arraycopy(outputStack, 0, t, 0, n);
outputStack = t;
}
// pushes the type on the output stack
outputStack[outputStackTop++] = type;
// updates the maximun height reached by the output stack, if needed
int top = owner.inputStackTop + outputStackTop;
if(top > owner.outputStackMax)
{
owner.outputStackMax = top;
}
}

/**
* Pushes a new type onto the output frame stack.
*
* @param cw the ClassWriter to which this label belongs.
* @param desc the descriptor of the type to be pushed. Can also be a
* method descriptor (in this case this method pushes its
* return type onto the output frame stack).
*/
private void push(final ClassWriter cw, final String desc){
int type = type(cw, desc);
if(type != 0)
{
push(type);
if(type == LONG || type == DOUBLE)
{
push(TOP);
}
}
}

/**
* Returns the int encoding of the given type.
*
* @param cw the ClassWriter to which this label belongs.
* @param desc a type descriptor.
* @return the int encoding of the given type.
*/
private int type(final ClassWriter cw, final String desc){
162 CHAPTER 6. JVM/CLOJURE/ASM/

String t;
int index = desc.charAt(0) == ’(’ ? desc.indexOf(’)’) + 1 : 0;
switch(desc.charAt(index))
{
case’V’:
return 0;
case’Z’:
case’C’:
case’B’:
case’S’:
case’I’:
return INTEGER;
case’F’:
return FLOAT;
case’J’:
return LONG;
case’D’:
return DOUBLE;
case’L’:
// stores the internal name, not the descriptor!
t = desc.substring(index + 1, desc.length() - 1);
return OBJECT | cw.addType(t);
// case ’[’:
default:
// extracts the dimensions and the element type
int data;
int dims = index + 1;
while(desc.charAt(dims) == ’[’)
{
++dims;
}
switch(desc.charAt(dims))
{
case’Z’:
data = BOOLEAN;
break;
case’C’:
data = CHAR;
break;
case’B’:
data = BYTE;
break;
case’S’:
data = SHORT;
break;
case’I’:
data = INTEGER;
break;
case’F’:
data = FLOAT;
6.12. FRAME.JAVA 163

break;
case’J’:
data = LONG;
break;
case’D’:
data = DOUBLE;
break;
// case ’L’:
default:
// stores the internal name, not the descriptor
t = desc.substring(dims + 1, desc.length() - 1);
data = OBJECT | cw.addType(t);
}
return (dims - index) << 28 | data;
}
}

/**
* Pops a type from the output frame stack and returns its value.
*
* @return the type that has been popped from the output frame stack.
*/
private int pop(){
if(outputStackTop > 0)
{
return outputStack[--outputStackTop];
}
else
{
// if the output frame stack is empty, pops from the input stack
return STACK | -(--owner.inputStackTop);
}
}

/**
* Pops the given number of types from the output frame stack.
*
* @param elements the number of types that must be popped.
*/
private void pop(final int elements){
if(outputStackTop >= elements)
{
outputStackTop -= elements;
}
else
{
// if the number of elements to be popped is greater than the
// number of elements in the output stack, clear it, and pops
// the remaining elements from the input stack.
owner.inputStackTop -= elements - outputStackTop;
164 CHAPTER 6. JVM/CLOJURE/ASM/

outputStackTop = 0;
}
}

/**
* Pops a type from the output frame stack.
*
* @param desc the descriptor of the type to be popped. Can also be a
* method descriptor (in this case this method pops the
* types corresponding to the method arguments).
*/
private void pop(final String desc){
char c = desc.charAt(0);
if(c == ’(’)
{
pop((MethodWriter.getArgumentsAndReturnSizes(desc) >> 2) - 1);
}
else if(c == ’J’ || c == ’D’)
{
pop(2);
}
else
{
pop(1);
}
}

/**
* Adds a new type to the list of types on which a constructor is
* invoked in the basic block.
*
* @param var a type on a which a constructor is invoked.
*/
private void init(final int var){
// creates and/or resizes the initializations array if necessary
if(initializations == null)
{
initializations = new int[2];
}
int n = initializations.length;
if(initializationCount >= n)
{
int[] t = new int[Math.max(initializationCount + 1, 2 * n)];
System.arraycopy(initializations, 0, t, 0, n);
initializations = t;
}
// stores the type to be initialized
initializations[initializationCount++] = var;
}
6.12. FRAME.JAVA 165

/**
* Replaces the given type with the appropriate type if it is one of
* the types on which a constructor is invoked in the basic block.
*
* @param cw the ClassWriter to which this label belongs.
* @param t a type
* @return t or, if t is one of the types on which a constructor is
* invoked in the basic block, the type corresponding to this
* constructor.
*/
private int init(final ClassWriter cw, final int t){
int s;
if(t == UNINITIALIZED_THIS)
{
s = OBJECT | cw.addType(cw.thisName);
}
else if((t & (DIM | BASE_KIND)) == UNINITIALIZED)
{
String type = cw.typeTable[t & BASE_VALUE].strVal1;
s = OBJECT | cw.addType(type);
}
else
{
return t;
}
for(int j = 0; j < initializationCount; ++j)
{
int u = initializations[j];
int dim = u & DIM;
int kind = u & KIND;
if(kind == LOCAL)
{
u = dim + inputLocals[u & VALUE];
}
else if(kind == STACK)
{
u = dim + inputStack[inputStack.length - (u & VALUE)];
}
if(t == u)
{
return s;
}
}
return t;
}

/**
* Initializes the input frame of the first basic block from the method
* descriptor.
*
166 CHAPTER 6. JVM/CLOJURE/ASM/

* @param cw the ClassWriter to which this label belongs.

* @param access the access flags of the method to which this
* label belongs.
* @param args the formal parameter types of this method.
* @param maxLocals the maximum number of local variables of this method.
*/
void initInputFrame(
final ClassWriter cw,
final int access,
final Type[] args,
final int maxLocals){
inputLocals = new int[maxLocals];
inputStack = new int[0];
int i = 0;
if((access & Opcodes.ACC_STATIC) == 0)
{
if((access & MethodWriter.ACC_CONSTRUCTOR) == 0)
{
inputLocals[i++] = OBJECT | cw.addType(cw.thisName);
}
else
{
inputLocals[i++] = UNINITIALIZED_THIS;
}
}
for(int j = 0; j < args.length; ++j)
{
int t = type(cw, args[j].getDescriptor());
inputLocals[i++] = t;
if(t == LONG || t == DOUBLE)
{
inputLocals[i++] = TOP;
}
}
while(i < maxLocals)
{
inputLocals[i++] = TOP;
}
}

/**
* Simulates the action of the given instruction on the output stack
* frame.
*
* @param opcode the opcode of the instruction.
* @param arg the operand of the instruction, if any.
* @param cw the class writer to which this label belongs.
* @param item the operand of the instructions, if any.
*/
void execute(
6.12. FRAME.JAVA 167

final int opcode,

final int arg,
final ClassWriter cw,
final Item item){
int t1, t2, t3, t4;
switch(opcode)
{
case Opcodes.NOP:
case Opcodes.INEG:
case Opcodes.LNEG:
case Opcodes.FNEG:
case Opcodes.DNEG:
case Opcodes.I2B:
case Opcodes.I2C:
case Opcodes.I2S:
case Opcodes.GOTO:
case Opcodes.RETURN:
break;
case Opcodes.ACONST_NULL:
push(NULL);
break;
case Opcodes.ICONST_M1:
case Opcodes.ICONST_0:
case Opcodes.ICONST_1:
case Opcodes.ICONST_2:
case Opcodes.ICONST_3:
case Opcodes.ICONST_4:
case Opcodes.ICONST_5:
case Opcodes.BIPUSH:
case Opcodes.SIPUSH:
case Opcodes.ILOAD:
push(INTEGER);
break;
case Opcodes.LCONST_0:
case Opcodes.LCONST_1:
case Opcodes.LLOAD:
push(LONG);
push(TOP);
break;
case Opcodes.FCONST_0:
case Opcodes.FCONST_1:
case Opcodes.FCONST_2:
case Opcodes.FLOAD:
push(FLOAT);
break;
case Opcodes.DCONST_0:
case Opcodes.DCONST_1:
case Opcodes.DLOAD:
push(DOUBLE);
push(TOP);
168 CHAPTER 6. JVM/CLOJURE/ASM/

break;
case Opcodes.LDC:
switch(item.type)
{
case ClassWriter.INT:
push(INTEGER);
break;
case ClassWriter.LONG:
push(LONG);
push(TOP);
break;
case ClassWriter.FLOAT:
push(FLOAT);
break;
case ClassWriter.DOUBLE:
push(DOUBLE);
push(TOP);
break;
case ClassWriter.CLASS:
push(OBJECT | cw.addType("java/lang/Class"));
break;
// case ClassWriter.STR:
default:
push(OBJECT | cw.addType("java/lang/String"));
}
break;
case Opcodes.ALOAD:
push(get(arg));
break;
case Opcodes.IALOAD:
case Opcodes.BALOAD:
case Opcodes.CALOAD:
case Opcodes.SALOAD:
pop(2);
push(INTEGER);
break;
case Opcodes.LALOAD:
case Opcodes.D2L:
pop(2);
push(LONG);
push(TOP);
break;
case Opcodes.FALOAD:
pop(2);
push(FLOAT);
break;
case Opcodes.DALOAD:
case Opcodes.L2D:
pop(2);
push(DOUBLE);
6.12. FRAME.JAVA 169

push(TOP);
break;
case Opcodes.AALOAD:
pop(1);
t1 = pop();
push(ELEMENT_OF + t1);
break;
case Opcodes.ISTORE:
case Opcodes.FSTORE:
case Opcodes.ASTORE:
t1 = pop();
set(arg, t1);
if(arg > 0)
{
t2 = get(arg - 1);
// if t2 is of kind STACK or LOCAL we cannot know
// its size!
if(t2 == LONG || t2 == DOUBLE)
{
set(arg - 1, TOP);
}
}
break;
case Opcodes.LSTORE:
case Opcodes.DSTORE:
pop(1);
t1 = pop();
set(arg, t1);
set(arg + 1, TOP);
if(arg > 0)
{
t2 = get(arg - 1);
// if t2 is of kind STACK or LOCAL we cannot know
// its size!
if(t2 == LONG || t2 == DOUBLE)
{
set(arg - 1, TOP);
}
}
break;
case Opcodes.IASTORE:
case Opcodes.BASTORE:
case Opcodes.CASTORE:
case Opcodes.SASTORE:
case Opcodes.FASTORE:
case Opcodes.AASTORE:
pop(3);
break;
case Opcodes.LASTORE:
case Opcodes.DASTORE:
170 CHAPTER 6. JVM/CLOJURE/ASM/

pop(4);
break;
case Opcodes.POP:
case Opcodes.IFEQ:
case Opcodes.IFNE:
case Opcodes.IFLT:
case Opcodes.IFGE:
case Opcodes.IFGT:
case Opcodes.IFLE:
case Opcodes.IRETURN:
case Opcodes.FRETURN:
case Opcodes.ARETURN:
case Opcodes.TABLESWITCH:
case Opcodes.LOOKUPSWITCH:
case Opcodes.ATHROW:
case Opcodes.MONITORENTER:
case Opcodes.MONITOREXIT:
case Opcodes.IFNULL:
case Opcodes.IFNONNULL:
pop(1);
break;
case Opcodes.POP2:
case Opcodes.IF_ICMPEQ:
case Opcodes.IF_ICMPNE:
case Opcodes.IF_ICMPLT:
case Opcodes.IF_ICMPGE:
case Opcodes.IF_ICMPGT:
case Opcodes.IF_ICMPLE:
case Opcodes.IF_ACMPEQ:
case Opcodes.IF_ACMPNE:
case Opcodes.LRETURN:
case Opcodes.DRETURN:
pop(2);
break;
case Opcodes.DUP:
t1 = pop();
push(t1);
push(t1);
break;
case Opcodes.DUP_X1:
t1 = pop();
t2 = pop();
push(t1);
push(t2);
push(t1);
break;
case Opcodes.DUP_X2:
t1 = pop();
t2 = pop();
t3 = pop();
6.12. FRAME.JAVA 171

push(t1);
push(t3);
push(t2);
push(t1);
break;
case Opcodes.DUP2:
t1 = pop();
t2 = pop();
push(t2);
push(t1);
push(t2);
push(t1);
break;
case Opcodes.DUP2_X1:
t1 = pop();
t2 = pop();
t3 = pop();
push(t2);
push(t1);
push(t3);
push(t2);
push(t1);
break;
case Opcodes.DUP2_X2:
t1 = pop();
t2 = pop();
t3 = pop();
t4 = pop();
push(t2);
push(t1);
push(t4);
push(t3);
push(t2);
push(t1);
break;
case Opcodes.SWAP:
t1 = pop();
t2 = pop();
push(t1);
push(t2);
break;
case Opcodes.IADD:
case Opcodes.ISUB:
case Opcodes.IMUL:
case Opcodes.IDIV:
case Opcodes.IREM:
case Opcodes.IAND:
case Opcodes.IOR:
case Opcodes.IXOR:
case Opcodes.ISHL:
172 CHAPTER 6. JVM/CLOJURE/ASM/

case Opcodes.ISHR:
case Opcodes.IUSHR:
case Opcodes.L2I:
case Opcodes.D2I:
case Opcodes.FCMPL:
case Opcodes.FCMPG:
pop(2);
push(INTEGER);
break;
case Opcodes.LADD:
case Opcodes.LSUB:
case Opcodes.LMUL:
case Opcodes.LDIV:
case Opcodes.LREM:
case Opcodes.LAND:
case Opcodes.LOR:
case Opcodes.LXOR:
pop(4);
push(LONG);
push(TOP);
break;
case Opcodes.FADD:
case Opcodes.FSUB:
case Opcodes.FMUL:
case Opcodes.FDIV:
case Opcodes.FREM:
case Opcodes.L2F:
case Opcodes.D2F:
pop(2);
push(FLOAT);
break;
case Opcodes.DADD:
case Opcodes.DSUB:
case Opcodes.DMUL:
case Opcodes.DDIV:
case Opcodes.DREM:
pop(4);
push(DOUBLE);
push(TOP);
break;
case Opcodes.LSHL:
case Opcodes.LSHR:
case Opcodes.LUSHR:
pop(3);
push(LONG);
push(TOP);
break;
case Opcodes.IINC:
set(arg, INTEGER);
break;
6.12. FRAME.JAVA 173

case Opcodes.I2L:
case Opcodes.F2L:
pop(1);
push(LONG);
push(TOP);
break;
case Opcodes.I2F:
pop(1);
push(FLOAT);
break;
case Opcodes.I2D:
case Opcodes.F2D:
pop(1);
push(DOUBLE);
push(TOP);
break;
case Opcodes.F2I:
case Opcodes.ARRAYLENGTH:
case Opcodes.INSTANCEOF:
pop(1);
push(INTEGER);
break;
case Opcodes.LCMP:
case Opcodes.DCMPL:
case Opcodes.DCMPG:
pop(4);
push(INTEGER);
break;
case Opcodes.JSR:
case Opcodes.RET:
throw new RuntimeException(
"JSR/RET are not supported with computeFrames option");
case Opcodes.GETSTATIC:
push(cw, item.strVal3);
break;
case Opcodes.PUTSTATIC:
pop(item.strVal3);
break;
case Opcodes.GETFIELD:
pop(1);
push(cw, item.strVal3);
break;
case Opcodes.PUTFIELD:
pop(item.strVal3);
pop();
break;
case Opcodes.INVOKEVIRTUAL:
case Opcodes.INVOKESPECIAL:
case Opcodes.INVOKESTATIC:
case Opcodes.INVOKEINTERFACE:
174 CHAPTER 6. JVM/CLOJURE/ASM/

pop(item.strVal3);
if(opcode != Opcodes.INVOKESTATIC)
{
t1 = pop();
if(opcode == Opcodes.INVOKESPECIAL
&& item.strVal2.charAt(0) == ’<’)
{
init(t1);
}
}
push(cw, item.strVal3);
break;
case Opcodes.NEW:
push(UNINITIALIZED |
cw.addUninitializedType(item.strVal1, arg));
break;
case Opcodes.NEWARRAY:
pop();
switch(arg)
{
case Opcodes.T_BOOLEAN:
push(ARRAY_OF | BOOLEAN);
break;
case Opcodes.T_CHAR:
push(ARRAY_OF | CHAR);
break;
case Opcodes.T_BYTE:
push(ARRAY_OF | BYTE);
break;
case Opcodes.T_SHORT:
push(ARRAY_OF | SHORT);
break;
case Opcodes.T_INT:
push(ARRAY_OF | INTEGER);
break;
case Opcodes.T_FLOAT:
push(ARRAY_OF | FLOAT);
break;
case Opcodes.T_DOUBLE:
push(ARRAY_OF | DOUBLE);
break;
// case Opcodes.T_LONG:
default:
push(ARRAY_OF | LONG);
break;
}
break;
case Opcodes.ANEWARRAY:
String s = item.strVal1;
pop();
6.12. FRAME.JAVA 175

if(s.charAt(0) == ’[’)
{
push(cw, "[" + s);
}
else
{
push(ARRAY_OF | OBJECT | cw.addType(s));
}
break;
case Opcodes.CHECKCAST:
s = item.strVal1;
pop();
if(s.charAt(0) == ’[’)
{
push(cw, s);
}
else
{
push(OBJECT | cw.addType(s));
}
break;
// case Opcodes.MULTIANEWARRAY:
default:
pop(arg);
push(cw, item.strVal1);
break;
}
}

/**
* Merges the input frame of the given basic block with the input and
* output frames of this basic block. Returns <tt>true</tt> if the
* input frame of the given label has been changed by this operation.
*
* @param cw the ClassWriter to which this label belongs.
* @param frame the basic block whose input frame must be updated.
* @param edge the kind of the {@link Edge} between this label and
* ’label’. See {@link Edge#info}.
* @return <tt>true</tt> if the input frame of the given label has been
* changed by this operation.
*/
boolean merge(final ClassWriter cw, final Frame frame, final int edge){
boolean changed = false;
int i, s, dim, kind, t;

int nLocal = inputLocals.length;

int nStack = inputStack.length;
if(frame.inputLocals == null)
{
frame.inputLocals = new int[nLocal];
176 CHAPTER 6. JVM/CLOJURE/ASM/

changed = true;
}

for(i = 0; i < nLocal; ++i)

{
if(outputLocals != null && i < outputLocals.length)
{
s = outputLocals[i];
if(s == 0)
{
t = inputLocals[i];
}
else
{
dim = s & DIM;
kind = s & KIND;
if(kind == LOCAL)
{
t = dim + inputLocals[s & VALUE];
}
else if(kind == STACK)
{
t = dim + inputStack[nStack - (s & VALUE)];
}
else
{
t = s;
}
}
}
else
{
t = inputLocals[i];
}
if(initializations != null)
{
t = init(cw, t);
}
changed |= merge(cw, t, frame.inputLocals, i);
}

if(edge > 0)
{
for(i = 0; i < nLocal; ++i)
{
t = inputLocals[i];
changed |= merge(cw, t, frame.inputLocals, i);
}
if(frame.inputStack == null)
{
6.12. FRAME.JAVA 177

frame.inputStack = new int[1];

changed = true;
}
changed |= merge(cw, edge, frame.inputStack, 0);
return changed;
}

int nInputStack = inputStack.length + owner.inputStackTop;

if(frame.inputStack == null)
{
frame.inputStack = new int[nInputStack + outputStackTop];
changed = true;
}

for(i = 0; i < nInputStack; ++i)

{
t = inputStack[i];
if(initializations != null)
{
t = init(cw, t);
}
changed |= merge(cw, t, frame.inputStack, i);
}
for(i = 0; i < outputStackTop; ++i)
{
s = outputStack[i];
dim = s & DIM;
kind = s & KIND;
if(kind == LOCAL)
{
t = dim + inputLocals[s & VALUE];
}
else if(kind == STACK)
{
t = dim + inputStack[nStack - (s & VALUE)];
}
else
{
t = s;
}
if(initializations != null)
{
t = init(cw, t);
}
changed |= merge(cw, t, frame.inputStack, nInputStack + i);
}
return changed;
}

/**
178 CHAPTER 6. JVM/CLOJURE/ASM/

* Merges the type at the given index in the given type array with
* the given type. Returns <tt>true</tt> if the type array has been
* modified by this operation.
*
* @param cw the ClassWriter to which this label belongs.
* @param t the type with which the type array element must be
* merged.
* @param types an array of types.
* @param index the index of the type that must be merged in ’types’.
* @return <tt>true</tt> if the type array has been modified by this
* operation.
*/
private boolean merge(
final ClassWriter cw,
int t,
final int[] types,
final int index){
int u = types[index];
if(u == t)
{
// if the types are equal, merge(u,t)=u, so there is no change
return false;
}
if((t & ~DIM) == NULL)
{
if(u == NULL)
{
return false;
}
t = NULL;
}
if(u == 0)
{
// if types[index] has never been assigned, merge(u,t)=t
types[index] = t;
return true;
}
int v;
if((u & BASE_KIND) == OBJECT || (u & DIM) != 0)
{
// if u is a reference type of any dimension
if(t == NULL)
{
// if t is the NULL type, merge(u,t)=u, so there is no change
return false;
}
else if((t & (DIM | BASE_KIND)) == (u & (DIM | BASE_KIND)))
{
if((u & BASE_KIND) == OBJECT)
{
6.12. FRAME.JAVA 179

// if t is also a reference type, and if u and t have

// the same dimension merge(u,t) = dim(t) | common parent
// of the element types of u and t
v = (t & DIM) | OBJECT
| cw.getMergedType(t & BASE_VALUE, u & BASE_VALUE);
}
else
{
// if u and t are array types, but not with the same
// element type, merge(u,t)=java/lang/Object
v = OBJECT | cw.addType("java/lang/Object");
}
}
else if((t & BASE_KIND) == OBJECT || (t & DIM) != 0)
{
// if t is any other reference or array type,
// merge(u,t)=java/lang/Object
v = OBJECT | cw.addType("java/lang/Object");
}
else
{
// if t is any other type, merge(u,t)=TOP
v = TOP;
}
}
else if(u == NULL)
{
// if u is the NULL type, merge(u,t)=t,
// or TOP if t is not a reference type
v = (t & BASE_KIND) == OBJECT || (t & DIM) != 0 ? t : TOP;
}
else
{
// if u is any other type, merge(u,t)=TOP whatever t
v = TOP;
}
if(u != v)
{
types[index] = v;
return true;
}
return false;
}
}

———-
180 CHAPTER 6. JVM/CLOJURE/ASM/

6.13 Handler.java

— Handler.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* Information about an exception handler block.
*
* @author Eric Bruneton
*/
class Handler{

/**
* Beginning of the exception handler’s scope (inclusive).
*/
Label start;

/**
* End of the exception handler’s scope (exclusive).
*/
Label end;

/**
* Beginning of the exception handler’s code.
*/
Label handler;

/**
* Internal name of the type of exceptions handled by this handler, or
* <tt>null</tt> to catch any exceptions.
*/
String desc;

/**
* Constant pool index of the internal name of the type of exceptions
* handled by this handler, or 0 to catch any exceptions.
*/
int type;

/**
* Next exception handler block info.
*/
Handler next;
}

———-
6.14. ITEM.JAVA 181

6.14 Item.java

— Item.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* A constant pool item. Constant pool items can be created with the
* ’newXXX’ methods in the {@link ClassWriter} class.
*
* @author Eric Bruneton
*/
final class Item{

/**
* Index of this item in the constant pool.
*/
int index;

/**
* Type of this constant pool item. A single class is used to represent
* all constant pool item types, in order to minimize the bytecode size
* of this package. The value of this field is one of
* {@link ClassWriter#INT},
* {@link ClassWriter#LONG}, {@link ClassWriter#FLOAT},
* {@link ClassWriter#DOUBLE}, {@link ClassWriter#UTF8},
* {@link ClassWriter#STR}, {@link ClassWriter#CLASS},
* {@link ClassWriter#NAME_TYPE}, {@link ClassWriter#FIELD},
* {@link ClassWriter#METH}, {@link ClassWriter#IMETH}.
* 
* Special Item types are used for Items that are stored in the
* ClassWriter {@link ClassWriter#typeTable}, instead of the constant
* pool, in order to avoid clashes with normal constant pool items in
* the ClassWriter constant pool’s hash table. These special item types
* are {@link ClassWriter#TYPE_NORMAL}, {@link ClassWriter#TYPE_UNINIT}
* and {@link ClassWriter#TYPE_MERGED}.
*/
int type;

/**
* Value of this item, for an integer item.
*/
int intVal;

/**
* Value of this item, for a long item.
*/
182 CHAPTER 6. JVM/CLOJURE/ASM/

long longVal;

/**
* First part of the value of this item, for items that do not hold a
* primitive value.
*/
String strVal1;

/**
* Second part of the value of this item, for items that do not hold a
* primitive value.
*/
String strVal2;

/**
* Third part of the value of this item, for items that do not hold a
* primitive value.
*/
String strVal3;

/**
* The hash code value of this constant pool item.
*/
int hashCode;

/**
* Link to another constant pool item, used for collision lists in the
* constant pool’s hash table.
*/
Item next;

/**
* Constructs an uninitialized {@link Item}.
*/
Item(){
}

/**
* Constructs an uninitialized {@link Item} for constant pool element at
* given position.
*
* @param index index of the item to be constructed.
*/
Item(final int index){
this.index = index;
}

/**
* Constructs a copy of the given item.
*
6.14. ITEM.JAVA 183

* @param index index of the item to be constructed.

* @param i the item that must be copied into the item to be
* constructed.
*/
Item(final int index, final Item i){
this.index = index;
type = i.type;
intVal = i.intVal;
longVal = i.longVal;
strVal1 = i.strVal1;
strVal2 = i.strVal2;
strVal3 = i.strVal3;
hashCode = i.hashCode;
}

/**
* Sets this item to an integer item.
*
* @param intVal the value of this item.
*/
void set(final int intVal){
this.type = ClassWriter.INT;
this.intVal = intVal;
this.hashCode = 0x7FFFFFFF & (type + intVal);
}

/**
* Sets this item to a long item.
*
* @param longVal the value of this item.
*/
void set(final long longVal){
this.type = ClassWriter.LONG;
this.longVal = longVal;
this.hashCode = 0x7FFFFFFF & (type + (int) longVal);
}

/**
* Sets this item to a float item.
*
* @param floatVal the value of this item.
*/
void set(final float floatVal){
this.type = ClassWriter.FLOAT;
this.intVal = Float.floatToRawIntBits(floatVal);
this.hashCode = 0x7FFFFFFF & (type + (int) floatVal);
}

/**
* Sets this item to a double item.
184 CHAPTER 6. JVM/CLOJURE/ASM/

*
* @param doubleVal the value of this item.
*/
void set(final double doubleVal){
this.type = ClassWriter.DOUBLE;
this.longVal = Double.doubleToRawLongBits(doubleVal);
this.hashCode = 0x7FFFFFFF & (type + (int) doubleVal);
}

/**
* Sets this item to an item that do not hold a primitive value.
*
* @param type the type of this item.
* @param strVal1 first part of the value of this item.
* @param strVal2 second part of the value of this item.
* @param strVal3 third part of the value of this item.
*/
void set(
final int type,
final String strVal1,
final String strVal2,
final String strVal3){
this.type = type;
this.strVal1 = strVal1;
this.strVal2 = strVal2;
this.strVal3 = strVal3;
switch(type)
{
case ClassWriter.UTF8:
case ClassWriter.STR:
case ClassWriter.CLASS:
case ClassWriter.TYPE_NORMAL:
hashCode = 0x7FFFFFFF & (type + strVal1.hashCode());
return;
case ClassWriter.NAME_TYPE:
hashCode = 0x7FFFFFFF & (type + strVal1.hashCode()
* strVal2.hashCode());
return;
// ClassWriter.FIELD:
// ClassWriter.METH:
// ClassWriter.IMETH:
default:
hashCode = 0x7FFFFFFF &
(type + strVal1.hashCode()
* strVal2.hashCode() * strVal3.hashCode());
}
}

/**
* Indicates if the given item is equal to this one.
6.15. LABEL.JAVA 185

*
* @param i the item to be compared to this one.
* @return <tt>true</tt> if the given item if equal to this one,
* <tt>false</tt> otherwise.
*/
boolean isEqualTo(final Item i){
if(i.type == type)
{
switch(type)
{
case ClassWriter.INT:
case ClassWriter.FLOAT:
return i.intVal == intVal;
case ClassWriter.TYPE_MERGED:
case ClassWriter.LONG:
case ClassWriter.DOUBLE:
return i.longVal == longVal;
case ClassWriter.UTF8:
case ClassWriter.STR:
case ClassWriter.CLASS:
case ClassWriter.TYPE_NORMAL:
return i.strVal1.equals(strVal1);
case ClassWriter.TYPE_UNINIT:
return i.intVal == intVal && i.strVal1.equals(strVal1);
case ClassWriter.NAME_TYPE:
return i.strVal1.equals(strVal1)
&& i.strVal2.equals(strVal2);
// ClassWriter.FIELD:
// ClassWriter.METH:
// ClassWriter.IMETH:
default:
return i.strVal1.equals(strVal1)
&& i.strVal2.equals(strVal2)
&& i.strVal3.equals(strVal3);
}
}
return false;
}
}

———-

6.15 Label.java

— Label.java —

\getchunk{France Telecom Copyright}

186 CHAPTER 6. JVM/CLOJURE/ASM/

package clojure.asm;

/**
* A label represents a position in the bytecode of a method. Labels
* are used for jump, goto, and switch instructions, and for try
* catch blocks.
*
* @author Eric Bruneton
*/
public class Label{

/**
* Indicates if this label is only used for debug attributes. Such a
* label is not the start of a basic block, the target of a jump
* instruction, or an exception handler. It can be safely ignored
* in control flow graph analysis algorithms (for optimization
* purposes).
*/
final static int DEBUG = 1;

/**
* Indicates if the position of this label is known.
*/
final static int RESOLVED = 2;

/**
* Indicates if this label has been updated, after instruction resizing.
*/
final static int RESIZED = 4;

/**
* Indicates if this basic block has been pushed in the basic block
* stack. See {@link MethodWriter#visitMaxs visitMaxs}.
*/
final static int PUSHED = 8;

/**
* Indicates if this label is the target of a jump instruction, or
* the start of an exception handler.
*/
final static int TARGET = 16;

/**
* Indicates if a stack map frame must be stored for this label.
*/
final static int STORE = 32;

/**
* Indicates if this label corresponds to a reachable basic block.
*/
6.15. LABEL.JAVA 187

final static int REACHABLE = 64;

/**
* Indicates if this basic block ends with a JSR instruction.
*/
final static int JSR = 128;

/**
* Indicates if this basic block ends with a RET instruction.
*/
final static int RET = 256;

/**
* Field used to associate user information to a label.
*/
public Object info;

/**
* Flags that indicate the status of this label.
*
* @see #DEBUG
* @see #RESOLVED
* @see #RESIZED
* @see #PUSHED
* @see #TARGET
* @see #STORE
* @see #REACHABLE
* @see #JSR
* @see #RET
*/
int status;

/**
* The line number corresponding to this label, if known.
*/
int line;

/**
* The position of this label in the code, if known.
*/
int position;

/**
* Number of forward references to this label, times two.
*/
private int referenceCount;

/**
* Informations about forward references. Each forward reference is
* described by two consecutive integers in this array: the first one
188 CHAPTER 6. JVM/CLOJURE/ASM/

* is the position of the first byte of the bytecode instruction that

* contains the forward reference, while the second is the position
* of the first byte of the forward reference itself. In fact the
* sign of the first integer indicates if this reference uses 2 or 4
* bytes, and its absolute value gives the position of the bytecode
* instruction.
*/
private int[] srcAndRefPositions;

// -------------------------------------------------------------------

/*
* Fields for the control flow and data flow graph analysis algorithms
* (used to compute the maximum stack size or the stack map frames).
* A control flow graph contains one node per "basic block", and one
* edge per "jump" from one basic block to another. Each node (i.e.,
* each basic block) is represented by the Label object that
* corresponds to the first instruction of this basic block. Each node
* also stores the list of its successors in the graph, as a linked
* list of Edge objects.
*
* The control flow analysis algorithms used to compute the maximum
* stack size or the stack map frames are similar and use two steps.
* The first step, during the visit of each instruction, builds
* information about the state of the local variables and the operand
* stack at the end of each basic block, called the "output frame",
* relatively to the frame state at the beginning of the basic
* block, which is called the "input frame", and which is unknown
* during this step. The second step, in
* {@link MethodWriter#visitMaxs}, is a fix point algorithm that
* icomputes information about the input frame of each basic block,
* from the nput state of the first basic block (known from the
* method signature), and by the using the previously computed
* relative output frames.
*
* The algorithm used to compute the maximum stack size only computes
* the relative output and absolute input stack heights, while the
* algorithm used to compute stack map frames computes relative
* output frames and absolute input frames.
*/

/**
* Start of the output stack relatively to the input stack. The exact
* semantics of this field depends on the algorithm that is used.
* 
* When only the maximum stack size is computed, this field is the
* number of elements in the input stack.
* 
* When the stack map frames are completely computed, this field is
* the offset of the first output stack element relatively to the top
6.15. LABEL.JAVA 189

* of the input stack. This offset is always negative or null. A

* null offset means that the output stack must be appended to the
* input stack. A -n offset means that the first n output stack
* elements must replace the top n input stack elements, and that
* the other elements must be appended to the input stack.
*/
int inputStackTop;

/**
* Maximum height reached by the output stack, relatively to the top
* of the input stack. This maximum is always positive or null.
*/
int outputStackMax;

/**
* Information about the input and output stack map frames of this
* basic block. This field is only used when
* {@link ClassWriter#COMPUTE_FRAMES} option is used.
*/
Frame frame;

/**
* The successor of this label, in the order they are visited. This
* linked list does not include labels used for debug info only. If
* {@link ClassWriter#COMPUTE_FRAMES} option is used then, in addition,
* it does not contain successive labels that denote the same
* bytecode position (in this case only the first label appears in
* this list).
*/
Label successor;

/**
* The successors of this node in the control flow graph. These
* successors are stored in a linked list of {@link Edge Edge}
* objects, linked to each other by their {@link Edge#next} field.
*/
Edge successors;

/**
* The next basic block in the basic block stack. This stack is used
* in the main loop of the fix point algorithm used in the second step
* of the control flow analysis algorithms.
*
* @see MethodWriter#visitMaxs
*/
Label next;

// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------
190 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Constructs a new label.
*/
public Label(){
}

/**
* Constructs a new label.
*
* @param debug if this label is only used for debug attributes.
*/
Label(final boolean debug){
this.status = debug ? DEBUG : 0;
}

// -------------------------------------------------------------------
// Methods to compute offsets and to manage forward references
// -------------------------------------------------------------------

/**
* Returns the offset corresponding to this label. This offset is
* computed from the start of the method’s bytecode. This method
* is intended for {@link Attribute} sub classes, and is normally
* not needed by class generators or adapters.
*
* @return the offset corresponding to this label.
* @throws IllegalStateException if this label is not resolved yet.
*/
public int getOffset(){
if((status & RESOLVED) == 0)
{
throw new IllegalStateException(
"Label offset position has not been resolved yet");
}
return position;
}

/**
* Puts a reference to this label in the bytecode of a method. If the
* position of the label is known, the offset is computed and written
* directly. Otherwise, a null offset is written and a new forward
* reference is declared for this label.
*
* @param owner the code writer that calls this method.
* @param out the bytecode of the method.
* @param source the position of first byte of the bytecode
* instruction that contains this label.
* @param wideOffset <tt>true</tt> if the reference must be stored in 4
* bytes, or <tt>false</tt> if it must be stored with 2
6.15. LABEL.JAVA 191

* bytes.
* @throws IllegalArgumentException if this label has not been created by
* the given code writer.
*/
void put(
final MethodWriter owner,
final ByteVector out,
final int source,
final boolean wideOffset){
if((status & RESOLVED) != 0)
{
if(wideOffset)
{
out.putInt(position - source);
}
else
{
out.putShort(position - source);
}
}
else
{
if(wideOffset)
{
addReference(-1 - source, out.length);
out.putInt(-1);
}
else
{
addReference(source, out.length);
out.putShort(-1);
}
}
}

/**
* Adds a forward reference to this label. This method must be called
* only for a true forward reference, i.e. only if this label is not
* resolved yet. For backward references, the offset of the reference
* can be, and must be, computed and stored directly.
*
* @param sourcePosition the position of the referencing instruction.
* This position will be used to compute the
* offset of this forward reference.
* @param referencePosition the position where the offset for this
* forward reference must be stored.
*/
private void addReference(
final int sourcePosition,
final int referencePosition){
192 CHAPTER 6. JVM/CLOJURE/ASM/

if(srcAndRefPositions == null)
{
srcAndRefPositions = new int[6];
}
if(referenceCount >= srcAndRefPositions.length)
{
int[] a = new int[srcAndRefPositions.length + 6];
System.arraycopy(srcAndRefPositions,
0,
a,
0,
srcAndRefPositions.length);
srcAndRefPositions = a;
}
srcAndRefPositions[referenceCount++] = sourcePosition;
srcAndRefPositions[referenceCount++] = referencePosition;
}

/**
* Resolves all forward references to this label. This method must be
* called when this label is added to the bytecode of the method,
* i.e. when its position becomes known. This method fills in the
* blanks that where left in the bytecode by each forward reference
* previously added to this label.
*
* @param owner the code writer that calls this method.
* @param position the position of this label in the bytecode.
* @param data the bytecode of the method.
* @return <tt>true</tt> if a blank that was left for this label was
* to small to store the offset. In such a case the
* corresponding jump instruction is replaced with a pseudo
* instruction (using unused opcodes) using an unsigned two
* bytes offset. These pseudo instructions will need to be
* replaced with true instructions with wider offsets (4 bytes
* instead of 2). This is done in
* {@link MethodWriter#resizeInstructions}.
* @throws IllegalArgumentException if this label has already been
* resolved, or if it has not been
created by the given code writer.
*/
boolean resolve(
final MethodWriter owner,
final int position,
final byte[] data){
boolean needUpdate = false;
this.status |= RESOLVED;
this.position = position;
int i = 0;
while(i < referenceCount)
{
6.15. LABEL.JAVA 193

int source = srcAndRefPositions[i++];

int reference = srcAndRefPositions[i++];
int offset;
if(source >= 0)
{
offset = position - source;
if(offset < Short.MIN_VALUE || offset > Short.MAX_VALUE)
{
/*
* changes the opcode of the jump instruction, in order
* to be able to find it later (see resizeInstructions
* in MethodWriter). These temporary opcodes are similar
* to jump instruction opcodes, except that the 2 bytes
* offset is unsigned (and can therefore represent
* values from 0 to 65535, which is sufficient since
* the size of a method is limited to 65535 bytes).
*/
int opcode = data[reference - 1] & 0xFF;
if(opcode <= Opcodes.JSR)
{
// changes IFEQ ... JSR to opcodes 202 to 217
data[reference - 1] = (byte) (opcode + 49);
}
else
{
// changes IFNULL and IFNONNULL to opcodes 218
// and 219
data[reference - 1] = (byte) (opcode + 20);
}
needUpdate = true;
}
data[reference++] = (byte) (offset >>> 8);
data[reference] = (byte) offset;
}
else
{
offset = position + source + 1;
data[reference++] = (byte) (offset >>> 24);
data[reference++] = (byte) (offset >>> 16);
data[reference++] = (byte) (offset >>> 8);
data[reference] = (byte) offset;
}
}
return needUpdate;
}

/**
* Returns the first label of the series to which this label belongs.
* For an isolated label or for the first label in a series of
* successive labels, this method returns the label itself. For other
194 CHAPTER 6. JVM/CLOJURE/ASM/

* labels it returns the first label of the series.

*
* @return the first label of the series to which this label belongs.
*/
Label getFirst(){
return frame == null ? this : frame.owner;
}

// -------------------------------------------------------------------
// Overriden Object methods
// -------------------------------------------------------------------

/**
* Returns a string representation of this label.
*
* @return a string representation of this label.
*/
public String toString(){
return "L" + System.identityHashCode(this);
}
}

———-

6.16 MethodAdapter.java

— MethodAdapter.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* An empty {@link MethodVisitor} that delegates to another
* {@link MethodVisitor}. This class can be used as a super class to
* quickly implement usefull method adapter classes, just by overriding
* the necessary methods.
*
* @author Eric Bruneton
*/
public class MethodAdapter implements MethodVisitor{

/**
* The {@link MethodVisitor} to which this adapter delegates calls.
*/
protected MethodVisitor mv;

/**
6.16. METHODADAPTER.JAVA 195

* Constructs a new {@link MethodAdapter} object.

*
* @param mv the code visitor to which this adapter must delegate calls.
*/
public MethodAdapter(final MethodVisitor mv){
this.mv = mv;
}

public AnnotationVisitor visitAnnotationDefault(){

return mv.visitAnnotationDefault();
}

public AnnotationVisitor visitAnnotation(

final String desc,
final boolean visible){
return mv.visitAnnotation(desc, visible);
}

public AnnotationVisitor visitParameterAnnotation(

final int parameter,
final String desc,
final boolean visible){
return mv.visitParameterAnnotation(parameter, desc, visible);
}

public void visitAttribute(final Attribute attr){

mv.visitAttribute(attr);
}

public void visitCode(){

mv.visitCode();
}

public void visitFrame(

final int type,
final int nLocal,
final Object[] local,
final int nStack,
final Object[] stack){
mv.visitFrame(type, nLocal, local, nStack, stack);
}

public void visitInsn(final int opcode){

mv.visitInsn(opcode);
}

public void visitIntInsn(final int opcode, final int operand){

mv.visitIntInsn(opcode, operand);
}
196 CHAPTER 6. JVM/CLOJURE/ASM/

public void visitVarInsn(final int opcode, final int var){

mv.visitVarInsn(opcode, var);
}

public void visitTypeInsn(final int opcode, final String desc){

mv.visitTypeInsn(opcode, desc);
}

public void visitFieldInsn(

final int opcode,
final String owner,
final String name,
final String desc){
mv.visitFieldInsn(opcode, owner, name, desc);
}

public void visitMethodInsn(

final int opcode,
final String owner,
final String name,
final String desc){
mv.visitMethodInsn(opcode, owner, name, desc);
}

public void visitJumpInsn(final int opcode, final Label label){

mv.visitJumpInsn(opcode, label);
}

public void visitLabel(final Label label){

mv.visitLabel(label);
}

public void visitLdcInsn(final Object cst){

mv.visitLdcInsn(cst);
}

public void visitIincInsn(final int var, final int increment){

mv.visitIincInsn(var, increment);
}

public void visitTableSwitchInsn(

final int min,
final int max,
final Label dflt,
final Label labels[]){
mv.visitTableSwitchInsn(min, max, dflt, labels);
}

public void visitLookupSwitchInsn(

final Label dflt,
6.17. METHODVISITOR.JAVA 197

final int keys[],

final Label labels[]){
mv.visitLookupSwitchInsn(dflt, keys, labels);
}

public void visitMultiANewArrayInsn(final String desc, final int dims){

mv.visitMultiANewArrayInsn(desc, dims);
}

public void visitTryCatchBlock(

final Label start,
final Label end,
final Label handler,
final String type){
mv.visitTryCatchBlock(start, end, handler, type);
}

public void visitLocalVariable(

final String name,
final String desc,
final String signature,
final Label start,
final Label end,
final int index){
mv.visitLocalVariable(name, desc, signature, start, end, index);
}

public void visitLineNumber(final int line, final Label start){

mv.visitLineNumber(line, start);
}

public void visitMaxs(final int maxStack, final int maxLocals){

mv.visitMaxs(maxStack, maxLocals);
}

public void visitEnd(){

mv.visitEnd();
}
}

———-

6.17 MethodVisitor.java

— MethodVisitor.java —

\getchunk{France Telecom Copyright}

198 CHAPTER 6. JVM/CLOJURE/ASM/

package clojure.asm;

/**
* A visitor to visit a Java method. The methods of this interface must
* be called in the following order:
* [ <tt>visitAnnotationDefault</tt> ] ( * <tt>visitAnnotation</tt> |
* <tt>visitParameterAnnotation</tt> | * <tt>visitAttribute</tt> )*
* [ <tt>visitCode</tt> ( <tt>visitFrame</tt> |
* <tt>visit</tt>XInsn</tt> | <tt>visitLabel</tt> |
* <tt>visitTryCatchBlock</tt> | * <tt>visitLocalVariable</tt> |
* <tt>visitLineNumber</tt>)* <tt>visitMaxs</tt> ]
* <tt>visitEnd</tt>. In addition, the <tt>visit</tt>XInsn</tt>
* and <tt>visitLabel</tt> methods must be called in the sequential
* order of the bytecode instructions of the visited code,
* <tt>visitTryCatchBlock</tt> must be called before the
* labels passed as arguments have been visited, and the
* <tt>visitLocalVariable</tt> and <tt>visitLineNumber</tt> methods
* must be called after the labels passed as arguments have
* been visited.
*
* @author Eric Bruneton
*/
public interface MethodVisitor{

// --------------------------------------------------------------------
// Annotations and non standard attributes
// --------------------------------------------------------------------

/**
* Visits the default value of this annotation interface method.
*
* @return a visitor to the visit the actual default value of this
* annotation interface method, or <tt>null</tt> if this
* visitor is not interested in visiting this default value.
* The ’name’ parameters passed to the methods of this
* annotation visitor are ignored. Moreover, exacly one visit
* method must be called on this annotation visitor, followed
* by visitEnd.
*/
AnnotationVisitor visitAnnotationDefault();

/**
* Visits an annotation of this method.
*
* @param desc the class descriptor of the annotation class.
* @param visible <tt>true</tt> if the annotation is visible at runtime.
* @return a visitor to visit the annotation values, or <tt>null</tt> if
* this visitor is not interested in visiting this annotation.
*/
AnnotationVisitor visitAnnotation(String desc, boolean visible);
6.17. METHODVISITOR.JAVA 199

/**
* Visits an annotation of a parameter this method.
*
* @param parameter the parameter index.
* @param desc the class descriptor of the annotation class.
* @param visible <tt>true</tt> if the annotation is visible at
* runtime.
* @return a visitor to visit the annotation values, or <tt>null</tt>
* if this visitor is not interested in visiting this annotation.
*/
AnnotationVisitor visitParameterAnnotation(
int parameter,
String desc,
boolean visible);

/**
* Visits a non standard attribute of this method.
*
* @param attr an attribute.
*/
void visitAttribute(Attribute attr);

/**
* Starts the visit of the method’s code, if any (i.e. non abstract
* method).
*/
void visitCode();

/**
* Visits the current state of the local variables and operand stack
* elements. This method must(*) be called just before any
* instruction i that follows an unconditionnal branch
* instruction such as GOTO or THROW, that is the target of a jump
* instruction, or that starts an exception handler block. The visited
* types must describe the values of the local variables and of the
* operand stack elements just before i is executed.
* (*) this is mandatory only for classes whose version
* is greater than or equal to {@link Opcodes#V1_6 V1_6}. 
* Packed frames are basically "deltas" from the state of the
* previous frame (very first frame is implicitly defined by the
* method’s parameters and access flags): <ul> <li>
* {@link Opcodes#F_SAME} representing frame with exactly the same
* locals as the previous frame and with the empty stack.</li>
* <li>{@link Opcodes#F_SAME1}
* representing frame with exactly the same locals as the previous
* frame and with single value on the stack (<code>nStack</code> is 1
* and <code>stack[0]</code> contains value for the type of the
* stack item).</li> <li>{@link Opcodes#F_APPEND} representing frame
* with current locals are the same as the locals in the previous
200 CHAPTER 6. JVM/CLOJURE/ASM/

* frame, except that additional locals are defined

* (<code>nLocal</code> is 1, 2 or 3 and * <code>local</code> elements
* contains values representing added types).</li>
* <li>{@link Opcodes#F_CHOP} representing frame with current locals
* are the same as the locals in the previous frame, except that the
* last 1-3 locals are absent and with the empty stack
* (<code>nLocals</code> is 1, 2 or 3). </li> <li>
* {@link Opcodes#F_FULL} representing complete frame
* data.</li> </li> </ul>
*
* @param type the type of this stack map frame. Must be
* {@link Opcodes#F_NEW} for expanded frames, or
* {@link Opcodes#F_FULL}, {@link Opcodes#F_APPEND},
* {@link Opcodes#F_CHOP}, {@link Opcodes#F_SAME} or
* {@link Opcodes#F_APPEND}, {@link Opcodes#F_SAME1}
* for compressed frames.
* @param nLocal the number of local variables in the visited frame.
* @param local the local variable types in this frame. This array must
* not be modified. Primitive types are represented by
* {@link Opcodes#TOP}, {@link Opcodes#INTEGER},
* {@link Opcodes#FLOAT}, {@link Opcodes#LONG},
* {@link Opcodes#DOUBLE},{@link Opcodes#NULL} or
* {@link Opcodes#UNINITIALIZED_THIS} (long and double are
* represented by a single element). Reference types are
* represented by String objects (representing internal
* names, or type descriptors for array types), and
* uninitialized types by Label objects (this label
* designates the NEW instruction that created this
* uninitialized value).
* @param nStack the number of operand stack elements in the visited
* frame.
* @param stack the operand stack types in this frame. This array must
* not be modified. Its content has the same format as
* the "local" array.
*/
void visitFrame(
int type,
int nLocal,
Object[] local,
int nStack,
Object[] stack);

// --------------------------------------------------------------------
// Normal instructions
// --------------------------------------------------------------------

/**
* Visits a zero operand instruction.
*
* @param opcode the opcode of the instruction to be visited. This
6.17. METHODVISITOR.JAVA 201

* opcode is either NOP, ACONST_NULL, ICONST_M1, ICONST_0,

* ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5,
* LCONST_0, LCONST_1, FCONST_0, FCONST_1, FCONST_2,
* DCONST_0, DCONST_1, IALOAD, LALOAD, FALOAD,
* DALOAD, AALOAD, BALOAD, CALOAD, SALOAD, IASTORE,
* LASTORE, FASTORE, DASTORE, AASTORE, BASTORE, CASTORE,
* SASTORE, POP, POP2, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1,
* DUP2_X2, SWAP, IADD, LADD, FADD, DADD, ISUB, LSUB, FSUB,
* DSUB, IMUL, LMUL, FMUL, DMUL, IDIV, LDIV, FDIV, DDIV,
* IREM, LREM, FREM, DREM, INEG, LNEG, FNEG, DNEG, ISHL,
* LSHL, ISHR, LSHR, IUSHR, LUSHR, IAND, LAND, IOR, LOR,
* IXOR, LXOR, I2L, I2F, I2D, L2I, L2F, L2D, F2I, F2L,
* F2D, D2I, D2L, D2F, I2B, I2C, I2S, LCMP, FCMPL, FCMPG,
* DCMPL, DCMPG, IRETURN, LRETURN, FRETURN, DRETURN,
* ARETURN, RETURN, ARRAYLENGTH, ATHROW, MONITORENTER,
* or MONITOREXIT.
*/
void visitInsn(int opcode);

/**
* Visits an instruction with a single int operand.
*
* @param opcode the opcode of the instruction to be visited. This
* opcode is either BIPUSH, SIPUSH or NEWARRAY.
* @param operand the operand of the instruction to be visited. When
* opcode is BIPUSH, operand value should be between
* Byte.MIN_VALUE and Byte.MAX_VALUE. When opcode
* is SIPUSH, operand value should be between
* Short.MIN_VALUE and Short.MAX_VALUE. When opcode
* is NEWARRAY, operand value should be one of
* {@link Opcodes#T_BOOLEAN}, {@link Opcodes#T_CHAR},
* {@link Opcodes#T_FLOAT}, {@link Opcodes#T_DOUBLE},
* {@link Opcodes#T_BYTE}, {@link Opcodes#T_SHORT},
* {@link Opcodes#T_INT} or {@link Opcodes#T_LONG}.
*/
void visitIntInsn(int opcode, int operand);

/**
* Visits a local variable instruction. A local variable instruction is
* an instruction that loads or stores the value of a local variable.
*
* @param opcode the opcode of the local variable instruction to be
* visited. This opcode is either ILOAD, LLOAD, FLOAD,
* DLOAD, ALOAD, ISTORE, LSTORE, FSTORE, DSTORE, ASTORE
* or RET.
* @param var the operand of the instruction to be visited. This
* operand is the index of a local variable.
*/
void visitVarInsn(int opcode, int var);
202 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Visits a type instruction. A type instruction is an instruction that
* takes a type descriptor as parameter.
*
* @param opcode the opcode of the type instruction to be visited.
* This opcode is either NEW, ANEWARRAY, CHECKCAST or
* INSTANCEOF.
* @param desc the operand of the instruction to be visited. This
* operand is must be a fully qualified class name in
* internal form, or the type descriptor of an array
* type (see {@link Type Type}).
*/
void visitTypeInsn(int opcode, String desc);

/**
* Visits a field instruction. A field instruction is an instruction
* that loads or stores the value of a field of an object.
*
* @param opcode the opcode of the type instruction to be visited.
* This opcode is either GETSTATIC, PUTSTATIC, GETFIELD
* or PUTFIELD.
* @param owner the internal name of the field’s owner class (see {@link
* Type#getInternalName() getInternalName}).
* @param name the field’s name.
* @param desc the field’s descriptor (see {@link Type Type}).
*/
void visitFieldInsn(int opcode, String owner, String name, String desc);

/**
* Visits a method instruction. A method instruction is an instruction
* that invokes a method.
*
* @param opcode the opcode of the type instruction to be visited.
* This opcode is either INVOKEVIRTUAL, INVOKESPECIAL,
* INVOKESTATIC or INVOKEINTERFACE.
* @param owner the internal name of the method’s owner class (see
* {@link Type#getInternalName() getInternalName}).
* @param name the method’s name.
* @param desc the method’s descriptor (see {@link Type Type}).
*/
void visitMethodInsn(int opcode, String owner, String name, String desc);

/**
* Visits a jump instruction. A jump instruction is an instruction that
* may jump to another instruction.
*
* @param opcode the opcode of the type instruction to be visited. This
* opcode is either IFEQ, IFNE, IFLT, IFGE, IFGT, IFLE,
* IF_ICMPEQ, IF_ICMPNE, IF_ICMPLT, IF_ICMPGE, IF_ICMPGT,
* IF_ICMPLE, IF_ACMPEQ, IF_ACMPNE, GOTO, JSR, IFNULL or
6.17. METHODVISITOR.JAVA 203

* IFNONNULL.
* @param label the operand of the instruction to be visited. This
* operand is a label that designates the instruction
* to which the jump instruction may jump.
*/
void visitJumpInsn(int opcode, Label label);

/**
* Visits a label. A label designates the instruction that will be
* visited just after it.
*
* @param label a {@link Label Label} object.
*/
void visitLabel(Label label);

// --------------------------------------------------------------------
// Special instructions
// --------------------------------------------------------------------

/**
* Visits a LDC instruction.
*
* @param cst the constant to be loaded on the stack. This parameter
* must be a non null {@link Integer}, a {@link Float},
* a {@link Long}, a {@link Double} a {@link String} (or
* a {@link Type} for <tt>.class</tt> constants, for classes
* whose version is 49.0 or more).
*/
void visitLdcInsn(Object cst);

/**
* Visits an IINC instruction.
*
* @param var index of the local variable to be incremented.
* @param increment amount to increment the local variable by.
*/
void visitIincInsn(int var, int increment);

/**
* Visits a TABLESWITCH instruction.
*
* @param min the minimum key value.
* @param max the maximum key value.
* @param dflt beginning of the default handler block.
* @param labels beginnings of the handler blocks. <tt>labels[i]</tt>
* is the beginning of the handler block for the
* <tt>min + i</tt> key.
*/
void visitTableSwitchInsn(int min, int max, Label dflt, Label labels[]);
204 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Visits a LOOKUPSWITCH instruction.
*
* @param dflt beginning of the default handler block.
* @param keys the values of the keys.
* @param labels beginnings of the handler blocks. <tt>labels[i]</tt>
* is the beginning of the handler block for the
* <tt>keys[i]</tt> key.
*/
void visitLookupSwitchInsn(Label dflt, int keys[], Label labels[]);

/**
* Visits a MULTIANEWARRAY instruction.
*
* @param desc an array type descriptor (see {@link Type Type}).
* @param dims number of dimensions of the array to allocate.
*/
void visitMultiANewArrayInsn(String desc, int dims);

// ---------------------------------------------------------------
// Exceptions table entries, debug information, max stack and max
// locals
// ---------------------------------------------------------------

/**
* Visits a try catch block.
*
* @param start beginning of the exception handler’s scope (inclusive).
* @param end end of the exception handler’s scope (exclusive).
* @param handler beginning of the exception handler’s code.
* @param type internal name of the type of exceptions handled by the
* handler, or <tt>null</tt> to catch any exceptions
* (for "finally" blocks).
* @throws IllegalArgumentException if one of the labels has already
* been visited by this visitor (by the
* {@link #visitLabel visitLabel} method).
*/
void visitTryCatchBlock(Label start,
Label end,
Label handler,
String type);

/**
* Visits a local variable declaration.
*
* @param name the name of a local variable.
* @param desc the type descriptor of this local variable.
* @param signature the type signature of this local variable. May be
* <tt>null</tt> if the local variable type does not
* use generic types.
6.17. METHODVISITOR.JAVA 205

* @param start the first instruction corresponding to the scope of

* this local variable (inclusive).
* @param end the last instruction corresponding to the scope of
* this local variable (exclusive).
* @param index the local variable’s index.
* @throws IllegalArgumentException if one of the labels has not already
* been visited by this visitor (by the
* {@link #visitLabel visitLabel} method).
*/
void visitLocalVariable(
String name,
String desc,
String signature,
Label start,
Label end,
int index);

/**
* Visits a line number declaration.
*
* @param line a line number. This number refers to the source file
* from which the class was compiled.
* @param start the first instruction corresponding to this line number.
* @throws IllegalArgumentException if <tt>start</tt> has not already
* been visited by this visitor (by the
* {@link #visitLabel visitLabel} method).
*/
void visitLineNumber(int line, Label start);

/**
* Visits the maximum stack size and the maximum number of local
* variables of the method.
*
* @param maxStack maximum stack size of the method.
* @param maxLocals maximum number of local variables for the method.
*/
void visitMaxs(int maxStack, int maxLocals);

/**
* Visits the end of the method. This method, which is the last one to
* be called, is used to inform the visitor that all the annotations and
* attributes of the method have been visited.
*/
void visitEnd();
}

———-
206 CHAPTER 6. JVM/CLOJURE/ASM/

6.18 MethodWriter.java

— MethodWriter.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* A {@link MethodVisitor} that generates methods in bytecode form.
* Each visit method of this class appends the bytecode corresponding
* to the visited instruction to a byte vector, in the order these
* methods are called.
*
* @author Eric Bruneton
* @author Eugene Kuleshov
*/
class MethodWriter implements MethodVisitor{

/**
* Pseudo access flag used to denote constructors.
*/
final static int ACC_CONSTRUCTOR = 262144;

/**
* Frame has exactly the same locals as the previous stack map frame
* and number of stack items is zero.
*/
final static int SAME_FRAME = 0; // to 63 (0-3f)

/**
* Frame has exactly the same locals as the previous stack map frame
* and number of stack items is 1
*/
final static int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; // to 127 (40-7f)

/**
* Reserved for future use
*/
final static int RESERVED = 128;

/**
* Frame has exactly the same locals as the previous stack map frame
* and number of stack items is 1. Offset is bigger then 63;
*/
final static int SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247; // f7

/**
* Frame where current locals are the same as the locals in the previous
6.18. METHODWRITER.JAVA 207

* frame, except that the k last locals are absent. The value of k is
* given by the formula 251-frame_type.
*/
final static int CHOP_FRAME = 248; // to 250 (f8-fA)

/**
* Frame has exactly the same locals as the previous stack map frame
* and number of stack items is zero. Offset is bigger then 63;
*/
final static int SAME_FRAME_EXTENDED = 251; // fb

/**
* Frame where current locals are the same as the locals in the
* previous frame, except that k additional locals are defined.
* The value of k is given by the formula frame_type-251.
*/
final static int APPEND_FRAME = 252; // to 254 // fc-fe

/**
* Full frame
*/
final static int FULL_FRAME = 255; // ff

/**
* Indicates that the stack map frames must be recomputed from scratch.
* In this case the maximum stack size and number of local variables
* is also recomputed from scratch.
*
* @see #compute
*/
private final static int FRAMES = 0;

/**
* Indicates that the maximum stack size and number of local variables
* must be automatically computed.
*
* @see #compute
*/
private final static int MAXS = 1;

/**
* Indicates that nothing must be automatically computed.
*
* @see #compute
*/
private final static int NOTHING = 2;

/**
* Next method writer (see {@link ClassWriter#firstMethod firstMethod}).
*/
208 CHAPTER 6. JVM/CLOJURE/ASM/

MethodWriter next;

/**
* The class writer to which this method must be added.
*/
ClassWriter cw;

/**
* Access flags of this method.
*/
private int access;

/**
* The index of the constant pool item that contains the name of this
* method.
*/
private int name;

/**
* The index of the constant pool item that contains the descriptor
* of this method.
*/
private int desc;

/**
* The descriptor of this method.
*/
private String descriptor;

/**
* The signature of this method.
*/
String signature;

/**
* If not zero, indicates that the code of this method must be copied
* from the ClassReader associated to this writer in
* <code>cw.cr</code>. More precisely, this field gives the index of
* the first byte to copied from <code>cw.cr.b</code>.
*/
int classReaderOffset;

/**
* If not zero, indicates that the code of this method must be
* copied from the ClassReader associated to this writer in
* <code>cw.cr</code>. More precisely, this field gives the number
* of bytes to copied from <code>cw.cr.b</code>.
*/
int classReaderLength;
6.18. METHODWRITER.JAVA 209

/**
* Number of exceptions that can be thrown by this method.
*/
int exceptionCount;

/**
* The exceptions that can be thrown by this method. More precisely,
* this array contains the indexes of the constant pool items that
* contain the internal names of these exception classes.
*/
int[] exceptions;

/**
* The annotation default attribute of this method. May be
* <tt>null</tt>.
*/
private ByteVector annd;

/**
* The runtime visible annotations of this method. May be
* <tt>null</tt>.
*/
private AnnotationWriter anns;

/**
* The runtime invisible annotations of this method. May be
* <tt>null</tt>.
*/
private AnnotationWriter ianns;

/**
* The runtime visible parameter annotations of this method. May be
* <tt>null</tt>.
*/
private AnnotationWriter[] panns;

/**
* The runtime invisible parameter annotations of this method. May be
* <tt>null</tt>.
*/
private AnnotationWriter[] ipanns;

/**
* The non standard attributes of the method.
*/
private Attribute attrs;

/**
* The bytecode of this method.
*/
210 CHAPTER 6. JVM/CLOJURE/ASM/

private ByteVector code = new ByteVector();

/**
* Maximum stack size of this method.
*/
private int maxStack;

/**
* Maximum number of local variables for this method.
*/
private int maxLocals;

/**
* Number of stack map frames in the StackMapTable attribute.
*/
private int frameCount;

/**
* The StackMapTable attribute.
*/
private ByteVector stackMap;

/**
* The offset of the last frame that was written in the StackMapTable
* attribute.
*/
private int previousFrameOffset;

/**
* The last frame that was written in the StackMapTable attribute.
*
* @see #frame
*/
private int[] previousFrame;

/**
* Index of the next element to be added in {@link #frame}.
*/
private int frameIndex;

/**
* The current stack map frame. The first element contains the offset
* of the instruction to which the frame corresponds, the second
* element is the number of locals and the third one is the number
* of stack elements. The local variables start at index 3 and are
* followed by the operand stack values. In summary frame[0] = offset,
* frame[1] = nLocal, frame[2] = nStack, frame[3] = nLocal. All types
* are encoded as integers, with the same format as the one used in
* {@link Label}, but limited to BASE types.
*/
6.18. METHODWRITER.JAVA 211

private int[] frame;

/**
* Number of elements in the exception handler list.
*/
private int handlerCount;

/**
* The first element in the exception handler list.
*/
private Handler firstHandler;

/**
* The last element in the exception handler list.
*/
private Handler lastHandler;

/**
* Number of entries in the LocalVariableTable attribute.
*/
private int localVarCount;

/**
* The LocalVariableTable attribute.
*/
private ByteVector localVar;

/**
* Number of entries in the LocalVariableTypeTable attribute.
*/
private int localVarTypeCount;

/**
* The LocalVariableTypeTable attribute.
*/
private ByteVector localVarType;

/**
* Number of entries in the LineNumberTable attribute.
*/
private int lineNumberCount;

/**
* The LineNumberTable attribute.
*/
private ByteVector lineNumber;

/**
* The non standard attributes of the method’s code.
*/
212 CHAPTER 6. JVM/CLOJURE/ASM/

private Attribute cattrs;

/**
* Indicates if some jump instructions are too small and need to be
* resized.
*/
private boolean resize;

/**
* Indicates if the instructions contain at least one JSR instruction.
*/
private boolean jsr;

// -------------------------------------------------------------------

/*
* Fields for the control flow graph analysis algorithm (used to
* compute the maximum stack size). A control flow graph contains
* one node per "basic block", and one edge per "jump" from one basic
* block to another. Each node (i.e., each basic block) is represented
* by the Label object that corresponds to the first instruction of
* this basic block. Each node also stores the list of its successors
* in the graph, as a linked list of Edge objects.
*/

/**
* Indicates what must be automatically computed.
*
* @see FRAMES
* @see MAXS
* @see NOTHING
*/
private int compute;

/**
* A list of labels. This list is the list of basic blocks in the
* method, i.e. a list of Label objects linked to each other by their
* {@link Label#successor} field, in the order they are visited by
* {@link visitLabel}, and starting with the first basic block.
*/
private Label labels;

/**
* The previous basic block.
*/
private Label previousBlock;

/**
* The current basic block.
*/
6.18. METHODWRITER.JAVA 213

private Label currentBlock;

/**
* The (relative) stack size after the last visited instruction. This
* size is relative to the beginning of the current basic block, i.e.,
* the true stack size after the last visited instruction is equal to
* the {@link Label#inputStackTop beginStackSize} of the current basic
* block plus <tt>stackSize</tt>.
*/
private int stackSize;

/**
* The (relative) maximum stack size after the last visited instruction.
* This size is relative to the beginning of the current basic block,
* i.e., the true maximum stack size after the last visited instruction
* is equal to the {@link Label#inputStackTop beginStackSize} of the
* current basic block plus <tt>stackSize</tt>.
*/
private int maxStackSize;

// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------

/**
* Constructs a new {@link MethodWriter}.
*
* @param cw the class writer in which the method must be
* added.
* @param access the method’s access flags (see {@link Opcodes}).
* @param name the method’s name.
* @param desc the method’s descriptor (see {@link Type}).
* @param signature the method’s signature. May be <tt>null</tt>.
* @param exceptions the internal names of the method’s exceptions.
* May be <tt>null</tt>.
* @param computeMaxs <tt>true</tt> if the maximum stack size and
* number of local variables must be automatically
* computed.
* @param computeFrames <tt>true</tt> if the stack map tables must be
* recomputed from scratch.
*/
MethodWriter(
final ClassWriter cw,
final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions,
final boolean computeMaxs,
final boolean computeFrames){
214 CHAPTER 6. JVM/CLOJURE/ASM/

if(cw.firstMethod == null)
{
cw.firstMethod = this;
}
else
{
cw.lastMethod.next = this;
}
cw.lastMethod = this;
this.cw = cw;
this.access = access;
this.name = cw.newUTF8(name);
this.desc = cw.newUTF8(desc);
this.descriptor = desc;
this.signature = signature;
if(exceptions != null && exceptions.length > 0)
{
exceptionCount = exceptions.length;
this.exceptions = new int[exceptionCount];
for(int i = 0; i < exceptionCount; ++i)
{
this.exceptions[i] = cw.newClass(exceptions[i]);
}
}
this.compute =
computeFrames ? FRAMES : (computeMaxs ? MAXS : NOTHING);
if(computeMaxs || computeFrames)
{
if(computeFrames && name.equals("<init>"))
{
this.access |= ACC_CONSTRUCTOR;
}
// updates maxLocals
int size = getArgumentsAndReturnSizes(descriptor) >> 2;
if((access & Opcodes.ACC_STATIC) != 0)
{
--size;
}
maxLocals = size;
// creates and visits the label for the first basic block
labels = new Label();
labels.status |= Label.PUSHED;
visitLabel(labels);
}
}

// -------------------------------------------------------------------
// Implementation of the MethodVisitor interface
// -------------------------------------------------------------------
6.18. METHODWRITER.JAVA 215

public AnnotationVisitor visitAnnotationDefault(){

annd = new ByteVector();
return new AnnotationWriter(cw, false, annd, null, 0);
}

public AnnotationVisitor visitAnnotation(

public AnnotationVisitor visitParameterAnnotation(

final int parameter,
final String desc,
final boolean visible){
ByteVector bv = new ByteVector();
// write type, and reserve space for values count
bv.putShort(cw.newUTF8(desc)).putShort(0);
AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
if(visible)
{
if(panns == null)
{
panns =
new AnnotationWriter[
Type.getArgumentTypes(descriptor).length];
}
aw.next = panns[parameter];
panns[parameter] = aw;
}
else
{
if(ipanns == null)
{
ipanns =
new AnnotationWriter[
216 CHAPTER 6. JVM/CLOJURE/ASM/

Type.getArgumentTypes(descriptor).length];
}
aw.next = ipanns[parameter];
ipanns[parameter] = aw;
}
return aw;
}

public void visitAttribute(final Attribute attr){

if(attr.isCodeAttribute())
{
attr.next = cattrs;
cattrs = attr;
}
else
{
attr.next = attrs;
attrs = attr;
}
}

public void visitCode(){

}

public void visitFrame(

final int type,
final int nLocal,
final Object[] local,
final int nStack,
final Object[] stack){
if(compute == FRAMES)
{
return;
}

if(type == Opcodes.F_NEW)
{
startFrame(code.length, nLocal, nStack);
for(int i = 0; i < nLocal; ++i)
{
if(local[i] instanceof String)
{
frame[frameIndex++] = Frame.OBJECT
| cw.addType((String) local[i]);
}
else if(local[i] instanceof Integer)
{
frame[frameIndex++] = ((Integer) local[i]).intValue();
}
else
6.18. METHODWRITER.JAVA 217

{
frame[frameIndex++] =
Frame.UNINITIALIZED
| cw.addUninitializedType("",
((Label) local[i]).position);
}
}
for(int i = 0; i < nStack; ++i)
{
if(stack[i] instanceof String)
{
frame[frameIndex++] = Frame.OBJECT
| cw.addType((String) stack[i]);
}
else if(stack[i] instanceof Integer)
{
frame[frameIndex++] = ((Integer) stack[i]).intValue();
}
else
{
frame[frameIndex++] =
Frame.UNINITIALIZED
| cw.addUninitializedType("",
((Label) stack[i]).position);
}
}
endFrame();
}
else
{
int delta;
if(stackMap == null)
{
stackMap = new ByteVector();
delta = code.length;
}
else
{
delta = code.length - previousFrameOffset - 1;
}

switch(type)
{
case Opcodes.F_FULL:
stackMap.putByte(FULL_FRAME)
.putShort(delta)
.putShort(nLocal);
for(int i = 0; i < nLocal; ++i)
{
writeFrameType(local[i]);
218 CHAPTER 6. JVM/CLOJURE/ASM/

}
stackMap.putShort(nStack);
for(int i = 0; i < nStack; ++i)
{
writeFrameType(stack[i]);
}
break;
case Opcodes.F_APPEND:
stackMap.putByte(SAME_FRAME_EXTENDED + nLocal)
.putShort(delta);
for(int i = 0; i < nLocal; ++i)
{
writeFrameType(local[i]);
}
break;
case Opcodes.F_CHOP:
stackMap.putByte(SAME_FRAME_EXTENDED - nLocal)
.putShort(delta);
break;
case Opcodes.F_SAME:
if(delta < 64)
{
stackMap.putByte(delta);
}
else
{
stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
}
break;
case Opcodes.F_SAME1:
if(delta < 64)
{
stackMap.putByte(
SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
}
else
{
stackMap.putByte(
SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
.putShort(delta);
}
writeFrameType(stack[0]);
break;
}

previousFrameOffset = code.length;
++frameCount;
}
}
6.18. METHODWRITER.JAVA 219

public void visitInsn(final int opcode){

// adds the instruction to the bytecode of the method
code.putByte(opcode);
// update currentBlock
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, 0, null, null);
}
else
{
// updates current and max stack sizes
int size = stackSize + Frame.SIZE[opcode];
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
// if opcode == ATHROW or xRETURN, ends current
// block (no successor)
if((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
|| opcode == Opcodes.ATHROW)
{
noSuccessor();
}
}
}

public void visitIntInsn(final int opcode, final int operand){

// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, operand, null, null);
}
else if(opcode != Opcodes.NEWARRAY)
{
// updates current and max stack sizes only for NEWARRAY
// (stack size variation = 0 for BIPUSH or SIPUSH)
int size = stackSize + 1;
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
220 CHAPTER 6. JVM/CLOJURE/ASM/

}
// adds the instruction to the bytecode of the method
if(opcode == Opcodes.SIPUSH)
{
code.put12(opcode, operand);
}
else
{ // BIPUSH or NEWARRAY
code.put11(opcode, operand);
}
}

public void visitVarInsn(final int opcode, final int var){

// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, var, null, null);
}
else
{
// updates current and max stack sizes
if(opcode == Opcodes.RET)
{
// no stack change, but end of current block
// (no successor)
currentBlock.status |= Label.RET;
// save ’stackSize’ here for future use
// (see {@link #findSubroutineSuccessors})
currentBlock.inputStackTop = stackSize;
noSuccessor();
}
else
{ // xLOAD or xSTORE
int size = stackSize + Frame.SIZE[opcode];
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
}
}
if(compute != NOTHING)
{
// updates max locals
int n;
if(opcode == Opcodes.LLOAD || opcode == Opcodes.DLOAD
|| opcode == Opcodes.LSTORE || opcode == Opcodes.DSTORE)
6.18. METHODWRITER.JAVA 221

{
n = var + 2;
}
else
{
n = var + 1;
}
if(n > maxLocals)
{
maxLocals = n;
}
}
// adds the instruction to the bytecode of the method
if(var < 4 && opcode != Opcodes.RET)
{
int opt;
if(opcode < Opcodes.ISTORE)
{
/* ILOAD_0 */
opt = 26 + ((opcode - Opcodes.ILOAD) << 2) + var;
}
else
{
/* ISTORE_0 */
opt = 59 + ((opcode - Opcodes.ISTORE) << 2) + var;
}
code.putByte(opt);
}
else if(var >= 256)
{
code.putByte(196 /* WIDE */).put12(opcode, var);
}
else
{
code.put11(opcode, var);
}
if(opcode >= Opcodes.ISTORE && compute == FRAMES && handlerCount > 0)
{
visitLabel(new Label());
}
}

public void visitTypeInsn(final int opcode, final String desc){

Item i = cw.newClassItem(desc);
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, code.length, cw, i);
222 CHAPTER 6. JVM/CLOJURE/ASM/

}
else if(opcode == Opcodes.NEW)
{
// updates current and max stack sizes only if opcode == NEW
// (no stack change for ANEWARRAY, CHECKCAST, INSTANCEOF)
int size = stackSize + 1;
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
}
// adds the instruction to the bytecode of the method
code.put12(opcode, i.index);
}

public void visitFieldInsn(

final int opcode,
final String owner,
final String name,
final String desc){
Item i = cw.newFieldItem(owner, name, desc);
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, 0, cw, i);
}
else
{
int size;
// computes the stack size variation
char c = desc.charAt(0);
switch(opcode)
{
case Opcodes.GETSTATIC:
size = stackSize + (c == ’D’ || c == ’J’ ? 2 : 1);
break;
case Opcodes.PUTSTATIC:
size = stackSize + (c == ’D’ || c == ’J’ ? -2 : -1);
break;
case Opcodes.GETFIELD:
size = stackSize + (c == ’D’ || c == ’J’ ? 1 : 0);
break;
// case Constants.PUTFIELD:
default:
size = stackSize + (c == ’D’ || c == ’J’ ? -3 : -2);
break;
6.18. METHODWRITER.JAVA 223

}
// updates current and max stack sizes
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
}
// adds the instruction to the bytecode of the method
code.put12(opcode, i.index);
}

public void visitMethodInsn(

final int opcode,
final String owner,
final String name,
final String desc){
boolean itf = opcode == Opcodes.INVOKEINTERFACE;
Item i = cw.newMethodItem(owner, name, desc, itf);
int argSize = i.intVal;
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, 0, cw, i);
}
else
{
/*
* computes the stack size variation. In order not to
* recompute several times this variation for the same
* Item, we use the intVal field of this item to store
* this variation, once it has been computed. More
* precisely this intVal field stores the sizes of the
* arguments and of the return value corresponding to desc.
*/
if(argSize == 0)
{
// the above sizes have not been computed yet,
// so we compute them...
argSize = getArgumentsAndReturnSizes(desc);
// ... and we save them in order
// not to recompute them in the future
i.intVal = argSize;
}
int size;
if(opcode == Opcodes.INVOKESTATIC)
{
224 CHAPTER 6. JVM/CLOJURE/ASM/

size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;

}
else
{
size = stackSize - (argSize >> 2) + (argSize & 0x03);
}
// updates current and max stack sizes
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
}
// adds the instruction to the bytecode of the method
if(itf)
{
if(argSize == 0)
{
argSize = getArgumentsAndReturnSizes(desc);
i.intVal = argSize;
}
code.put12(Opcodes.INVOKEINTERFACE, i.index)
.put11(argSize >> 2, 0);
}
else
{
code.put12(opcode, i.index);
}
}

public void visitJumpInsn(final int opcode, final Label label){

Label nextInsn = null;
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(opcode, 0, null, null);
// ’label’ is the target of a jump instruction
label.getFirst().status |= Label.TARGET;
// adds ’label’ as a successor of this basic block
addSuccessor(Edge.NORMAL, label);
if(opcode != Opcodes.GOTO)
{
// creates a Label for the next basic block
nextInsn = new Label();
}
}
else
6.18. METHODWRITER.JAVA 225

{
if(opcode == Opcodes.JSR)
{
jsr = true;
currentBlock.status |= Label.JSR;
addSuccessor(stackSize + 1, label);
// creates a Label for the next basic block
nextInsn = new Label();
/*
* note that, by construction in this method, a JSR block
* has at least two successors in the control flow graph:
* the first one leads the next instruction after the
* JSR, while the second one leads to the JSR target.
*/
}
else
{
// updates current stack size (max stack size unchanged
// because stack size variation always negative in this
// case)
stackSize += Frame.SIZE[opcode];
addSuccessor(stackSize, label);
}
}
}
// adds the instruction to the bytecode of the method
if((label.status & Label.RESOLVED) != 0
&& label.position - code.length < Short.MIN_VALUE)
{
/*
* case of a backward jump with an offset < -32768. In this case
* we automatically replace GOTO with GOTO_W, JSR with JSR_W
* and IFxxx <l> with IFNOTxxx <l’> GOTO_W <l>, where IFNOTxxx
* is the "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and
* where <l’> designates the instruction just after the GOTO_W.
*/
if(opcode == Opcodes.GOTO)
{
code.putByte(200); // GOTO_W
}
else if(opcode == Opcodes.JSR)
{
code.putByte(201); // JSR_W
}
else
{
// if the IF instruction is transformed into IFNOT GOTO_W the
// next instruction becomes the target of the IFNOT
// instruction
if(nextInsn != null)
226 CHAPTER 6. JVM/CLOJURE/ASM/

{
nextInsn.status |= Label.TARGET;
}
code.putByte(opcode <= 166
? ((opcode + 1) ^ 1) - 1
: opcode ^ 1);
code.putShort(8); // jump offset
code.putByte(200); // GOTO_W
}
label.put(this, code, code.length - 1, true);
}
else
{
/*
* case of a backward jump with an offset >= -32768, or of a
* forward jump with, of course, an unknown offset. In these
* cases we store the offset in 2 bytes (which will be
* increased in resizeInstructions, if needed).
*/
code.putByte(opcode);
label.put(this, code, code.length - 1, false);
}
if(currentBlock != null)
{
if(nextInsn != null)
{
// if the jump instruction is not a GOTO, the next
// instruction is also a successor of this instruction.
// Calling visitLabel adds the label of this next
// instruction as a successor of the current block,
// and starts a new basic block
visitLabel(nextInsn);
}
if(opcode == Opcodes.GOTO)
{
noSuccessor();
}
}
}

public void visitLabel(final Label label){

// resolves previous forward references to label, if any
resize |= label.resolve(this, code.length, code.data);
// updates currentBlock
if((label.status & Label.DEBUG) != 0)
{
return;
}
if(compute == FRAMES)
{
6.18. METHODWRITER.JAVA 227

if(currentBlock != null)
{
if(label.position == currentBlock.position)
{
// successive labels, do not start a new basic block
currentBlock.status |= (label.status & Label.TARGET);
label.frame = currentBlock.frame;
return;
}
// ends current block (with one new successor)
addSuccessor(Edge.NORMAL, label);
}
// begins a new current block
currentBlock = label;
if(label.frame == null)
{
label.frame = new Frame();
label.frame.owner = label;
}
// updates the basic block list
if(previousBlock != null)
{
if(label.position == previousBlock.position)
{
previousBlock.status |= (label.status & Label.TARGET);
label.frame = previousBlock.frame;
currentBlock = previousBlock;
return;
}
previousBlock.successor = label;
}
previousBlock = label;
}
else if(compute == MAXS)
{
if(currentBlock != null)
{
// ends current block (with one new successor)
currentBlock.outputStackMax = maxStackSize;
addSuccessor(stackSize, label);
}
// begins a new current block
currentBlock = label;
// resets the relative current and max stack sizes
stackSize = 0;
maxStackSize = 0;
// updates the basic block list
if(previousBlock != null)
{
previousBlock.successor = label;
228 CHAPTER 6. JVM/CLOJURE/ASM/

}
previousBlock = label;
}
}

public void visitLdcInsn(final Object cst){

Item i = cw.newConstItem(cst);
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(Opcodes.LDC, 0, cw, i);
}
else
{
int size;
// computes the stack size variation
if(i.type == ClassWriter.LONG ||
i.type == ClassWriter.DOUBLE)
{
size = stackSize + 2;
}
else
{
size = stackSize + 1;
}
// updates current and max stack sizes
if(size > maxStackSize)
{
maxStackSize = size;
}
stackSize = size;
}
}
// adds the instruction to the bytecode of the method
int index = i.index;
if(i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE)
{
code.put12(20 /* LDC2_W */, index);
}
else if(index >= 256)
{
code.put12(19 /* LDC_W */, index);
}
else
{
code.put11(Opcodes.LDC, index);
}
}
6.18. METHODWRITER.JAVA 229

public void visitIincInsn(final int var, final int increment){

if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame.execute(Opcodes.IINC, var, null, null);
}
}
if(compute != NOTHING)
{
// updates max locals
int n = var + 1;
if(n > maxLocals)
{
maxLocals = n;
}
}
// adds the instruction to the bytecode of the method
if((var > 255) || (increment > 127) || (increment < -128))
{
code.putByte(196 /* WIDE */)
.put12(Opcodes.IINC, var)
.putShort(increment);
}
else
{
code.putByte(Opcodes.IINC).put11(var, increment);
}
}

public void visitTableSwitchInsn(

final int min,
final int max,
final Label dflt,
final Label labels[]){
// adds the instruction to the bytecode of the method
int source = code.length;
code.putByte(Opcodes.TABLESWITCH);
code.length += (4 - code.length % 4) % 4;
dflt.put(this, code, source, true);
code.putInt(min).putInt(max);
for(int i = 0; i < labels.length; ++i)
{
labels[i].put(this, code, source, true);
}
// updates currentBlock
visitSwitchInsn(dflt, labels);
}
230 CHAPTER 6. JVM/CLOJURE/ASM/

public void visitLookupSwitchInsn(

final Label dflt,
final int keys[],
final Label labels[]){
// adds the instruction to the bytecode of the method
int source = code.length;
code.putByte(Opcodes.LOOKUPSWITCH);
code.length += (4 - code.length % 4) % 4;
dflt.put(this, code, source, true);
code.putInt(labels.length);
for(int i = 0; i < labels.length; ++i)
{
code.putInt(keys[i]);
labels[i].put(this, code, source, true);
}
// updates currentBlock
visitSwitchInsn(dflt, labels);
}

private void visitSwitchInsn(final Label dflt, final Label[] labels){

// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame
.execute(Opcodes.LOOKUPSWITCH, 0, null, null);
// adds current block successors
addSuccessor(Edge.NORMAL, dflt);
dflt.getFirst().status |= Label.TARGET;
for(int i = 0; i < labels.length; ++i)
{
addSuccessor(Edge.NORMAL, labels[i]);
labels[i].getFirst().status |= Label.TARGET;
}
}
else
{
// updates current stack size (max stack size unchanged)
--stackSize;
// adds current block successors
addSuccessor(stackSize, dflt);
for(int i = 0; i < labels.length; ++i)
{
addSuccessor(stackSize, labels[i]);
}
}
// ends current block
noSuccessor();
}
6.18. METHODWRITER.JAVA 231

public void visitMultiANewArrayInsn(final String desc, final int dims){

Item i = cw.newClassItem(desc);
// Label currentBlock = this.currentBlock;
if(currentBlock != null)
{
if(compute == FRAMES)
{
currentBlock.frame
.execute(Opcodes.MULTIANEWARRAY, dims, cw, i);
}
else
{
// updates current stack size (max stack size unchanged
// because stack size variation always negative or null)
stackSize += 1 - dims;
}
}
// adds the instruction to the bytecode of the method
code.put12(Opcodes.MULTIANEWARRAY, i.index).putByte(dims);
}

public void visitTryCatchBlock(

final Label start,
final Label end,
final Label handler,
final String type){
++handlerCount;
Handler h = new Handler();
h.start = start;
h.end = end;
h.handler = handler;
h.desc = type;
h.type = type != null ? cw.newClass(type) : 0;
if(lastHandler == null)
{
firstHandler = h;
}
else
{
lastHandler.next = h;
}
lastHandler = h;
}

public void visitLocalVariable(

final String name,
final String desc,
final String signature,
232 CHAPTER 6. JVM/CLOJURE/ASM/

final Label start,

final Label end,
final int index){
if(signature != null)
{
if(localVarType == null)
{
localVarType = new ByteVector();
}
++localVarTypeCount;
localVarType.putShort(start.position)
.putShort(end.position - start.position)
.putShort(cw.newUTF8(name))
.putShort(cw.newUTF8(signature))
.putShort(index);
}
if(localVar == null)
{
localVar = new ByteVector();
}
++localVarCount;
localVar.putShort(start.position)
.putShort(end.position - start.position)
.putShort(cw.newUTF8(name))
.putShort(cw.newUTF8(desc))
.putShort(index);
if(compute != NOTHING)
{
// updates max locals
char c = desc.charAt(0);
int n = index + (c == ’J’ || c == ’D’ ? 2 : 1);
if(n > maxLocals)
{
maxLocals = n;
}
}
}

public void visitLineNumber(final int line, final Label start){

if(lineNumber == null)
{
lineNumber = new ByteVector();
}
++lineNumberCount;
lineNumber.putShort(start.position);
lineNumber.putShort(line);
}

public void visitMaxs(final int maxStack, final int maxLocals){

if(compute == FRAMES)
6.18. METHODWRITER.JAVA 233

{
// completes the control flow graph with exception handler blocks
Handler handler = firstHandler;
while(handler != null)
{
Label l = handler.start.getFirst();
Label h = handler.handler.getFirst();
Label e = handler.end.getFirst();
// computes the kind of the edges to ’h’
String t = handler.desc == null
? "java/lang/Throwable"
: handler.desc;
int kind = Frame.OBJECT | cw.addType(t);
// h is an exception handler
h.status |= Label.TARGET;
// adds ’h’ as a successor of labels between ’start’
// and ’end’
while(l != e)
{
// creates an edge to ’h’
Edge b = new Edge();
b.info = kind;
b.successor = h;
// adds it to the successors of ’l’
b.next = l.successors;
l.successors = b;
// goes to the next label
l = l.successor;
}
handler = handler.next;
}

// creates and visits the first (implicit) frame

Frame f = labels.frame;
Type[] args = Type.getArgumentTypes(descriptor);
f.initInputFrame(cw, access, args, this.maxLocals);
visitFrame(f);

/*
* fix point algorithm: mark the first basic block as ’changed’
* (i.e. put it in the ’changed’ list) and, while there are
* changed basic blocks, choose one, mark it as unchanged,
* and update its successors (which can be changed in the
* process).
*/
int max = 0;
Label changed = labels;
while(changed != null)
{
// removes a basic block from the list of changed basic
234 CHAPTER 6. JVM/CLOJURE/ASM/

// blocks
Label l = changed;
changed = changed.next;
l.next = null;
f = l.frame;
// a reacheable jump target must be stored in the stack map
if((l.status & Label.TARGET) != 0)
{
l.status |= Label.STORE;
}
// all visited labels are reacheable, by definition
l.status |= Label.REACHABLE;
// updates the (absolute) maximum stack size
int blockMax = f.inputStack.length + l.outputStackMax;
if(blockMax > max)
{
max = blockMax;
}
// updates the successors of the current basic block
Edge e = l.successors;
while(e != null)
{
Label n = e.successor.getFirst();
boolean change = f.merge(cw, n.frame, e.info);
if(change && n.next == null)
{
// if n has changed and is not already in the
// ’changed’ list, adds it to this list
n.next = changed;
changed = n;
}
e = e.next;
}
}
this.maxStack = max;

// visits all the frames that must be stored in the stack map
Label l = labels;
while(l != null)
{
f = l.frame;
if((l.status & Label.STORE) != 0)
{
visitFrame(f);
}
if((l.status & Label.REACHABLE) == 0)
{
// finds start and end of dead basic block
Label k = l.successor;
int start = l.position;
6.18. METHODWRITER.JAVA 235

int end = (k == null ? code.length : k.position) - 1;

// if non empty basic block
if(end >= start)
{
// replaces instructions with NOP ... NOP ATHROW
for(int i = start; i < end; ++i)
{
code.data[i] = Opcodes.NOP;
}
code.data[end] = (byte) Opcodes.ATHROW;
// emits a frame for this unreachable block
startFrame(start, 0, 1);
frame[frameIndex++] =
Frame.OBJECT
| cw.addType("java/lang/Throwable");
endFrame();
}
}
l = l.successor;
}
}
else if(compute == MAXS)
{
// completes the control flow graph with exception handler blocks
Handler handler = firstHandler;
while(handler != null)
{
Label l = handler.start;
Label h = handler.handler;
Label e = handler.end;
// adds ’h’ as a successor of labels between ’start’
// and ’end’
while(l != e)
{
// creates an edge to ’h’
Edge b = new Edge();
b.info = Edge.EXCEPTION;
b.successor = h;
// adds it to the successors of ’l’
if((l.status & Label.JSR) != 0)
{
// if l is a JSR block, adds b after the first two
// edges to preserve the hypothesis about JSR block
// successors order (see {@link #visitJumpInsn})
b.next = l.successors.next.next;
l.successors.next.next = b;
}
else
{
b.next = l.successors;
236 CHAPTER 6. JVM/CLOJURE/ASM/

l.successors = b;
}
// goes to the next label
l = l.successor;
}
handler = handler.next;
}

if(jsr)
{
// completes the control flow graph with the RET successors
/*
* first step: finds the subroutines. This step determines,
* for each basic block, to which subroutine(s) it belongs,
* and stores this set as a bit set in the
* {@link Label#status} field. Subroutines are numbered
* with powers of two, from 0x1000 to 0x80000000 (so there
* must be at most 20 subroutines in a method).
*/
// finds the basic blocks that belong to the "main"
// subroutine
int id = 0x1000;
findSubroutine(labels, id);
// finds the basic blocks that belong to the real subroutines
Label l = labels;
while(l != null)
{
if((l.status & Label.JSR) != 0)
{
// the subroutine is defined by l’s TARGET, not by l
Label subroutine = l.successors.next.successor;
// if this subroutine does not have an id yet...
if((subroutine.status & ~0xFFF) == 0)
{
// ...assigns it a new id and finds its
// basic blocks
id = id << 1;
findSubroutine(subroutine, id);
}
}
l = l.successor;
}
// second step: finds the successors of RET blocks
findSubroutineSuccessors(0x1000, new Label[10], 0);
}

/*
* control flow analysis algorithm: while the block stack is not
* empty, pop a block from this stack, update the max stack size,
* compute the true (non relative) begin stack size of the
6.18. METHODWRITER.JAVA 237

* successors of this block, and push these successors onto the

* stack (unless they have already been pushed onto the stack).
* Note: by hypothesis, the {@link Label#inputStackTop} of the
* blocks in the block stack are the true (non relative)
* beginning stack sizes of these blocks.
*/
int max = 0;
Label stack = labels;
while(stack != null)
{
// pops a block from the stack
Label l = stack;
stack = stack.next;
// computes the true (non relative) max stack size of this
// block
int start = l.inputStackTop;
int blockMax = start + l.outputStackMax;
// updates the global max stack size
if(blockMax > max)
{
max = blockMax;
}
// analyses the successors of the block
Edge b = l.successors;
if((l.status & Label.JSR) != 0)
{
// ignores the first edge of JSR blocks
// (virtual successor)
b = b.next;
}
while(b != null)
{
l = b.successor;
// if this successor has not already been pushed...
if((l.status & Label.PUSHED) == 0)
{
// computes its true beginning stack size...
l.inputStackTop = b.info == Edge.EXCEPTION
? 1 : start + b.info;
// ...and pushes it onto the stack
l.status |= Label.PUSHED;
l.next = stack;
stack = l;
}
b = b.next;
}
}
this.maxStack = max;
}
else
238 CHAPTER 6. JVM/CLOJURE/ASM/

{
this.maxStack = maxStack;
this.maxLocals = maxLocals;
}
}

public void visitEnd(){

}

// -------------------------------------------------------------------
// Utility methods: control flow analysis algorithm
// -------------------------------------------------------------------

/**
* Computes the size of the arguments and of the return value of a
* method.
*
* @param desc the descriptor of a method.
* @return the size of the arguments of the method (plus one for the
* implicit this argument), argSize, and the size of its return
* value, retSize, packed into a single int i =
* <tt>(argSize << 2) | retSize</tt> (argSize is therefore equal
* to <tt>i >> 2</tt>, and retSize to <tt>i & 0x03</tt>).
*/
static int getArgumentsAndReturnSizes(final String desc){
int n = 1;
int c = 1;
while(true)
{
char car = desc.charAt(c++);
if(car == ’)’)
{
car = desc.charAt(c);
return n << 2
| (car == ’V’ ? 0 : (car == ’D’ || car == ’J’ ? 2 : 1));
}
else if(car == ’L’)
{
while(desc.charAt(c++) != ’;’)
{
}
n += 1;
}
else if(car == ’[’)
{
while((car = desc.charAt(c)) == ’[’)
{
++c;
}
if(car == ’D’ || car == ’J’)
6.18. METHODWRITER.JAVA 239

{
n -= 1;
}
}
else if(car == ’D’ || car == ’J’)
{
n += 2;
}
else
{
n += 1;
}
}
}

/**
* Adds a successor to the {@link #currentBlock currentBlock} block.
*
* @param info information about the control flow edge to be added.
* @param successor the successor block to be added to the current block.
*/
private void addSuccessor(final int info, final Label successor){
// creates and initializes an Edge object...
Edge b = new Edge();
b.info = info;
b.successor = successor;
// ...and adds it to the successor list of the currentBlock block
b.next = currentBlock.successors;
currentBlock.successors = b;
}

/**
* Ends the current basic block. This method must be used in the case
* where the current basic block does not have any successor.
*/
private void noSuccessor(){
if(compute == FRAMES)
{
Label l = new Label();
l.frame = new Frame();
l.frame.owner = l;
l.resolve(this, code.length, code.data);
previousBlock.successor = l;
previousBlock = l;
}
else
{
currentBlock.outputStackMax = maxStackSize;
}
currentBlock = null;
240 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Finds the basic blocks that belong to a given subroutine, and marks
* these blocks as belonging to this subroutine (by using
* {@link Label#status} as a bit set (see {@link #visitMaxs}). This
* recursive method follows the control flow graph to find all the
* blocks that are reachable from the given block WITHOUT following
* any JSR target.
*
* @param block a block that belongs to the subroutine
* @param id the id of this subroutine
*/
private void findSubroutine(final Label block, final int id){
// if ’block’ is already marked as belonging to subroutine ’id’,
// returns
if((block.status & id) != 0)
{
return;
}
// marks ’block’ as belonging to subroutine ’id’
block.status |= id;
// calls this method recursively on each successor, except
// JSR targets
Edge e = block.successors;
while(e != null)
{
// if ’block’ is a JSR block, then ’block.successors.next’
// leads to the JSR target (see {@link #visitJumpInsn}) and
// must therefore not be followed
if((block.status & Label.JSR) == 0 || e != block.successors.next)
{
findSubroutine(e.successor, id);
}
e = e.next;
}
}

/**
* Finds the successors of the RET blocks of the specified subroutine,
* and of any nested subroutine it calls.
*
* @param id id of the subroutine whose RET block successors must
* be found.
* @param JSRs the JSR blocks that were followed to reach this
* subroutine.
* @param nJSRs number of JSR blocks in the JSRs array.
*/
private void findSubroutineSuccessors(
final int id,
6.18. METHODWRITER.JAVA 241

final Label[] JSRs,

final int nJSRs){
// iterates over all the basic blocks...
Label l = labels;
while(l != null)
{
// for those that belong to subroutine ’id’...
if((l.status & id) != 0)
{
if((l.status & Label.JSR) != 0)
{
// finds the subroutine to which ’l’ leads by
// following the second edge of l.successors (see
// {@link #visitJumpInsn})
int nId = l.successors.next.successor.status & ~0xFFF;
if(nId != id)
{
// calls this method recursively with l pushed onto
// the JSRs stack to find the successors of the RET
// blocks of this nested subroutine ’nId’
JSRs[nJSRs] = l;
findSubroutineSuccessors(nId, JSRs, nJSRs + 1);
}
}
else if((l.status & Label.RET) != 0)
{
/*
* finds the JSR block in the JSRs stack that corresponds
* to this RET block, and updates the successors of this
* RET block accordingly. This corresponding JSR is the
* one that leads to the subroutine to which the RET
* block belongs. But the RET block can belong to
* several subroutines (if a nested subroutine returns
* to its parent subroutine implicitely, without a RET).
* So, in fact, the JSR that corresponds to this RET is
* the first block in the JSRs stack, starting from the
* bottom of the stack, that leads to a subroutine to
* which the RET block belongs.
*/
for(int i = 0; i < nJSRs; ++i)
{
int JSRstatus =
JSRs[i].successors.next.successor.status;
if(((JSRstatus & ~0xFFF) &
(l.status & ~0xFFF)) != 0)
{
Edge e = new Edge();
e.info = l.inputStackTop;
e.successor = JSRs[i].successors.successor;
e.next = l.successors;
242 CHAPTER 6. JVM/CLOJURE/ASM/

l.successors = e;
break;
}
}
}
}
l = l.successor;
}
}

// -------------------------------------------------------------------
// Utility methods: stack map frames
// -------------------------------------------------------------------

/**
* Visits a frame that has been computed from scratch.
*
* @param f the frame that must be visited.
*/
private void visitFrame(final Frame f){
int i, t;
int nTop = 0;
int nLocal = 0;
int nStack = 0;
int[] locals = f.inputLocals;
int[] stacks = f.inputStack;
// computes the number of locals (ignores TOP types that are just
// after a LONG or a DOUBLE, and all trailing TOP types)
for(i = 0; i < locals.length; ++i)
{
t = locals[i];
if(t == Frame.TOP)
{
++nTop;
}
else
{
nLocal += nTop + 1;
nTop = 0;
}
if(t == Frame.LONG || t == Frame.DOUBLE)
{
++i;
}
}
// computes the stack size (ignores TOP types that are just after
// a LONG or a DOUBLE)
for(i = 0; i < stacks.length; ++i)
{
t = stacks[i];
6.18. METHODWRITER.JAVA 243

++nStack;
if(t == Frame.LONG || t == Frame.DOUBLE)
{
++i;
}
}
// visits the frame and its content
startFrame(f.owner.position, nLocal, nStack);
for(i = 0; nLocal > 0; ++i, --nLocal)
{
t = locals[i];
frame[frameIndex++] = t;
if(t == Frame.LONG || t == Frame.DOUBLE)
{
++i;
}
}
for(i = 0; i < stacks.length; ++i)
{
t = stacks[i];
frame[frameIndex++] = t;
if(t == Frame.LONG || t == Frame.DOUBLE)
{
++i;
}
}
endFrame();
}

/**
* Starts the visit of a stack map frame.
*
* @param offset the offset of the instruction to which the frame
* corresponds.
* @param nLocal the number of local variables in the frame.
* @param nStack the number of stack elements in the frame.
*/
private void startFrame(final int offset,
final int nLocal,
final int nStack){
int n = 3 + nLocal + nStack;
if(frame == null || frame.length < n)
{
frame = new int[n];
}
frame[0] = offset;
frame[1] = nLocal;
frame[2] = nStack;
frameIndex = 3;
}
244 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Checks if the visit of the current frame {@link #frame} is finished,
* and if yes, write it in the StackMapTable attribute.
*/
private void endFrame(){
if(previousFrame != null)
{ // do not write the first frame
if(stackMap == null)
{
stackMap = new ByteVector();
}
writeFrame();
++frameCount;
}
previousFrame = frame;
frame = null;
}

/**
* Compress and writes the current frame {@link #frame} in the
* StackMapTable attribute.
*/
private void writeFrame(){
int clocalsSize = frame[1];
int cstackSize = frame[2];
if((cw.version & 0xFFFF) < Opcodes.V1_6)
{
stackMap.putShort(frame[0]).putShort(clocalsSize);
writeFrameTypes(3, 3 + clocalsSize);
stackMap.putShort(cstackSize);
writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
return;
}
int localsSize = previousFrame[1];
int type = FULL_FRAME;
int k = 0;
int delta;
if(frameCount == 0)
{
delta = frame[0];
}
else
{
delta = frame[0] - previousFrame[0] - 1;
}
if(cstackSize == 0)
{
k = clocalsSize - localsSize;
switch(k)
6.18. METHODWRITER.JAVA 245

{
case-3:
case-2:
case-1:
type = CHOP_FRAME;
localsSize = clocalsSize;
break;
case 0:
type = delta < 64 ? SAME_FRAME : SAME_FRAME_EXTENDED;
break;
case 1:
case 2:
case 3:
type = APPEND_FRAME;
break;
}
}
else if(clocalsSize == localsSize && cstackSize == 1)
{
type = delta < 63
? SAME_LOCALS_1_STACK_ITEM_FRAME
: SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED;
}
if(type != FULL_FRAME)
{
// verify if locals are the same
int l = 3;
for(int j = 0; j < localsSize; j++)
{
if(frame[l] != previousFrame[l])
{
type = FULL_FRAME;
break;
}
l++;
}
}
switch(type)
{
case SAME_FRAME:
stackMap.putByte(delta);
break;
case SAME_LOCALS_1_STACK_ITEM_FRAME:
stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
break;
case SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED:
stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
.putShort(delta);
writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
246 CHAPTER 6. JVM/CLOJURE/ASM/

break;
case SAME_FRAME_EXTENDED:
stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
break;
case CHOP_FRAME:
stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
break;
case APPEND_FRAME:
stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
writeFrameTypes(3 + localsSize, 3 + clocalsSize);
break;
// case FULL_FRAME:
default:
stackMap.putByte(FULL_FRAME)
.putShort(delta)
.putShort(clocalsSize);
writeFrameTypes(3, 3 + clocalsSize);
stackMap.putShort(cstackSize);
writeFrameTypes(3+clocalsSize, 3+clocalsSize+cstackSize);
}
}

/**
* Writes some types of the current frame {@link #frame} into the
* StackMapTableAttribute. This method converts types from the format
* used in {@link Label} to the format used in StackMapTable attributes.
* In particular, it converts type table indexes to constant pool
* indexes.
*
* @param start index of the first type in {@link #frame} to write.
* @param end index of last type in {@link #frame} to write
* (exclusive).
*/
private void writeFrameTypes(final int start, final int end){
for(int i = start; i < end; ++i)
{
int t = frame[i];
int d = t & Frame.DIM;
if(d == 0)
{
int v = t & Frame.BASE_VALUE;
switch(t & Frame.BASE_KIND)
{
case Frame.OBJECT:
stackMap.putByte(7)
.putShort(cw.newClass(cw.typeTable[v].strVal1));
break;
case Frame.UNINITIALIZED:
stackMap.putByte(8).putShort(cw.typeTable[v].intVal);
break;
6.18. METHODWRITER.JAVA 247

default:
stackMap.putByte(v);
}
}
else
{
StringBuffer buf = new StringBuffer();
d >>= 28;
while(d-- > 0)
{
buf.append(’[’);
}
if((t & Frame.BASE_KIND) == Frame.OBJECT)
{
buf.append(’L’);
buf.append(cw.typeTable[t & Frame.BASE_VALUE].strVal1);
buf.append(’;’);
}
else
{
switch(t & 0xF)
{
case 1:
buf.append(’I’);
break;
case 2:
buf.append(’F’);
break;
case 3:
buf.append(’D’);
break;
case 9:
buf.append(’Z’);
break;
case 10:
buf.append(’B’);
break;
case 11:
buf.append(’C’);
break;
case 12:
buf.append(’S’);
break;
default:
buf.append(’J’);
}
}
stackMap.putByte(7).putShort(cw.newClass(buf.toString()));
}
}
248 CHAPTER 6. JVM/CLOJURE/ASM/

private void writeFrameType(final Object type){

if(type instanceof String)
{
stackMap.putByte(7).putShort(cw.newClass((String) type));
}
else if(type instanceof Integer)
{
stackMap.putByte(((Integer) type).intValue());
}
else
{
stackMap.putByte(8).putShort(((Label) type).position);
}
}

// -------------------------------------------------------------------
// Utility methods: dump bytecode array
// -------------------------------------------------------------------

/**
* Returns the size of the bytecode of this method.
*
* @return the size of the bytecode of this method.
*/
final int getSize(){
if(classReaderOffset != 0)
{
return 6 + classReaderLength;
}
if(resize)
{
// replaces the temporary jump opcodes introduced by
// Label.resolve.
resizeInstructions();
}
int size = 8;
if(code.length > 0)
{
cw.newUTF8("Code");
size += 18 + code.length + 8 * handlerCount;
if(localVar != null)
{
cw.newUTF8("LocalVariableTable");
size += 8 + localVar.length;
}
if(localVarType != null)
{
cw.newUTF8("LocalVariableTypeTable");
6.18. METHODWRITER.JAVA 249

size += 8 + localVarType.length;
}
if(lineNumber != null)
{
cw.newUTF8("LineNumberTable");
size += 8 + lineNumber.length;
}
if(stackMap != null)
{
boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
cw.newUTF8(zip ? "StackMapTable" : "StackMap");
size += 8 + stackMap.length;
}
if(cattrs != null)
{
size += cattrs.getSize(cw,
code.data,
code.length,
maxStack,
maxLocals);
}
}
if(exceptionCount > 0)
{
cw.newUTF8("Exceptions");
size += 8 + 2 * exceptionCount;
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (cw.version & 0xffff) < Opcodes.V1_5)
{
cw.newUTF8("Synthetic");
size += 6;
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
cw.newUTF8("Deprecated");
size += 6;
}
if(signature != null)
{
cw.newUTF8("Signature");
cw.newUTF8(signature);
size += 8;
}
if(annd != null)
{
cw.newUTF8("AnnotationDefault");
size += 6 + annd.length;
}
if(anns != null)
250 CHAPTER 6. JVM/CLOJURE/ASM/

{
cw.newUTF8("RuntimeVisibleAnnotations");
size += 8 + anns.getSize();
}
if(ianns != null)
{
cw.newUTF8("RuntimeInvisibleAnnotations");
size += 8 + ianns.getSize();
}
if(panns != null)
{
cw.newUTF8("RuntimeVisibleParameterAnnotations");
size += 7 + 2 * panns.length;
for(int i = panns.length - 1; i >= 0; --i)
{
size += panns[i] == null ? 0 : panns[i].getSize();
}
}
if(ipanns != null)
{
cw.newUTF8("RuntimeInvisibleParameterAnnotations");
size += 7 + 2 * ipanns.length;
for(int i = ipanns.length - 1; i >= 0; --i)
{
size += ipanns[i] == null ? 0 : ipanns[i].getSize();
}
}
if(attrs != null)
{
size += attrs.getSize(cw, null, 0, -1, -1);
}
return size;
}

/**
* Puts the bytecode of this method in the given byte vector.
*
* @param out the byte vector into which the bytecode of this method must
* be copied.
*/
final void put(final ByteVector out){
out.putShort(access).putShort(name).putShort(desc);
if(classReaderOffset != 0)
{
out.putByteArray(cw.cr.b, classReaderOffset, classReaderLength);
return;
}
int attributeCount = 0;
if(code.length > 0)
{
6.18. METHODWRITER.JAVA 251

++attributeCount;
}
if(exceptionCount > 0)
{
++attributeCount;
}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (cw.version & 0xffff) < Opcodes.V1_5)
{
++attributeCount;
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
++attributeCount;
}
if(signature != null)
{
++attributeCount;
}
if(annd != null)
{
++attributeCount;
}
if(anns != null)
{
++attributeCount;
}
if(ianns != null)
{
++attributeCount;
}
if(panns != null)
{
++attributeCount;
}
if(ipanns != null)
{
++attributeCount;
}
if(attrs != null)
{
attributeCount += attrs.getCount();
}
out.putShort(attributeCount);
if(code.length > 0)
{
int size = 12 + code.length + 8 * handlerCount;
if(localVar != null)
{
size += 8 + localVar.length;
252 CHAPTER 6. JVM/CLOJURE/ASM/

}
if(localVarType != null)
{
size += 8 + localVarType.length;
}
if(lineNumber != null)
{
size += 8 + lineNumber.length;
}
if(stackMap != null)
{
size += 8 + stackMap.length;
}
if(cattrs != null)
{
size += cattrs.getSize(cw,
code.data,
code.length,
maxStack,
maxLocals);
}
out.putShort(cw.newUTF8("Code")).putInt(size);
out.putShort(maxStack).putShort(maxLocals);
out.putInt(code.length).putByteArray(code.data, 0, code.length);
out.putShort(handlerCount);
if(handlerCount > 0)
{
Handler h = firstHandler;
while(h != null)
{
out.putShort(h.start.position)
.putShort(h.end.position)
.putShort(h.handler.position)
.putShort(h.type);
h = h.next;
}
}
attributeCount = 0;
if(localVar != null)
{
++attributeCount;
}
if(localVarType != null)
{
++attributeCount;
}
if(lineNumber != null)
{
++attributeCount;
}
6.18. METHODWRITER.JAVA 253

if(stackMap != null)
{
++attributeCount;
}
if(cattrs != null)
{
attributeCount += cattrs.getCount();
}
out.putShort(attributeCount);
if(localVar != null)
{
out.putShort(cw.newUTF8("LocalVariableTable"));
out.putInt(localVar.length + 2).putShort(localVarCount);
out.putByteArray(localVar.data, 0, localVar.length);
}
if(localVarType != null)
{
out.putShort(cw.newUTF8("LocalVariableTypeTable"));
out.putInt(localVarType.length + 2)
.putShort(localVarTypeCount);
out.putByteArray(localVarType.data, 0, localVarType.length);
}
if(lineNumber != null)
{
out.putShort(cw.newUTF8("LineNumberTable"));
out.putInt(lineNumber.length + 2).putShort(lineNumberCount);
out.putByteArray(lineNumber.data, 0, lineNumber.length);
}
if(stackMap != null)
{
boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
out.putShort(cw.newUTF8(zip ? "StackMapTable" : "StackMap"));
out.putInt(stackMap.length + 2).putShort(frameCount);
out.putByteArray(stackMap.data, 0, stackMap.length);
}
if(cattrs != null)
{
cattrs.put(cw, code.data, code.length,
maxLocals, maxStack, out);
}
}
if(exceptionCount > 0)
{
out.putShort(cw.newUTF8("Exceptions"))
.putInt(2 * exceptionCount + 2);
out.putShort(exceptionCount);
for(int i = 0; i < exceptionCount; ++i)
{
out.putShort(exceptions[i]);
}
254 CHAPTER 6. JVM/CLOJURE/ASM/

}
if((access & Opcodes.ACC_SYNTHETIC) != 0
&& (cw.version & 0xffff) < Opcodes.V1_5)
{
out.putShort(cw.newUTF8("Synthetic")).putInt(0);
}
if((access & Opcodes.ACC_DEPRECATED) != 0)
{
out.putShort(cw.newUTF8("Deprecated")).putInt(0);
}
if(signature != null)
{
out.putShort(cw.newUTF8("Signature"))
.putInt(2)
.putShort(cw.newUTF8(signature));
}
if(annd != null)
{
out.putShort(cw.newUTF8("AnnotationDefault"));
out.putInt(annd.length);
out.putByteArray(annd.data, 0, annd.length);
}
if(anns != null)
{
out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));
anns.put(out);
}
if(ianns != null)
{
out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));
ianns.put(out);
}
if(panns != null)
{
out.putShort(cw.newUTF8("RuntimeVisibleParameterAnnotations"));
AnnotationWriter.put(panns, out);
}
if(ipanns != null)
{
out.putShort(cw.newUTF8("RuntimeInvisibleParameterAnnotations"));
AnnotationWriter.put(ipanns, out);
}
if(attrs != null)
{
attrs.put(cw, null, 0, -1, -1, out);
}
}

// -------------------------------------------------------------------
// Utility methods: instruction resizing (used to handle GOTO_W and
6.18. METHODWRITER.JAVA 255

// JSR_W)
// ------------------------------------------------------------------

/**
* Resizes and replaces the temporary instructions inserted by
* {@link Label#resolve} for wide forward jumps, while keeping jump
* offsets and instruction addresses consistent. This may require to
* resize other existing instructions, or even to introduce new
* instructions: for example, increasing the size of an instruction
* by 2 at the middle of a method can increases the offset of an
* IFEQ instruction from 32766 to 32768, in which case IFEQ 32766
* must be replaced with IFNEQ 8 GOTO_W 32765. This, in turn, may
* require to increase the size of another jump instruction, and so
* on... All these operations are handled automatically by this
* method. This method must be called after all the method
* that is being built has been visited. In particular, the
* {@link Label Label} objects used to construct the method are no
* longer valid after this method has been called.
*/
private void resizeInstructions(){
byte[] b = code.data; // bytecode of the method
int u, v, label; // indexes in b
int i, j; // loop indexes
/*
* 1st step: As explained above, resizing an instruction may require
* to resize another one, which may require to resize yet another
* one, and so on. The first step of the algorithm consists in
* finding all the instructions that need to be resized, without
* modifying the code. This is done by the following "fix point"
* algorithm:
*
* Parse the code to find the jump instructions whose offset will
* need more than 2 bytes to be stored (the future offset is
* computed from the current offset and from the number of bytes
* that will be inserted or removed between the source and target
* instructions). For each such instruction, adds an entry in (a
* copy of) the indexes and sizes arrays (if this has not already
* been done in a previous iteration!).
*
* If at least one entry has been added during the previous step, go
* back to the beginning, otherwise stop.
*
* In fact the real algorithm is complicated by the fact that the
* size of TABLESWITCH and LOOKUPSWITCH instructions depends on their
* position in the bytecode (because of padding). In order to ensure
* the convergence of the algorithm, the number of bytes to be added
* or removed from these instructions is over estimated during the
* previous loop, and computed exactly only after the loop is
* finished (this requires another pass to parse the bytecode of
* the method).
256 CHAPTER 6. JVM/CLOJURE/ASM/

*/
int[] allIndexes = new int[0]; // copy of indexes
int[] allSizes = new int[0]; // copy of sizes
boolean[] resize; // instructions to be resized
int newOffset; // future offset of a jump instruction

resize = new boolean[code.length];

// 3 = loop again, 2 = loop ended, 1 = last pass, 0 = done

int state = 3;
do
{
if(state == 3)
{
state = 2;
}
u = 0;
while(u < b.length)
{
int opcode = b[u] & 0xFF; // opcode of current instruction
int insert = 0; // bytes to be added after this instruction

switch(ClassWriter.TYPE[opcode])
{
case ClassWriter.NOARG_INSN:
case ClassWriter.IMPLVAR_INSN:
u += 1;
break;
case ClassWriter.LABEL_INSN:
if(opcode > 201)
{
// converts temporary opcodes 202 to 217, 218 and
// 219 to IFEQ ... JSR (inclusive), IFNULL and
// IFNONNULL
opcode =
opcode < 218 ? opcode - 49 : opcode - 20;
label = u + readUnsignedShort(b, u + 1);
}
else
{
label = u + readShort(b, u + 1);
}
newOffset =
getNewOffset(allIndexes, allSizes, u, label);
if(newOffset < Short.MIN_VALUE
|| newOffset > Short.MAX_VALUE)
{
if(!resize[u])
{
if(opcode == Opcodes.GOTO
6.18. METHODWRITER.JAVA 257

|| opcode == Opcodes.JSR)
{
// two additional bytes will be required to
// replace this GOTO or JSR instruction with
// a GOTO_W or a JSR_W
insert = 2;
}
else
{
// five additional bytes will be required to
// replace this IFxxx <l> instruction with
// IFNOTxxx <l’> GOTO_W <l>, where IFNOTxxx
// is the "opposite" opcode of IFxxx (i.e.,
// IFNE for IFEQ) and where <l’> designates
// the instruction just after the GOTO_W.
insert = 5;
}
resize[u] = true;
}
}
u += 3;
break;
case ClassWriter.LABELW_INSN:
u += 5;
break;
case ClassWriter.TABL_INSN:
if(state == 1)
{
// true number of bytes to be added (or removed)
// from this instruction = (future number of
// padding bytes - current number of padding
// byte) - previously over estimated variation =
// = ((3 - newOffset%4) - (3 - u%4)) - u%4
// = (-newOffset%4 + u%4) - u%4
// = -(newOffset & 3)
newOffset =
getNewOffset(allIndexes, allSizes, 0, u);
insert = -(newOffset & 3);
}
else if(!resize[u])
{
// over estimation of the number of bytes to be
// added to this instruction = 3 - current number
// of padding bytes = 3 - (3 - u%4) = u%4 = u & 3
insert = u & 3;
resize[u] = true;
}
// skips instruction
u = u + 4 - (u & 3);
u += 4*(readInt(b,u+8) - readInt(b,u+4)+1)+12;
258 CHAPTER 6. JVM/CLOJURE/ASM/

break;
case ClassWriter.LOOK_INSN:
if(state == 1)
{
// like TABL_INSN
newOffset =
getNewOffset(allIndexes, allSizes, 0, u);
insert = -(newOffset & 3);
}
else if(!resize[u])
{
// like TABL_INSN
insert = u & 3;
resize[u] = true;
}
// skips instruction
u = u + 4 - (u & 3);
u += 8 * readInt(b, u + 4) + 8;
break;
case ClassWriter.WIDE_INSN:
opcode = b[u + 1] & 0xFF;
if(opcode == Opcodes.IINC)
{
u += 6;
}
else
{
u += 4;
}
break;
case ClassWriter.VAR_INSN:
case ClassWriter.SBYTE_INSN:
case ClassWriter.LDC_INSN:
u += 2;
break;
case ClassWriter.SHORT_INSN:
case ClassWriter.LDCW_INSN:
case ClassWriter.FIELDORMETH_INSN:
case ClassWriter.TYPE_INSN:
case ClassWriter.IINC_INSN:
u += 3;
break;
case ClassWriter.ITFMETH_INSN:
u += 5;
break;
// case ClassWriter.MANA_INSN:
default:
u += 4;
break;
}
6.18. METHODWRITER.JAVA 259

if(insert != 0)
{
// adds a new (u, insert) entry in the allIndexes and
// allSizes arrays
int[] newIndexes = new int[allIndexes.length + 1];
int[] newSizes = new int[allSizes.length + 1];
System.arraycopy(allIndexes,
0,
newIndexes,
0,
allIndexes.length);
System.arraycopy(allSizes,0,newSizes,0,allSizes.length);
newIndexes[allIndexes.length] = u;
newSizes[allSizes.length] = insert;
allIndexes = newIndexes;
allSizes = newSizes;
if(insert > 0)
{
state = 3;
}
}
}
if(state < 3)
{
--state;
}
} while(state != 0);

// 2nd step:
// copies the bytecode of the method into a new bytevector, updates
// the offsets, and inserts (or removes) bytes as requested.

ByteVector newCode = new ByteVector(code.length);

u = 0;
while(u < code.length)
{
int opcode = b[u] & 0xFF;
switch(ClassWriter.TYPE[opcode])
{
case ClassWriter.NOARG_INSN:
case ClassWriter.IMPLVAR_INSN:
newCode.putByte(opcode);
u += 1;
break;
case ClassWriter.LABEL_INSN:
if(opcode > 201)
{
// changes temporary opcodes 202 to 217 (inclusive),
// 218 and 219 to IFEQ ... JSR (inclusive), IFNULL
260 CHAPTER 6. JVM/CLOJURE/ASM/

// and IFNONNULL
opcode = opcode < 218 ? opcode - 49 : opcode - 20;
label = u + readUnsignedShort(b, u + 1);
}
else
{
label = u + readShort(b, u + 1);
}
newOffset = getNewOffset(allIndexes, allSizes, u, label);
if(resize[u])
{
// replaces GOTO with GOTO_W, JSR with JSR_W and
// IFxxx <l> with IFNOTxxx <l’> GOTO_W <l>, where
// IFNOTxxx is the "opposite" opcode of IFxxx
// (i.e., IFNE for IFEQ) and where <l’> designates
// the instruction just after the GOTO_W.
if(opcode == Opcodes.GOTO)
{
newCode.putByte(200); // GOTO_W
}
else if(opcode == Opcodes.JSR)
{
newCode.putByte(201); // JSR_W
}
else
{
newCode.putByte(opcode <= 166
? ((opcode + 1) ^ 1) - 1
: opcode ^ 1);
newCode.putShort(8); // jump offset
newCode.putByte(200); // GOTO_W
// newOffset now computed from start of GOTO_W
newOffset -= 3;
}
newCode.putInt(newOffset);
}
else
{
newCode.putByte(opcode);
newCode.putShort(newOffset);
}
u += 3;
break;
case ClassWriter.LABELW_INSN:
label = u + readInt(b, u + 1);
newOffset = getNewOffset(allIndexes, allSizes, u, label);
newCode.putByte(opcode);
newCode.putInt(newOffset);
u += 5;
break;
6.18. METHODWRITER.JAVA 261

case ClassWriter.TABL_INSN:
// skips 0 to 3 padding bytes
v = u;
u = u + 4 - (v & 3);
// reads and copies instruction
newCode.putByte(Opcodes.TABLESWITCH);
newCode.length += (4 - newCode.length % 4) % 4;
label = v + readInt(b, u);
u += 4;
newOffset = getNewOffset(allIndexes, allSizes, v, label);
newCode.putInt(newOffset);
j = readInt(b, u);
u += 4;
newCode.putInt(j);
j = readInt(b, u) - j + 1;
u += 4;
newCode.putInt(readInt(b, u - 4));
for(; j > 0; --j)
{
label = v + readInt(b, u);
u += 4;
newOffset =
getNewOffset(allIndexes, allSizes, v, label);
newCode.putInt(newOffset);
}
break;
case ClassWriter.LOOK_INSN:
// skips 0 to 3 padding bytes
v = u;
u = u + 4 - (v & 3);
// reads and copies instruction
newCode.putByte(Opcodes.LOOKUPSWITCH);
newCode.length += (4 - newCode.length % 4) % 4;
label = v + readInt(b, u);
u += 4;
newOffset = getNewOffset(allIndexes, allSizes, v, label);
newCode.putInt(newOffset);
j = readInt(b, u);
u += 4;
newCode.putInt(j);
for(; j > 0; --j)
{
newCode.putInt(readInt(b, u));
u += 4;
label = v + readInt(b, u);
u += 4;
newOffset =
getNewOffset(allIndexes, allSizes, v, label);
newCode.putInt(newOffset);
}
262 CHAPTER 6. JVM/CLOJURE/ASM/

break;
case ClassWriter.WIDE_INSN:
opcode = b[u + 1] & 0xFF;
if(opcode == Opcodes.IINC)
{
newCode.putByteArray(b, u, 6);
u += 6;
}
else
{
newCode.putByteArray(b, u, 4);
u += 4;
}
break;
case ClassWriter.VAR_INSN:
case ClassWriter.SBYTE_INSN:
case ClassWriter.LDC_INSN:
newCode.putByteArray(b, u, 2);
u += 2;
break;
case ClassWriter.SHORT_INSN:
case ClassWriter.LDCW_INSN:
case ClassWriter.FIELDORMETH_INSN:
case ClassWriter.TYPE_INSN:
case ClassWriter.IINC_INSN:
newCode.putByteArray(b, u, 3);
u += 3;
break;
case ClassWriter.ITFMETH_INSN:
newCode.putByteArray(b, u, 5);
u += 5;
break;
// case MANA_INSN:
default:
newCode.putByteArray(b, u, 4);
u += 4;
break;
}
}

// recomputes the stack map frames

if(frameCount > 0)
{
if(compute == FRAMES)
{
frameCount = 0;
stackMap = null;
previousFrame = null;
frame = null;
Frame f = new Frame();
6.18. METHODWRITER.JAVA 263

f.owner = labels;
Type[] args = Type.getArgumentTypes(descriptor);
f.initInputFrame(cw, access, args, maxLocals);
visitFrame(f);
Label l = labels;
while(l != null)
{
/*
* here we need the original label position. getNewOffset
* must therefore never have been called for this label.
*/
u = l.position - 3;
if((l.status & Label.STORE) != 0 ||
(u >= 0 && resize[u]))
{
getNewOffset(allIndexes, allSizes, l);
// TODO update offsets in UNINITIALIZED values
visitFrame(l.frame);
}
l = l.successor;
}
}
else
{
/*
* Resizing an existing stack map frame table is really
* hard. Not only the table must be parsed to update the
* offets, but new frames may be needed for jump
* instructions that were inserted by this method. And
* updating the offsets or inserting frames can change
* the format of the following frames, in case of packed
* frames. In practice the whole table must be recomputed.
* For this the frames are marked as potentially invalid.
* This will cause the whole class to be reread and
* rewritten with the COMPUTE_FRAMES option (see the
* ClassWriter.toByteArray method). This is not very
* efficient but is much easier and requires much less
* code than any other method I can think of.
*/
cw.invalidFrames = true;
}
}
// updates the exception handler block labels
Handler h = firstHandler;
while(h != null)
{
getNewOffset(allIndexes, allSizes, h.start);
getNewOffset(allIndexes, allSizes, h.end);
getNewOffset(allIndexes, allSizes, h.handler);
h = h.next;
264 CHAPTER 6. JVM/CLOJURE/ASM/

}
// updates the instructions addresses in the
// local var and line number tables
for(i = 0; i < 2; ++i)
{
ByteVector bv = i == 0 ? localVar : localVarType;
if(bv != null)
{
b = bv.data;
u = 0;
while(u < bv.length)
{
label = readUnsignedShort(b, u);
newOffset = getNewOffset(allIndexes, allSizes, 0, label);
writeShort(b, u, newOffset);
label += readUnsignedShort(b, u + 2);
newOffset = getNewOffset(allIndexes, allSizes, 0, label)
- newOffset;
writeShort(b, u + 2, newOffset);
u += 10;
}
}
}
if(lineNumber != null)
{
b = lineNumber.data;
u = 0;
while(u < lineNumber.length)
{
writeShort(b, u, getNewOffset(allIndexes,
allSizes,
0,
readUnsignedShort(b, u)));
u += 4;
}
}
// updates the labels of the other attributes
Attribute attr = cattrs;
while(attr != null)
{
Label[] labels = attr.getLabels();
if(labels != null)
{
for(i = labels.length - 1; i >= 0; --i)
{
getNewOffset(allIndexes, allSizes, labels[i]);
}
}
attr = attr.next;
}
6.18. METHODWRITER.JAVA 265

// replaces old bytecodes with new ones

code = newCode;
}

/**
* Reads an unsigned short value in the given byte array.
*
* @param b a byte array.
* @param index the start index of the value to be read.
* @return the read value.
*/
static int readUnsignedShort(final byte[] b, final int index){
return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
}

/**
* Reads a signed short value in the given byte array.
*
* @param b a byte array.
* @param index the start index of the value to be read.
* @return the read value.
*/
static short readShort(final byte[] b, final int index){
return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
}

/**
* Reads a signed int value in the given byte array.
*
* @param b a byte array.
* @param index the start index of the value to be read.
* @return the read value.
*/
static int readInt(final byte[] b, final int index){
return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
| ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
}

/**
* Writes a short value in the given byte array.
*
* @param b a byte array.
* @param index where the first byte of the short value must be written.
* @param s the value to be written in the given byte array.
*/
static void writeShort(final byte[] b, final int index, final int s){
b[index] = (byte) (s >>> 8);
b[index + 1] = (byte) s;
}
266 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Computes the future value of a bytecode offset. Note: it is
* possible to have several entries for the same instruction in the
* <tt>indexes</tt> and <tt>sizes</tt>: two entries (index=a,size=b)
* and (index=a,size=b’) are equivalent to a single entry
* (index=a,size=b+b’).
*
* @param indexes current positions of the instructions to be resized.
* Each instruction must be designated by the index of
* its last byte, plus one (or, in other words, by
* the index of the first byte of the next
* instruction).
* @param sizes the number of bytes to be added to the above
* instructions. More precisely, for each
* i < <tt>len</tt>, <tt>sizes</tt>[i] bytes will be
* added at the end of the instruction designated by
* <tt>indexes</tt>[i] or, if <tt>sizes</tt>[i] is
* negative, the last |<tt>sizes[i]</tt>|
* bytes of the instruction will be removed (the
* instruction size must not become negative or
* null).
* @param begin index of the first byte of the source instruction.
* @param end index of the first byte of the target instruction.
* @return the future value of the given bytecode offset.
*/
static int getNewOffset(
final int[] indexes,
final int[] sizes,
final int begin,
final int end){
int offset = end - begin;
for(int i = 0; i < indexes.length; ++i)
{
if(begin < indexes[i] && indexes[i] <= end)
{
// forward jump
offset += sizes[i];
}
else if(end < indexes[i] && indexes[i] <= begin)
{
// backward jump
offset -= sizes[i];
}
}
return offset;
}

/**
* Updates the offset of the given label.
6.19. OPCODES.JAVA 267

*
* @param indexes current positions of the instructions to be resized.
* Each instruction must be designated by the index of
* its last byte, plus one (or, in other words,
* by the index of the first byte of the
* next instruction).
* @param sizes the number of bytes to be added to the above
* instructions. More precisely, for each
* i < <tt>len</tt>, <tt>sizes</tt>[i] bytes will be
* added at the end of the instruction designated by
* <tt>indexes</tt>[i] or, if <tt>sizes</tt>[i] is
* negative, the last | <tt>sizes[i]</tt>|
* bytes of the instruction will be removed (the
* instruction size must not become negative
* or null).
* @param label the label whose offset must be updated.
*/
static void getNewOffset(
final int[] indexes,
final int[] sizes,
final Label label){
if((label.status & Label.RESIZED) == 0)
{
label.position = getNewOffset(indexes, sizes, 0, label.position);
label.status |= Label.RESIZED;
}
}
}

———-

6.19 Opcodes.java

— Opcodes.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

/**
* Defines the JVM opcodes, access flags and array type codes. This
* interface does not define all the JVM opcodes because some opcodes
* are automatically handled. For example, the xLOAD and xSTORE opcodes
* are automatically replaced by xLOAD_n and xSTORE_n opcodes when
* possible. The xLOAD_n and xSTORE_n opcodes are therefore not
* defined in this interface. Likewise for LDC, automatically replaced
* by LDC_W or LDC2_W when necessary, WIDE, GOTO_W and JSR_W.
*
268 CHAPTER 6. JVM/CLOJURE/ASM/

* @author Eric Bruneton

* @author Eugene Kuleshov
*/
public interface Opcodes{

// versions

int V1_1 = 3 << 16 | 45;

// access flags

int ACC_PUBLIC = 0x0001; // class, field, method

int ACC_PRIVATE = 0x0002; // class, field, method
int ACC_PROTECTED = 0x0004; // class, field, method
int ACC_STATIC = 0x0008; // field, method
int ACC_FINAL = 0x0010; // class, field, method
int ACC_SUPER = 0x0020; // class
int ACC_SYNCHRONIZED = 0x0020; // method
int ACC_VOLATILE = 0x0040; // field
int ACC_BRIDGE = 0x0040; // method
int ACC_VARARGS = 0x0080; // method
int ACC_TRANSIENT = 0x0080; // field
int ACC_NATIVE = 0x0100; // method
int ACC_INTERFACE = 0x0200; // class
int ACC_ABSTRACT = 0x0400; // class, method
int ACC_STRICT = 0x0800; // method
int ACC_SYNTHETIC = 0x1000; // class, field, method
int ACC_ANNOTATION = 0x2000; // class
int ACC_ENUM = 0x4000; // class(?) field inner

// ASM specific pseudo access flags

int ACC_DEPRECATED = 131072; // class, field, method

// types for NEWARRAY

int T_BOOLEAN = 4;
int T_CHAR = 5;
int T_FLOAT = 6;
int T_DOUBLE = 7;
int T_BYTE = 8;
int T_SHORT = 9;
int T_INT = 10;
int T_LONG = 11;
6.19. OPCODES.JAVA 269

// stack map frame types

/**
* Represents an expanded frame. See {@link ClassReader#EXPAND_FRAMES}.
*/
int F_NEW = -1;

/**
* Represents a compressed frame with complete frame data.
*/
int F_FULL = 0;

/**
* Represents a compressed frame where locals are the same as the
* locals in the previous frame, except that additional 1-3 locals
* are defined, and with an empty stack.
*/
int F_APPEND = 1;

/**
* Represents a compressed frame where locals are the same as the
* locals in the previous frame, except that the last 1-3 locals are
* absent and with an empty stack.
*/
int F_CHOP = 2;

/**
* Represents a compressed frame with exactly the same locals as the
* previous frame and with an empty stack.
*/
int F_SAME = 3;

/**
* Represents a compressed frame with exactly the same locals as the
* previous frame and with a single value on the stack.
*/
int F_SAME1 = 4;

Integer TOP = new Integer(0);

Integer INTEGER = new Integer(1);
Integer FLOAT = new Integer(2);
Integer DOUBLE = new Integer(3);
Integer LONG = new Integer(4);
Integer NULL = new Integer(5);
Integer UNINITIALIZED_THIS = new Integer(6);

// opcodes // visit method (- = idem)

int NOP = 0; // visitInsn

int ACONST_NULL = 1; // -
270 CHAPTER 6. JVM/CLOJURE/ASM/

int ICONST_M1 = 2; // -
int ICONST_0 = 3; // -
int ICONST_1 = 4; // -
int ICONST_2 = 5; // -
int ICONST_3 = 6; // -
int ICONST_4 = 7; // -
int ICONST_5 = 8; // -
int LCONST_0 = 9; // -
int LCONST_1 = 10; // -
int FCONST_0 = 11; // -
int FCONST_1 = 12; // -
int FCONST_2 = 13; // -
int DCONST_0 = 14; // -
int DCONST_1 = 15; // -
int BIPUSH = 16; // visitIntInsn
int SIPUSH = 17; // -
int LDC = 18; // visitLdcInsn
// int LDC_W = 19; // -
// int LDC2_W = 20; // -
int ILOAD = 21; // visitVarInsn
int LLOAD = 22; // -
int FLOAD = 23; // -
int DLOAD = 24; // -
int ALOAD = 25; // -
// int ILOAD_0 = 26; // -
// int ILOAD_1 = 27; // -
// int ILOAD_2 = 28; // -
// int ILOAD_3 = 29; // -
// int LLOAD_0 = 30; // -
// int LLOAD_1 = 31; // -
// int LLOAD_2 = 32; // -
// int LLOAD_3 = 33; // -
// int FLOAD_0 = 34; // -
// int FLOAD_1 = 35; // -
// int FLOAD_2 = 36; // -
// int FLOAD_3 = 37; // -
// int DLOAD_0 = 38; // -
// int DLOAD_1 = 39; // -
// int DLOAD_2 = 40; // -
// int DLOAD_3 = 41; // -
// int ALOAD_0 = 42; // -
// int ALOAD_1 = 43; // -
// int ALOAD_2 = 44; // -
// int ALOAD_3 = 45; // -
int IALOAD = 46; // visitInsn
int LALOAD = 47; // -
int FALOAD = 48; // -
int DALOAD = 49; // -
int AALOAD = 50; // -
int BALOAD = 51; // -
6.19. OPCODES.JAVA 271

int CALOAD = 52; // -

int SALOAD = 53; // -
int ISTORE = 54; // visitVarInsn
int LSTORE = 55; // -
int FSTORE = 56; // -
int DSTORE = 57; // -
int ASTORE = 58; // -
// int ISTORE_0 = 59; // -
// int ISTORE_1 = 60; // -
// int ISTORE_2 = 61; // -
// int ISTORE_3 = 62; // -
// int LSTORE_0 = 63; // -
// int LSTORE_1 = 64; // -
// int LSTORE_2 = 65; // -
// int LSTORE_3 = 66; // -
// int FSTORE_0 = 67; // -
// int FSTORE_1 = 68; // -
// int FSTORE_2 = 69; // -
// int FSTORE_3 = 70; // -
// int DSTORE_0 = 71; // -
// int DSTORE_1 = 72; // -
// int DSTORE_2 = 73; // -
// int DSTORE_3 = 74; // -
// int ASTORE_0 = 75; // -
// int ASTORE_1 = 76; // -
// int ASTORE_2 = 77; // -
// int ASTORE_3 = 78; // -
int IASTORE = 79; // visitInsn
int LASTORE = 80; // -
int FASTORE = 81; // -
int DASTORE = 82; // -
int AASTORE = 83; // -
int BASTORE = 84; // -
int CASTORE = 85; // -
int SASTORE = 86; // -
int POP = 87; // -
int POP2 = 88; // -
int DUP = 89; // -
int DUP_X1 = 90; // -
int DUP_X2 = 91; // -
int DUP2 = 92; // -
int DUP2_X1 = 93; // -
int DUP2_X2 = 94; // -
int SWAP = 95; // -
int IADD = 96; // -
int LADD = 97; // -
int FADD = 98; // -
int DADD = 99; // -
int ISUB = 100; // -
int LSUB = 101; // -
272 CHAPTER 6. JVM/CLOJURE/ASM/

int FSUB = 102; // -

int DSUB = 103; // -
int IMUL = 104; // -
int LMUL = 105; // -
int FMUL = 106; // -
int DMUL = 107; // -
int IDIV = 108; // -
int LDIV = 109; // -
int FDIV = 110; // -
int DDIV = 111; // -
int IREM = 112; // -
int LREM = 113; // -
int FREM = 114; // -
int DREM = 115; // -
int INEG = 116; // -
int LNEG = 117; // -
int FNEG = 118; // -
int DNEG = 119; // -
int ISHL = 120; // -
int LSHL = 121; // -
int ISHR = 122; // -
int LSHR = 123; // -
int IUSHR = 124; // -
int LUSHR = 125; // -
int IAND = 126; // -
int LAND = 127; // -
int IOR = 128; // -
int LOR = 129; // -
int IXOR = 130; // -
int LXOR = 131; // -
int IINC = 132; // visitIincInsn
int I2L = 133; // visitInsn
int I2F = 134; // -
int I2D = 135; // -
int L2I = 136; // -
int L2F = 137; // -
int L2D = 138; // -
int F2I = 139; // -
int F2L = 140; // -
int F2D = 141; // -
int D2I = 142; // -
int D2L = 143; // -
int D2F = 144; // -
int I2B = 145; // -
int I2C = 146; // -
int I2S = 147; // -
int LCMP = 148; // -
int FCMPL = 149; // -
int FCMPG = 150; // -
int DCMPL = 151; // -
6.19. OPCODES.JAVA 273

int DCMPG = 152; // -

int IFEQ = 153; // visitJumpInsn
int IFNE = 154; // -
int IFLT = 155; // -
int IFGE = 156; // -
int IFGT = 157; // -
int IFLE = 158; // -
int IF_ICMPEQ = 159; // -
int IF_ICMPNE = 160; // -
int IF_ICMPLT = 161; // -
int IF_ICMPGE = 162; // -
int IF_ICMPGT = 163; // -
int IF_ICMPLE = 164; // -
int IF_ACMPEQ = 165; // -
int IF_ACMPNE = 166; // -
int GOTO = 167; // -
int JSR = 168; // -
int RET = 169; // visitVarInsn
int TABLESWITCH = 170; // visiTableSwitchInsn
int LOOKUPSWITCH = 171; // visitLookupSwitch
int IRETURN = 172; // visitInsn
int LRETURN = 173; // -
int FRETURN = 174; // -
int DRETURN = 175; // -
int ARETURN = 176; // -
int RETURN = 177; // -
int GETSTATIC = 178; // visitFieldInsn
int PUTSTATIC = 179; // -
int GETFIELD = 180; // -
int PUTFIELD = 181; // -
int INVOKEVIRTUAL = 182; // visitMethodInsn
int INVOKESPECIAL = 183; // -
int INVOKESTATIC = 184; // -
int INVOKEINTERFACE = 185; // -
// int UNUSED = 186; // NOT VISITED
int NEW = 187; // visitTypeInsn
int NEWARRAY = 188; // visitIntInsn
int ANEWARRAY = 189; // visitTypeInsn
int ARRAYLENGTH = 190; // visitInsn
int ATHROW = 191; // -
int CHECKCAST = 192; // visitTypeInsn
int INSTANCEOF = 193; // -
int MONITORENTER = 194; // visitInsn
int MONITOREXIT = 195; // -
// int WIDE = 196; // NOT VISITED
int MULTIANEWARRAY = 197; // visitMultiANewArrayInsn
int IFNULL = 198; // visitJumpInsn
int IFNONNULL = 199; // -
// int GOTO_W = 200; // -
// int JSR_W = 201; // -
274 CHAPTER 6. JVM/CLOJURE/ASM/

———-

6.20 Type.java

— Type.java —

\getchunk{France Telecom Copyright}

package clojure.asm;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
* A Java type. This class can be used to make it easier to manipulate
* type and method descriptors.
*
* @author Eric Bruneton
* @author Chris Nokleberg
*/
public class Type{

/**
* The sort of the <tt>void</tt> type. See {@link #getSort getSort}.
*/
public final static int VOID = 0;

/**
* The sort of the <tt>boolean</tt> type. See {@link #getSort getSort}.
*/
public final static int BOOLEAN = 1;

/**
* The sort of the <tt>char</tt> type. See {@link #getSort getSort}.
*/
public final static int CHAR = 2;

/**
* The sort of the <tt>byte</tt> type. See {@link #getSort getSort}.
*/
public final static int BYTE = 3;

/**
* The sort of the <tt>short</tt> type. See {@link #getSort getSort}.
*/
public final static int SHORT = 4;
6.20. TYPE.JAVA 275

/**
* The sort of the <tt>int</tt> type. See {@link #getSort getSort}.
*/
public final static int INT = 5;

/**
* The sort of the <tt>float</tt> type. See {@link #getSort getSort}.
*/
public final static int FLOAT = 6;

/**
* The sort of the <tt>long</tt> type. See {@link #getSort getSort}.
*/
public final static int LONG = 7;

/**
* The sort of the <tt>double</tt> type. See {@link #getSort getSort}.
*/
public final static int DOUBLE = 8;

/**
* The sort of array reference types. See {@link #getSort getSort}.
*/
public final static int ARRAY = 9;

/**
* The sort of object reference type. See {@link #getSort getSort}.
*/
public final static int OBJECT = 10;

/**
* The <tt>void</tt> type.
*/
public final static Type VOID_TYPE = new Type(VOID);

/**
* The <tt>boolean</tt> type.
*/
public final static Type BOOLEAN_TYPE = new Type(BOOLEAN);

/**
* The <tt>char</tt> type.
*/
public final static Type CHAR_TYPE = new Type(CHAR);

/**
* The <tt>byte</tt> type.
*/
public final static Type BYTE_TYPE = new Type(BYTE);
276 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* The <tt>short</tt> type.
*/
public final static Type SHORT_TYPE = new Type(SHORT);

/**
* The <tt>int</tt> type.
*/
public final static Type INT_TYPE = new Type(INT);

/**
* The <tt>float</tt> type.
*/
public final static Type FLOAT_TYPE = new Type(FLOAT);

/**
* The <tt>long</tt> type.
*/
public final static Type LONG_TYPE = new Type(LONG);

/**
* The <tt>double</tt> type.
*/
public final static Type DOUBLE_TYPE = new Type(DOUBLE);

// -------------------------------------------------------------------
// Fields
// -------------------------------------------------------------------

/**
* The sort of this Java type.
*/
private final int sort;

/**
* A buffer containing the descriptor of this Java type. This field
* is only used for reference types.
*/
private char[] buf;

/**
* The offset of the descriptor of this Java type in {@link #buf buf}.
* This field is only used for reference types.
*/
private int off;

/**
* The length of the descriptor of this Java type.
*/
6.20. TYPE.JAVA 277

private int len;

// -------------------------------------------------------------------
// Constructors
// -------------------------------------------------------------------

/**
* Constructs a primitive type.
*
* @param sort the sort of the primitive type to be constructed.
*/
private Type(final int sort){
this.sort = sort;
this.len = 1;
}

/**
* Constructs a reference type.
*
* @param sort the sort of the reference type to be constructed.
* @param buf a buffer containing the descriptor of the previous type.
* @param off the offset of this descriptor in the previous buffer.
* @param len the length of this descriptor.
*/
private Type(final int sort,
final char[] buf,
final int off,
final int len){
this.sort = sort;
this.buf = buf;
this.off = off;
this.len = len;
}

/**
* Returns the Java type corresponding to the given type descriptor.
*
* @param typeDescriptor a type descriptor.
* @return the Java type corresponding to the given type descriptor.
*/
public static Type getType(final String typeDescriptor){
return getType(typeDescriptor.toCharArray(), 0);
}

/**
* Returns the Java type corresponding to the given class.
*
* @param c a class.
* @return the Java type corresponding to the given class.
*/
278 CHAPTER 6. JVM/CLOJURE/ASM/

public static Type getType(final Class c){

if(c.isPrimitive())
{
if(c == Integer.TYPE)
{
return INT_TYPE;
}
else if(c == Void.TYPE)
{
return VOID_TYPE;
}
else if(c == Boolean.TYPE)
{
return BOOLEAN_TYPE;
}
else if(c == Byte.TYPE)
{
return BYTE_TYPE;
}
else if(c == Character.TYPE)
{
return CHAR_TYPE;
}
else if(c == Short.TYPE)
{
return SHORT_TYPE;
}
else if(c == Double.TYPE)
{
return DOUBLE_TYPE;
}
else if(c == Float.TYPE)
{
return FLOAT_TYPE;
}
else /* if (c == Long.TYPE) */
{
return LONG_TYPE;
}
}
else
{
return getType(getDescriptor(c));
}
}

/**
* Returns the {@link Type#OBJECT} type for the given internal class
* name. This is a shortcut method for
* <code>Type.getType("L"+name+";")</code>.
6.20. TYPE.JAVA 279

* Note that opposed to {@link Type#getType(String)}, this method

* takes internal class names and not class descriptor.
*
* @param name an internal class name.
* @return the the {@link Type#OBJECT} type for the given class name.
*/
public static Type getObjectType(String name){
int l = name.length();
char[] buf = new char[l + 2];
buf[0] = ’L’;
buf[l + 1] = ’;’;
name.getChars(0, l, buf, 1);
return new Type(OBJECT, buf, 0, l + 2);
}

/**
* Returns the Java types corresponding to the argument types of the
* given method descriptor.
*
* @param methodDescriptor a method descriptor.
* @return the Java types corresponding to the argument types of the
* given method descriptor.
*/
public static Type[] getArgumentTypes(final String methodDescriptor){
char[] buf = methodDescriptor.toCharArray();
int off = 1;
int size = 0;
while(true)
{
char car = buf[off++];
if(car == ’)’)
{
break;
}
else if(car == ’L’)
{
while(buf[off++] != ’;’)
{
}
++size;
}
else if(car != ’[’)
{
++size;
}
}
Type[] args = new Type[size];
off = 1;
size = 0;
while(buf[off] != ’)’)
280 CHAPTER 6. JVM/CLOJURE/ASM/

{
args[size] = getType(buf, off);
off += args[size].len;
size += 1;
}
return args;
}

/**
* Returns the Java types corresponding to the argument types of the
* given method.
*
* @param method a method.
* @return the Java types corresponding to the argument types of the
* given method.
*/
public static Type[] getArgumentTypes(final Method method){
Class[] classes = method.getParameterTypes();
Type[] types = new Type[classes.length];
for(int i = classes.length - 1; i >= 0; --i)
{
types[i] = getType(classes[i]);
}
return types;
}

/**
* Returns the Java type corresponding to the return type of the given
* method descriptor.
*
* @param methodDescriptor a method descriptor.
* @return the Java type corresponding to the return type of the given
* method descriptor.
*/
public static Type getReturnType(final String methodDescriptor){
char[] buf = methodDescriptor.toCharArray();
return getType(buf, methodDescriptor.indexOf(’)’) + 1);
}

/**
* Returns the Java type corresponding to the return type of the given
* method.
*
* @param method a method.
* @return the Java type corresponding to the return type of the given
* method.
*/
public static Type getReturnType(final Method method){
return getType(method.getReturnType());
}
6.20. TYPE.JAVA 281

/**
* Returns the Java type corresponding to the given type descriptor.
*
* @param buf a buffer containing a type descriptor.
* @param off the offset of this descriptor in the previous buffer.
* @return the Java type corresponding to the given type descriptor.
*/
private static Type getType(final char[] buf, final int off){
int len;
switch(buf[off])
{
case’V’:
return VOID_TYPE;
case’Z’:
return BOOLEAN_TYPE;
case’C’:
return CHAR_TYPE;
case’B’:
return BYTE_TYPE;
case’S’:
return SHORT_TYPE;
case’I’:
return INT_TYPE;
case’F’:
return FLOAT_TYPE;
case’J’:
return LONG_TYPE;
case’D’:
return DOUBLE_TYPE;
case’[’:
len = 1;
while(buf[off + len] == ’[’)
{
++len;
}
if(buf[off + len] == ’L’)
{
++len;
while(buf[off + len] != ’;’)
{
++len;
}
}
return new Type(ARRAY, buf, off, len + 1);
// case ’L’:
default:
len = 1;
while(buf[off + len] != ’;’)
{
282 CHAPTER 6. JVM/CLOJURE/ASM/

++len;
}
return new Type(OBJECT, buf, off, len + 1);
}
}

// -------------------------------------------------------------------
// Accessors
// -------------------------------------------------------------------

/**
* Returns the sort of this Java type.
*
* @return {@link #VOID VOID}, {@link #BOOLEAN BOOLEAN},
* {@link #CHAR CHAR}, {@link #BYTE BYTE}, {@link #SHORT SHORT},
* {@link #INT INT}, {@link #FLOAT FLOAT}, {@link #LONG LONG},
* {@link #DOUBLE DOUBLE}, {@link #ARRAY ARRAY} or
* {@link #OBJECT OBJECT}.
*/
public int getSort(){
return sort;
}

/**
* Returns the number of dimensions of this array type. This method
* should only be used for an array type.
*
* @return the number of dimensions of this array type.
*/
public int getDimensions(){
int i = 1;
while(buf[off + i] == ’[’)
{
++i;
}
return i;
}

/**
* Returns the type of the elements of this array type. This method
* should only be used for an array type.
*
* @return Returns the type of the elements of this array type.
*/
public Type getElementType(){
return getType(buf, off + getDimensions());
}

/**
* Returns the name of the class corresponding to this type.
6.20. TYPE.JAVA 283

*
* @return the fully qualified name of the class corresponding to
* this type.
*/
public String getClassName(){
switch(sort)
{
case VOID:
return "void";
case BOOLEAN:
return "boolean";
case CHAR:
return "char";
case BYTE:
return "byte";
case SHORT:
return "short";
case INT:
return "int";
case FLOAT:
return "float";
case LONG:
return "long";
case DOUBLE:
return "double";
case ARRAY:
StringBuffer b =
new StringBuffer(getElementType().getClassName());
for(int i = getDimensions(); i > 0; --i)
{
b.append("[]");
}
return b.toString();
// case OBJECT:
default:
return new String(buf, off + 1, len - 2).replace(’/’, ’.’);
}
}

/**
* Returns the internal name of the class corresponding to this object
* type. The internal name of a class is its fully qualified name,
* where ’.’ are replaced by ’/’. This method should only be used for
* an object type.
*
* @return the internal name of the class corresponding to this object
* type.
*/
public String getInternalName(){
return new String(buf, off + 1, len - 2);
284 CHAPTER 6. JVM/CLOJURE/ASM/

// -------------------------------------------------------------------
// Conversion to type descriptors
// -------------------------------------------------------------------

/**
* Returns the descriptor corresponding to this Java type.
*
* @return the descriptor corresponding to this Java type.
*/
public String getDescriptor(){
StringBuffer buf = new StringBuffer();
getDescriptor(buf);
return buf.toString();
}

/**
* Returns the descriptor corresponding to the given argument and return
* types.
*
* @param returnType the return type of the method.
* @param argumentTypes the argument types of the method.
* @return the descriptor corresponding to the given argument and return
* types.
*/
public static String getMethodDescriptor(
final Type returnType,
final Type[] argumentTypes){
StringBuffer buf = new StringBuffer();
buf.append(’(’);
for(int i = 0; i < argumentTypes.length; ++i)
{
argumentTypes[i].getDescriptor(buf);
}
buf.append(’)’);
returnType.getDescriptor(buf);
return buf.toString();
}

/**
* Appends the descriptor corresponding to this Java type to the given
* string buffer.
*
* @param buf the string buffer to which the descriptor must be appended.
*/
private void getDescriptor(final StringBuffer buf){
switch(sort)
{
case VOID:
6.20. TYPE.JAVA 285

buf.append(’V’);
return;
case BOOLEAN:
buf.append(’Z’);
return;
case CHAR:
buf.append(’C’);
return;
case BYTE:
buf.append(’B’);
return;
case SHORT:
buf.append(’S’);
return;
case INT:
buf.append(’I’);
return;
case FLOAT:
buf.append(’F’);
return;
case LONG:
buf.append(’J’);
return;
case DOUBLE:
buf.append(’D’);
return;
// case ARRAY:
// case OBJECT:
default:
buf.append(this.buf, off, len);
}
}

// -------------------------------------------------------------------
// Direct conversion from classes to type descriptors,
// without intermediate Type objects
// -------------------------------------------------------------------

/**
* Returns the internal name of the given class. The internal name of a
* class is its fully qualified name, where ’.’ are replaced by ’/’.
*
* @param c an object class.
* @return the internal name of the given class.
*/
public static String getInternalName(final Class c){
return c.getName().replace(’.’, ’/’);
}

/**
286 CHAPTER 6. JVM/CLOJURE/ASM/

* Returns the descriptor corresponding to the given Java type.

*
* @param c an object class, a primitive class or an array class.
* @return the descriptor corresponding to the given class.
*/
public static String getDescriptor(final Class c){
StringBuffer buf = new StringBuffer();
getDescriptor(buf, c);
return buf.toString();
}

/**
* Returns the descriptor corresponding to the given constructor.
*
* @param c a {@link Constructor Constructor} object.
* @return the descriptor of the given constructor.
*/
public static String getConstructorDescriptor(final Constructor c){
Class[] parameters = c.getParameterTypes();
StringBuffer buf = new StringBuffer();
buf.append(’(’);
for(int i = 0; i < parameters.length; ++i)
{
getDescriptor(buf, parameters[i]);
}
return buf.append(")V").toString();
}

/**
* Returns the descriptor corresponding to the given method.
*
* @param m a {@link Method Method} object.
* @return the descriptor of the given method.
*/
public static String getMethodDescriptor(final Method m){
Class[] parameters = m.getParameterTypes();
StringBuffer buf = new StringBuffer();
buf.append(’(’);
for(int i = 0; i < parameters.length; ++i)
{
getDescriptor(buf, parameters[i]);
}
buf.append(’)’);
getDescriptor(buf, m.getReturnType());
return buf.toString();
}

/**
* Appends the descriptor of the given class to the given string buffer.
*
6.20. TYPE.JAVA 287

* @param buf the string buffer to which the descriptor must be appended.
* @param c the class whose descriptor must be computed.
*/
private static void getDescriptor(final StringBuffer buf, final Class c){
Class d = c;
while(true)
{
if(d.isPrimitive())
{
char car;
if(d == Integer.TYPE)
{
car = ’I’;
}
else if(d == Void.TYPE)
{
car = ’V’;
}
else if(d == Boolean.TYPE)
{
car = ’Z’;
}
else if(d == Byte.TYPE)
{
car = ’B’;
}
else if(d == Character.TYPE)
{
car = ’C’;
}
else if(d == Short.TYPE)
{
car = ’S’;
}
else if(d == Double.TYPE)
{
car = ’D’;
}
else if(d == Float.TYPE)
{
car = ’F’;
}
else /* if (d == Long.TYPE) */
{
car = ’J’;
}
buf.append(car);
return;
}
else if(d.isArray())
288 CHAPTER 6. JVM/CLOJURE/ASM/

{
buf.append(’[’);
d = d.getComponentType();
}
else
{
buf.append(’L’);
String name = d.getName();
int len = name.length();
for(int i = 0; i < len; ++i)
{
char car = name.charAt(i);
buf.append(car == ’.’ ? ’/’ : car);
}
buf.append(’;’);
return;
}
}
}

// -------------------------------------------------------------------
// Corresponding size and opcodes
// -------------------------------------------------------------------

/**
* Returns the size of values of this type.
*
* @return the size of values of this type, i.e., 2 for <tt>long</tt> and
* <tt>double</tt>, and 1 otherwise.
*/
public int getSize(){
return sort == LONG || sort == DOUBLE ? 2 : 1;
}

/**
* Returns a JVM instruction opcode adapted to this Java type.
*
* @param opcode a JVM instruction opcode. This opcode must be one of
* ILOAD, ISTORE, IALOAD, IASTORE, IADD, ISUB, IMUL,
* IDIV, IREM, INEG, ISHL, ISHR, IUSHR, IAND, IOR,
* IXOR and IRETURN.
* @return an opcode that is similar to the given opcode, but adapted to
* this Java type. For example, if this type is <tt>float</tt>
* and <tt>opcode</tt> is IRETURN, this method returns FRETURN.
*/
public int getOpcode(final int opcode){
if(opcode == Opcodes.IALOAD || opcode == Opcodes.IASTORE)
{
switch(sort)
{
6.20. TYPE.JAVA 289

case BOOLEAN:
case BYTE:
return opcode + 5;
case CHAR:
return opcode + 6;
case SHORT:
return opcode + 7;
case INT:
return opcode;
case FLOAT:
return opcode + 2;
case LONG:
return opcode + 1;
case DOUBLE:
return opcode + 3;
// case ARRAY:
// case OBJECT:
default:
return opcode + 4;
}
}
else
{
switch(sort)
{
case VOID:
return opcode + 5;
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
return opcode;
case FLOAT:
return opcode + 2;
case LONG:
return opcode + 1;
case DOUBLE:
return opcode + 3;
// case ARRAY:
// case OBJECT:
default:
return opcode + 4;
}
}
}

// -------------------------------------------------------------------
// Equals, hashCode and toString
// -------------------------------------------------------------------
290 CHAPTER 6. JVM/CLOJURE/ASM/

/**
* Tests if the given object is equal to this type.
*
* @param o the object to be compared to this type.
* @return <tt>true</tt> if the given object is equal to this type.
*/
public boolean equals(final Object o){
if(this == o)
{
return true;
}
if(!(o instanceof Type))
{
return false;
}
Type t = (Type) o;
if(sort != t.sort)
{
return false;
}
if(sort == Type.OBJECT || sort == Type.ARRAY)
{
if(len != t.len)
{
return false;
}
for(int i = off, j = t.off, end = i + len; i < end; i++, j++)
{
if(buf[i] != t.buf[j])
{
return false;
}
}
}
return true;
}

/**
* Returns a hash code value for this type.
*
* @return a hash code value for this type.
*/
public int hashCode(){
int hc = 13 * sort;
if(sort == Type.OBJECT || sort == Type.ARRAY)
{
for(int i = off, end = i + len; i < end; i++)
{
hc = 17 * (hc + buf[i]);
6.20. TYPE.JAVA 291

}
}
return hc;
}

/**
* Returns a string representation of this type.
*
* @return the descriptor of this type.
*/
public String toString(){
return getDescriptor();
}
}

———-
292 CHAPTER 6. JVM/CLOJURE/ASM/
Chapter 7

jvm/clojure/asm/commons

7.1 AdviceAdapter.java

— AdviceAdapter.java —
\getchunk{France Telecom Copyright}
package clojure.asm.commons;

import java.util.ArrayList;
import java.util.HashMap;

import clojure.asm.Label;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;
import clojure.asm.Type;

/**
* A {@link clojure.asm.MethodAdapter} to insert before, after and around
* advices in methods and constructors. The behavior for constructors
* is like this: <ol>
* 
* <li>as long as the INVOKESPECIAL for the object initialization has
* not been reached, every bytecode instruction is dispatched in the
* ctor code visitor</li>
* 
* <li>when this one is reached, it is only added in the ctor code
* visitor and a JP invoke is added</li>
* 
* <li>after that, only the other code visitor receives the
* instructions</li>
* 
* </ol>

293
294 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*
* @author Eugene Kuleshov
* @author Eric Bruneton
*/
public abstract class AdviceAdapter
extends GeneratorAdapter implements Opcodes{
private static final Object THIS = new Object();
private static final Object OTHER = new Object();

protected int methodAccess;

protected String methodDesc;

private boolean constructor;

private boolean superInitialized;
private ArrayList stackFrame;
private HashMap branches;

/**
* Creates a new {@link AdviceAdapter}.
*
* @param mv the method visitor to which this adapter delegates
* calls.
* @param access the method’s access flags (see {@link Opcodes}).
* @param name the method’s name.
* @param desc the method’s descriptor (see {@link Type Type}).
*/
public AdviceAdapter(
final MethodVisitor mv,
final int access,
final String name,
final String desc){
super(mv, access, name, desc);
methodAccess = access;
methodDesc = desc;

constructor = "<init>".equals(name);
}

public void visitCode(){

mv.visitCode();
if(!constructor)
{
superInitialized = true;
onMethodEnter();
}
else
{
stackFrame = new ArrayList();
branches = new HashMap();
}
7.1. ADVICEADAPTER.JAVA 295

public void visitLabel(final Label label){

mv.visitLabel(label);

if(constructor && branches != null)

{
ArrayList frame = (ArrayList) branches.get(label);
if(frame != null)
{
stackFrame = frame;
branches.remove(label);
}
}
}

public void visitInsn(final int opcode){

if(constructor)
{
switch(opcode)
{
case RETURN: // empty stack
onMethodExit(opcode);
break;

case IRETURN: // 1 before n/a after

case FRETURN: // 1 before n/a after
case ARETURN: // 1 before n/a after
case ATHROW: // 1 before n/a after
popValue();
popValue();
onMethodExit(opcode);
break;

case LRETURN: // 2 before n/a after

case DRETURN: // 2 before n/a after
popValue();
popValue();
onMethodExit(opcode);
break;

case NOP:
case LALOAD: // remove 2 add 2
case DALOAD: // remove 2 add 2
case LNEG:
case DNEG:
case FNEG:
case INEG:
case L2D:
case D2L:
296 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

case F2I:
case I2B:
case I2C:
case I2S:
case I2F:
case Opcodes.ARRAYLENGTH:
break;

case ACONST_NULL:
case ICONST_M1:
case ICONST_0:
case ICONST_1:
case ICONST_2:
case ICONST_3:
case ICONST_4:
case ICONST_5:
case FCONST_0:
case FCONST_1:
case FCONST_2:
case F2L: // 1 before 2 after
case F2D:
case I2L:
case I2D:
pushValue(OTHER);
break;

case LCONST_0:
case LCONST_1:
case DCONST_0:
case DCONST_1:
pushValue(OTHER);
pushValue(OTHER);
break;

case IALOAD: // remove 2 add 1

case FALOAD: // remove 2 add 1
case AALOAD: // remove 2 add 1
case BALOAD: // remove 2 add 1
case CALOAD: // remove 2 add 1
case SALOAD: // remove 2 add 1
case POP:
case IADD:
case FADD:
case ISUB:
case LSHL: // 3 before 2 after
case LSHR: // 3 before 2 after
case LUSHR: // 3 before 2 after
case L2I: // 2 before 1 after
case L2F: // 2 before 1 after
case D2I: // 2 before 1 after
7.1. ADVICEADAPTER.JAVA 297

case D2F: // 2 before 1 after

case FSUB:
case FMUL:
case FDIV:
case FREM:
case FCMPL: // 2 before 1 after
case FCMPG: // 2 before 1 after
case IMUL:
case IDIV:
case IREM:
case ISHL:
case ISHR:
case IUSHR:
case IAND:
case IOR:
case IXOR:
case MONITORENTER:
case MONITOREXIT:
popValue();
break;

case POP2:
case LSUB:
case LMUL:
case LDIV:
case LREM:
case LADD:
case LAND:
case LOR:
case LXOR:
case DADD:
case DMUL:
case DSUB:
case DDIV:
case DREM:
popValue();
popValue();
break;

case IASTORE:
case FASTORE:
case AASTORE:
case BASTORE:
case CASTORE:
case SASTORE:
case LCMP: // 4 before 1 after
case DCMPL:
case DCMPG:
popValue();
popValue();
298 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

popValue();
break;

case LASTORE:
case DASTORE:
popValue();
popValue();
popValue();
popValue();
break;

case DUP:
pushValue(peekValue());
break;

case DUP_X1:
// TODO optimize this
{
Object o1 = popValue();
Object o2 = popValue();
pushValue(o1);
pushValue(o2);
pushValue(o1);
}
break;

case DUP_X2:
// TODO optimize this
{
Object o1 = popValue();
Object o2 = popValue();
Object o3 = popValue();
pushValue(o1);
pushValue(o3);
pushValue(o2);
pushValue(o1);
}
break;

case DUP2:
// TODO optimize this
{
Object o1 = popValue();
Object o2 = popValue();
pushValue(o2);
pushValue(o1);
pushValue(o2);
pushValue(o1);
}
break;
7.1. ADVICEADAPTER.JAVA 299

case DUP2_X1:
// TODO optimize this
{
Object o1 = popValue();
Object o2 = popValue();
Object o3 = popValue();
pushValue(o2);
pushValue(o1);
pushValue(o3);
pushValue(o2);
pushValue(o1);
}
break;

case DUP2_X2:
// TODO optimize this
{
Object o1 = popValue();
Object o2 = popValue();
Object o3 = popValue();
Object o4 = popValue();
pushValue(o2);
pushValue(o1);
pushValue(o4);
pushValue(o3);
pushValue(o2);
pushValue(o1);
}
break;

case SWAP:
{
Object o1 = popValue();
Object o2 = popValue();
pushValue(o1);
pushValue(o2);
}
break;
}
}
else
{
switch(opcode)
{
case RETURN:
case IRETURN:
case FRETURN:
case ARETURN:
case LRETURN:
300 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

case DRETURN:
case ATHROW:
onMethodExit(opcode);
break;
}
}
mv.visitInsn(opcode);
}

public void visitVarInsn(final int opcode, final int var){

super.visitVarInsn(opcode, var);

if(constructor)
{
switch(opcode)
{
case ILOAD:
case FLOAD:
pushValue(OTHER);
break;
case LLOAD:
case DLOAD:
pushValue(OTHER);
pushValue(OTHER);
break;
case ALOAD:
pushValue(var == 0 ? THIS : OTHER);
break;
case ASTORE:
case ISTORE:
case FSTORE:
popValue();
break;
case LSTORE:
case DSTORE:
popValue();
popValue();
break;
}
}
}

public void visitFieldInsn(

final int opcode,
final String owner,
final String name,
final String desc){
mv.visitFieldInsn(opcode, owner, name, desc);

if(constructor)
7.1. ADVICEADAPTER.JAVA 301

{
char c = desc.charAt(0);
boolean longOrDouble = c == ’J’ || c == ’D’;
switch(opcode)
{
case GETSTATIC:
pushValue(OTHER);
if(longOrDouble)
{
pushValue(OTHER);
}
break;
case PUTSTATIC:
popValue();
if(longOrDouble)
{
popValue();
}
break;
case PUTFIELD:
popValue();
if(longOrDouble)
{
popValue();
popValue();
}
break;
// case GETFIELD:
default:
if(longOrDouble)
{
pushValue(OTHER);
}
}
}
}

public void visitIntInsn(final int opcode, final int operand){

mv.visitIntInsn(opcode, operand);

if(constructor && opcode != NEWARRAY)

{
pushValue(OTHER);
}
}

public void visitLdcInsn(final Object cst){

mv.visitLdcInsn(cst);

if(constructor)
302 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

{
pushValue(OTHER);
if(cst instanceof Double || cst instanceof Long)
{
pushValue(OTHER);
}
}
}

public void visitMultiANewArrayInsn(final String desc, final int dims){

mv.visitMultiANewArrayInsn(desc, dims);

if(constructor)
{
for(int i = 0; i < dims; i++)
{
popValue();
}
pushValue(OTHER);
}
}

public void visitTypeInsn(final int opcode, final String name){

mv.visitTypeInsn(opcode, name);

// ANEWARRAY, CHECKCAST or INSTANCEOF don’t change stack

if(constructor && opcode == NEW)
{
pushValue(OTHER);
}
}

public void visitMethodInsn(

final int opcode,
final String owner,
final String name,
final String desc){
mv.visitMethodInsn(opcode, owner, name, desc);

if(constructor)
{
Type[] types = Type.getArgumentTypes(desc);
for(int i = 0; i < types.length; i++)
{
popValue();
if(types[i].getSize() == 2)
{
popValue();
}
}
7.1. ADVICEADAPTER.JAVA 303

switch(opcode)
{
// case INVOKESTATIC:
// break;

case INVOKEINTERFACE:
case INVOKEVIRTUAL:
popValue(); // objectref
break;

case INVOKESPECIAL:
Object type = popValue(); // objectref
if(type == THIS && !superInitialized)
{
onMethodEnter();
superInitialized = true;
// once super has been initialized it is no longer
// necessary to keep track of stack state
constructor = false;
}
break;
}

Type returnType = Type.getReturnType(desc);

if(returnType != Type.VOID_TYPE)
{
pushValue(OTHER);
if(returnType.getSize() == 2)
{
pushValue(OTHER);
}
}
}
}

public void visitJumpInsn(final int opcode, final Label label){

mv.visitJumpInsn(opcode, label);

if(constructor)
{
switch(opcode)
{
case IFEQ:
case IFNE:
case IFLT:
case IFGE:
case IFGT:
case IFLE:
case IFNULL:
case IFNONNULL:
304 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

popValue();
break;

case IF_ICMPEQ:
case IF_ICMPNE:
case IF_ICMPLT:
case IF_ICMPGE:
case IF_ICMPGT:
case IF_ICMPLE:
case IF_ACMPEQ:
case IF_ACMPNE:
popValue();
popValue();
break;

case JSR:
pushValue(OTHER);
break;
}
addBranch(label);
}
}

public void visitLookupSwitchInsn(

final Label dflt,
final int[] keys,
final Label[] labels){
mv.visitLookupSwitchInsn(dflt, keys, labels);

if(constructor)
{
popValue();
addBranches(dflt, labels);
}
}

public void visitTableSwitchInsn(

final int min,
final int max,
final Label dflt,
final Label[] labels){
mv.visitTableSwitchInsn(min, max, dflt, labels);

if(constructor)
{
popValue();
addBranches(dflt, labels);
}
}
7.1. ADVICEADAPTER.JAVA 305

private void addBranches(final Label dflt, final Label[] labels){

addBranch(dflt);
for(int i = 0; i < labels.length; i++)
{
addBranch(labels[i]);
}
}

private void addBranch(final Label label){

if(branches.containsKey(label))
{
return;
}
ArrayList frame = new ArrayList();
frame.addAll(stackFrame);
branches.put(label, frame);
}

private Object popValue(){

return stackFrame.remove(stackFrame.size() - 1);
}

private Object peekValue(){

return stackFrame.get(stackFrame.size() - 1);
}

private void pushValue(final Object o){

stackFrame.add(o);
}

/**
* Called at the beginning of the method or after super class class
* call in the constructor. 
* 
* Custom code can use or change all the local variables, but
* should not change state of the stack.
*/
protected abstract void onMethodEnter();

/**
* Called before explicit exit from the method using either return
* or throw. Top element on the stack contains the return value or
* exception instance.
* For example:
* 
* <pre>
* public void onMethodExit(int opcode) {
* if(opcode==RETURN) {
* visitInsn(ACONST_NULL);
* } else if(opcode==ARETURN || opcode==ATHROW) {
306 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

* dup();
* } else {
* if(opcode==LRETURN || opcode==DRETURN) {
* dup2();
* } else {
* dup();
* }
* box(Type.getReturnType(this.methodDesc));
* }
* visitIntInsn(SIPUSH, opcode);
* visitMethodInsn(INVOKESTATIC, owner, "onExit",
"(Ljava/lang/Object;I)V");
* }
* 
* // an actual call back method
* public static void onExit(int opcode, Object param) {
* ...
* </pre>
* 
* 
* 
* Custom code can use or change all the local variables, but should
* not change state of the stack.
*
* @param opcode one of the RETURN, IRETURN, FRETURN, ARETURN, LRETURN,
* DRETURN or ATHROW
*/
protected abstract void onMethodExit(int opcode);

// TODO onException, onMethodCall

———-

7.2 AnalyzerAdapter.java

— AnalyzerAdapter.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
7.2. ANALYZERADAPTER.JAVA 307

import clojure.asm.Label;
import clojure.asm.MethodAdapter;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;
import clojure.asm.Type;

/**
* A {@link MethodAdapter} that keeps track of stack map frame changes
* between
* {@link #visitFrame(int,int,Object[],int,Object[]) visitFrame} calls.
* This adapter must be used with the
* {@link clojure.asm.ClassReader#EXPAND_FRAMES} option. Each
* visitXXX instruction delegates to the next visitor in the
* chain, if any, and then simulates the effect of this instruction
* on the stack map frame, represented by {@link #locals} and
* {@link #stack}. The next visitor in the chain can get the state
* of the stack map frame before each instruction by reading
* the value of these fields in its visitXXX methods (this
* requires a reference to the AnalyzerAdapter that is before it
* in the chain).
*
* @author Eric Bruneton
*/
public class AnalyzerAdapter extends MethodAdapter{

/**
* <code>List</code> of the local variable slots for current execution
* frame. Primitive types are represented by {@link Opcodes#TOP},
* {@link Opcodes#INTEGER}, {@link Opcodes#FLOAT}, {@link Opcodes#LONG},
* {@link Opcodes#DOUBLE},{@link Opcodes#NULL} or
* {@link Opcodes#UNINITIALIZED_THIS} (long and double are represented
* by a two elements, the second one being TOP). Reference types are
* represented by String objects (representing internal names, or type
* descriptors for array types), and uninitialized types by Label
* objects (this label designates the NEW instruction that created
* this uninitialized value). This field is <tt>null</tt> for
* unreacheable instructions.
*/
public List locals;

/**
* <code>List</code> of the operand stack slots for current execution
* frame. Primitive types are represented by {@link Opcodes#TOP},
* {@link Opcodes#INTEGER}, {@link Opcodes#FLOAT}, {@link Opcodes#LONG},
* {@link Opcodes#DOUBLE},{@link Opcodes#NULL} or
* {@link Opcodes#UNINITIALIZED_THIS} (long and double are represented
* by a two elements, the second one being TOP). Reference types are
* represented by String objects (representing internal names, or type
* descriptors for array types), and uninitialized types by Label
* objects (this label designates the NEW instruction that created this
308 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

* uninitialized value). This field is <tt>null</tt> for unreacheable

* instructions.
*/
public List stack;

/**
* The labels that designate the next instruction to be visited. May be
* <tt>null</tt>.
*/
private List labels;

/**
* Information about uninitialized types in the current execution frame.
* This map associates internal names to Label objects. Each label
* designates a NEW instruction that created the currently uninitialized
* types, and the associated internal name represents the NEW operand,
* i.e. the final, initialized type value.
*/
private Map uninitializedTypes;

/**
* The maximum stack size of this method.
*/
private int maxStack;

/**
* The maximum number of local variables of this method.
*/
private int maxLocals;

/**
* Creates a new {@link AnalyzerAdapter}.
*
* @param owner the owner’s class name.
* @param access the method’s access flags (see {@link Opcodes}).
* @param name the method’s name.
* @param desc the method’s descriptor (see {@link Type Type}).
* @param mv the method visitor to which this adapter delegates
* calls. May be <tt>null</tt>.
*/
public AnalyzerAdapter(
final String owner,
final int access,
final String name,
final String desc,
final MethodVisitor mv){
super(mv);
locals = new ArrayList();
stack = new ArrayList();
uninitializedTypes = new HashMap();
7.2. ANALYZERADAPTER.JAVA 309

if((access & Opcodes.ACC_STATIC) == 0)

{
if(name.equals("<init>"))
{
locals.add(Opcodes.UNINITIALIZED_THIS);
}
else
{
locals.add(owner);
}
}
Type[] types = Type.getArgumentTypes(desc);
for(int i = 0; i < types.length; ++i)
{
Type type = types[i];
switch(type.getSort())
{
case Type.BOOLEAN:
case Type.CHAR:
case Type.BYTE:
case Type.SHORT:
case Type.INT:
locals.add(Opcodes.INTEGER);
break;
case Type.FLOAT:
locals.add(Opcodes.FLOAT);
break;
case Type.LONG:
locals.add(Opcodes.LONG);
locals.add(Opcodes.TOP);
break;
case Type.DOUBLE:
locals.add(Opcodes.DOUBLE);
locals.add(Opcodes.TOP);
break;
case Type.ARRAY:
locals.add(types[i].getDescriptor());
break;
// case Type.OBJECT:
default:
locals.add(types[i].getInternalName());
}
}
}

public void visitFrame(

final int type,
final int nLocal,
final Object[] local,
310 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

final int nStack,

final Object[] stack){
if(type != Opcodes.F_NEW)
{ // uncompressed frame
throw new IllegalStateException(
"ClassReader.accept() should be called with EXPAND_FRAMES flag");
}

if(mv != null)
{
mv.visitFrame(type, nLocal, local, nStack, stack);
}

if(this.locals != null)
{
this.locals.clear();
this.stack.clear();
}
else
{
this.locals = new ArrayList();
this.stack = new ArrayList();
}
visitFrameTypes(nLocal, local, this.locals);
visitFrameTypes(nStack, stack, this.stack);
maxStack = Math.max(maxStack, this.stack.size());
}

private void visitFrameTypes(

final int n,
final Object[] types,
final List result){
for(int i = 0; i < n; ++i)
{
Object type = types[i];
result.add(type);
if(type == Opcodes.LONG || type == Opcodes.DOUBLE)
{
result.add(Opcodes.TOP);
}
}
}

public void visitInsn(final int opcode){

if(mv != null)
{
mv.visitInsn(opcode);
}
execute(opcode, 0, null);
if((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
7.2. ANALYZERADAPTER.JAVA 311

|| opcode == Opcodes.ATHROW)
{
this.locals = null;
this.stack = null;
}
}

public void visitIntInsn(final int opcode, final int operand){

if(mv != null)
{
mv.visitIntInsn(opcode, operand);
}
execute(opcode, operand, null);
}

public void visitVarInsn(final int opcode, final int var){

if(mv != null)
{
mv.visitVarInsn(opcode, var);
}
execute(opcode, var, null);
}

public void visitTypeInsn(final int opcode, final String desc){

if(opcode == Opcodes.NEW)
{
if(labels == null)
{
Label l = new Label();
labels = new ArrayList(3);
labels.add(l);
if(mv != null)
{
mv.visitLabel(l);
}
}
for(int i = 0; i < labels.size(); ++i)
{
uninitializedTypes.put(labels.get(i), desc);
}
}
if(mv != null)
{
mv.visitTypeInsn(opcode, desc);
}
execute(opcode, 0, desc);
}

public void visitFieldInsn(

final int opcode,
312 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

final String owner,

final String name,
final String desc){
if(mv != null)
{
mv.visitFieldInsn(opcode, owner, name, desc);
}
execute(opcode, 0, desc);
}

public void visitMethodInsn(

final int opcode,
final String owner,
final String name,
final String desc){
if(mv != null)
{
mv.visitMethodInsn(opcode, owner, name, desc);
}
pop(desc);
if(opcode != Opcodes.INVOKESTATIC)
{
Object t = pop();
if(opcode == Opcodes.INVOKESPECIAL && name.charAt(0) == ’<’)
{
Object u;
if(t == Opcodes.UNINITIALIZED_THIS)
{
u = owner;
}
else
{
u = uninitializedTypes.get(t);
}
for(int i = 0; i < locals.size(); ++i)
{
if(locals.get(i) == t)
{
locals.set(i, u);
}
}
for(int i = 0; i < stack.size(); ++i)
{
if(stack.get(i) == t)
{
stack.set(i, u);
}
}
}
}
7.2. ANALYZERADAPTER.JAVA 313

pushDesc(desc);
labels = null;
}

public void visitJumpInsn(final int opcode, final Label label){

if(mv != null)
{
mv.visitJumpInsn(opcode, label);
}
execute(opcode, 0, null);
if(opcode == Opcodes.GOTO)
{
this.locals = null;
this.stack = null;
}
}

public void visitLabel(final Label label){

if(mv != null)
{
mv.visitLabel(label);
}
if(labels == null)
{
labels = new ArrayList(3);
}
labels.add(label);
}

public void visitLdcInsn(final Object cst){

if(mv != null)
{
mv.visitLdcInsn(cst);
}
if(cst instanceof Integer)
{
push(Opcodes.INTEGER);
}
else if(cst instanceof Long)
{
push(Opcodes.LONG);
push(Opcodes.TOP);
}
else if(cst instanceof Float)
{
push(Opcodes.FLOAT);
}
else if(cst instanceof Double)
{
push(Opcodes.DOUBLE);
314 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

push(Opcodes.TOP);
}
else if(cst instanceof String)
{
push("java/lang/String");
}
else if(cst instanceof Type)
{
push("java/lang/Class");
}
else
{
throw new IllegalArgumentException();
}
labels = null;
}

public void visitIincInsn(final int var, final int increment){

if(mv != null)
{
mv.visitIincInsn(var, increment);
}
execute(Opcodes.IINC, var, null);
}

public void visitTableSwitchInsn(

final int min,
final int max,
final Label dflt,
final Label labels[]){
if(mv != null)
{
mv.visitTableSwitchInsn(min, max, dflt, labels);
}
execute(Opcodes.TABLESWITCH, 0, null);
this.locals = null;
this.stack = null;
}

public void visitLookupSwitchInsn(

final Label dflt,
final int keys[],
final Label labels[]){
if(mv != null)
{
mv.visitLookupSwitchInsn(dflt, keys, labels);
}
execute(Opcodes.LOOKUPSWITCH, 0, null);
this.locals = null;
this.stack = null;
7.2. ANALYZERADAPTER.JAVA 315

public void visitMultiANewArrayInsn(final String desc, final int dims){

if(mv != null)
{
mv.visitMultiANewArrayInsn(desc, dims);
}
execute(Opcodes.MULTIANEWARRAY, dims, desc);
}

public void visitMaxs(final int maxStack, final int maxLocals){

if(mv != null)
{
this.maxStack = Math.max(this.maxStack, maxStack);
this.maxLocals = Math.max(this.maxLocals, maxLocals);
mv.visitMaxs(this.maxStack, this.maxLocals);
}
}

// -------------------------------------------------------------------

private Object get(final int local){

maxLocals = Math.max(maxLocals, local);
return local < locals.size() ? locals.get(local) : Opcodes.TOP;
}

private void set(final int local, final Object type){

maxLocals = Math.max(maxLocals, local);
while(local >= locals.size())
{
locals.add(Opcodes.TOP);
}
locals.set(local, type);
}

private void push(final Object type){

stack.add(type);
maxStack = Math.max(maxStack, stack.size());
}

private void pushDesc(final String desc){

int index = desc.charAt(0) == ’(’ ? desc.indexOf(’)’) + 1 : 0;
switch(desc.charAt(index))
{
case’V’:
return;
case’Z’:
case’C’:
case’B’:
case’S’:
316 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

case’I’:
push(Opcodes.INTEGER);
return;
case’F’:
push(Opcodes.FLOAT);
return;
case’J’:
push(Opcodes.LONG);
push(Opcodes.TOP);
return;
case’D’:
push(Opcodes.DOUBLE);
push(Opcodes.TOP);
return;
case’[’:
if(index == 0)
{
push(desc);
}
else
{
push(desc.substring(index, desc.length()));
}
break;
// case ’L’:
default:
if(index == 0)
{
push(desc.substring(1, desc.length() - 1));
}
else
{
push(desc.substring(index + 1, desc.length() - 1));
}
return;
}
}

private Object pop(){

return stack.remove(stack.size() - 1);
}

private void pop(final int n){

int size = stack.size();
int end = size - n;
for(int i = size - 1; i >= end; --i)
{
stack.remove(i);
}
}
7.2. ANALYZERADAPTER.JAVA 317

private void pop(final String desc){

char c = desc.charAt(0);
if(c == ’(’)
{
int n = 0;
Type[] types = Type.getArgumentTypes(desc);
for(int i = 0; i < types.length; ++i)
{
n += types[i].getSize();
}
pop(n);
}
else if(c == ’J’ || c == ’D’)
{
pop(2);
}
else
{
pop(1);
}
}

private void execute(final int opcode,

final int iarg,
final String sarg){
if(this.locals == null)
{
return;
}
Object t1, t2, t3, t4;
switch(opcode)
{
case Opcodes.NOP:
case Opcodes.INEG:
case Opcodes.LNEG:
case Opcodes.FNEG:
case Opcodes.DNEG:
case Opcodes.I2B:
case Opcodes.I2C:
case Opcodes.I2S:
case Opcodes.GOTO:
case Opcodes.RETURN:
break;
case Opcodes.ACONST_NULL:
push(Opcodes.NULL);
break;
case Opcodes.ICONST_M1:
case Opcodes.ICONST_0:
case Opcodes.ICONST_1:
318 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

case Opcodes.ICONST_2:
case Opcodes.ICONST_3:
case Opcodes.ICONST_4:
case Opcodes.ICONST_5:
case Opcodes.BIPUSH:
case Opcodes.SIPUSH:
push(Opcodes.INTEGER);
break;
case Opcodes.LCONST_0:
case Opcodes.LCONST_1:
push(Opcodes.LONG);
push(Opcodes.TOP);
break;
case Opcodes.FCONST_0:
case Opcodes.FCONST_1:
case Opcodes.FCONST_2:
push(Opcodes.FLOAT);
break;
case Opcodes.DCONST_0:
case Opcodes.DCONST_1:
push(Opcodes.DOUBLE);
push(Opcodes.TOP);
break;
case Opcodes.ILOAD:
case Opcodes.FLOAD:
case Opcodes.ALOAD:
push(get(iarg));
break;
case Opcodes.LLOAD:
case Opcodes.DLOAD:
push(get(iarg));
push(Opcodes.TOP);
break;
case Opcodes.IALOAD:
case Opcodes.BALOAD:
case Opcodes.CALOAD:
case Opcodes.SALOAD:
pop(2);
push(Opcodes.INTEGER);
break;
case Opcodes.LALOAD:
case Opcodes.D2L:
pop(2);
push(Opcodes.LONG);
push(Opcodes.TOP);
break;
case Opcodes.FALOAD:
pop(2);
push(Opcodes.FLOAT);
break;
7.2. ANALYZERADAPTER.JAVA 319

case Opcodes.DALOAD:
case Opcodes.L2D:
pop(2);
push(Opcodes.DOUBLE);
push(Opcodes.TOP);
break;
case Opcodes.AALOAD:
pop(1);
t1 = pop();
pushDesc(((String) t1).substring(1));
break;
case Opcodes.ISTORE:
case Opcodes.FSTORE:
case Opcodes.ASTORE:
t1 = pop();
set(iarg, t1);
if(iarg > 0)
{
t2 = get(iarg - 1);
if(t2 == Opcodes.LONG || t2 == Opcodes.DOUBLE)
{
set(iarg - 1, Opcodes.TOP);
}
}
break;
case Opcodes.LSTORE:
case Opcodes.DSTORE:
pop(1);
t1 = pop();
set(iarg, t1);
set(iarg + 1, Opcodes.TOP);
if(iarg > 0)
{
t2 = get(iarg - 1);
if(t2 == Opcodes.LONG || t2 == Opcodes.DOUBLE)
{
set(iarg - 1, Opcodes.TOP);
}
}
break;
case Opcodes.IASTORE:
case Opcodes.BASTORE:
case Opcodes.CASTORE:
case Opcodes.SASTORE:
case Opcodes.FASTORE:
case Opcodes.AASTORE:
pop(3);
break;
case Opcodes.LASTORE:
case Opcodes.DASTORE:
320 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

case Opcodes.ISHR:
case Opcodes.IUSHR:
case Opcodes.L2I:
case Opcodes.D2I:
case Opcodes.FCMPL:
case Opcodes.FCMPG:
pop(2);
push(Opcodes.INTEGER);
break;
case Opcodes.LADD:
case Opcodes.LSUB:
case Opcodes.LMUL:
case Opcodes.LDIV:
case Opcodes.LREM:
case Opcodes.LAND:
case Opcodes.LOR:
case Opcodes.LXOR:
pop(4);
push(Opcodes.LONG);
push(Opcodes.TOP);
break;
case Opcodes.FADD:
case Opcodes.FSUB:
case Opcodes.FMUL:
case Opcodes.FDIV:
case Opcodes.FREM:
case Opcodes.L2F:
case Opcodes.D2F:
pop(2);
push(Opcodes.FLOAT);
break;
case Opcodes.DADD:
case Opcodes.DSUB:
case Opcodes.DMUL:
case Opcodes.DDIV:
case Opcodes.DREM:
pop(4);
push(Opcodes.DOUBLE);
push(Opcodes.TOP);
break;
case Opcodes.LSHL:
case Opcodes.LSHR:
case Opcodes.LUSHR:
pop(3);
push(Opcodes.LONG);
push(Opcodes.TOP);
break;
case Opcodes.IINC:
set(iarg, Opcodes.INTEGER);
break;
7.2. ANALYZERADAPTER.JAVA 323

case Opcodes.I2L:
case Opcodes.F2L:
pop(1);
push(Opcodes.LONG);
push(Opcodes.TOP);
break;
case Opcodes.I2F:
pop(1);
push(Opcodes.FLOAT);
break;
case Opcodes.I2D:
case Opcodes.F2D:
pop(1);
push(Opcodes.DOUBLE);
push(Opcodes.TOP);
break;
case Opcodes.F2I:
case Opcodes.ARRAYLENGTH:
case Opcodes.INSTANCEOF:
pop(1);
push(Opcodes.INTEGER);
break;
case Opcodes.LCMP:
case Opcodes.DCMPL:
case Opcodes.DCMPG:
pop(4);
push(Opcodes.INTEGER);
break;
case Opcodes.JSR:
case Opcodes.RET:
throw new RuntimeException("JSR/RET are not supported");
case Opcodes.GETSTATIC:
pushDesc(sarg);
break;
case Opcodes.PUTSTATIC:
pop(sarg);
break;
case Opcodes.GETFIELD:
pop(1);
pushDesc(sarg);
break;
case Opcodes.PUTFIELD:
pop(sarg);
pop();
break;
case Opcodes.NEW:
push(labels.get(0));
break;
case Opcodes.NEWARRAY:
pop();
324 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

switch(iarg)
{
case Opcodes.T_BOOLEAN:
pushDesc("[Z");
break;
case Opcodes.T_CHAR:
pushDesc("[C");
break;
case Opcodes.T_BYTE:
pushDesc("[B");
break;
case Opcodes.T_SHORT:
pushDesc("[S");
break;
case Opcodes.T_INT:
pushDesc("[I");
break;
case Opcodes.T_FLOAT:
pushDesc("[F");
break;
case Opcodes.T_DOUBLE:
pushDesc("[D");
break;
// case Opcodes.T_LONG:
default:
pushDesc("[J");
break;
}
break;
case Opcodes.ANEWARRAY:
pop();
if(sarg.charAt(0) == ’[’)
{
pushDesc("[" + sarg);
}
else
{
pushDesc("[L" + sarg + ";");
}
break;
case Opcodes.CHECKCAST:
pop();
if(sarg.charAt(0) == ’[’)
{
pushDesc(sarg);
}
else
{
push(sarg);
}
7.3. CODESIZEEVALUATOR.JAVA 325

break;
// case Opcodes.MULTIANEWARRAY:
default:
pop(iarg);
pushDesc(sarg);
break;
}
labels = null;
}
}

———-

7.3 CodeSizeEvaluator.java

— CodeSizeEvaluator.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import clojure.asm.Label;
import clojure.asm.MethodAdapter;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;

/**
* A {@link MethodAdapter} that can be used to approximate method size.
*
* @author Eugene Kuleshov
*/
public class CodeSizeEvaluator extends MethodAdapter implements Opcodes{

private int minSize;

private int maxSize;

public CodeSizeEvaluator(final MethodVisitor mv){

super(mv);
}

public int getMinSize(){

return this.minSize;
}

public int getMaxSize(){

return this.maxSize;
}
326 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

public void visitInsn(final int opcode){

minSize += 1;
maxSize += 1;
if(mv != null)
{
mv.visitInsn(opcode);
}
}

public void visitIntInsn(final int opcode, final int operand){

if(opcode == SIPUSH)
{
minSize += 3;
maxSize += 3;
}
else
{
minSize += 2;
maxSize += 2;
}
if(mv != null)
{
mv.visitIntInsn(opcode, operand);
}
}

public void visitVarInsn(final int opcode, final int var){

if(var < 4 && opcode != Opcodes.RET)
{
minSize += 1;
maxSize += 1;
}
else if(var >= 256)
{
minSize += 4;
maxSize += 4;
}
else
{
minSize += 2;
maxSize += 2;
}
if(mv != null)
{
mv.visitVarInsn(opcode, var);
}
}

public void visitTypeInsn(final int opcode, final String desc){

7.3. CODESIZEEVALUATOR.JAVA 327

minSize += 3;
maxSize += 3;
if(mv != null)
{
mv.visitTypeInsn(opcode, desc);
}
}

public void visitFieldInsn(

final int opcode,
final String owner,
final String name,
final String desc){
minSize += 3;
maxSize += 3;
if(mv != null)
{
mv.visitFieldInsn(opcode, owner, name, desc);
}
}

public void visitMethodInsn(

final int opcode,
final String owner,
final String name,
final String desc){
if(opcode == INVOKEINTERFACE)
{
minSize += 5;
maxSize += 5;
}
else
{
minSize += 3;
maxSize += 3;
}
if(mv != null)
{
mv.visitMethodInsn(opcode, owner, name, desc);
}
}

public void visitJumpInsn(final int opcode, final Label label){

minSize += 3;
if(opcode == GOTO || opcode == JSR)
{
maxSize += 5;
}
else
{
328 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

maxSize += 8;
}
if(mv != null)
{
mv.visitJumpInsn(opcode, label);
}
}

public void visitLdcInsn(final Object cst){

if(cst instanceof Long || cst instanceof Double)
{
minSize += 3;
maxSize += 3;
}
else
{
minSize += 2;
maxSize += 3;
}
if(mv != null)
{
mv.visitLdcInsn(cst);
}
}

public void visitIincInsn(final int var, final int increment){

if(var > 255 || increment > 127 || increment < -128)
{
minSize += 6;
maxSize += 6;
}
else
{
minSize += 3;
maxSize += 3;
}
if(mv != null)
{
mv.visitIincInsn(var, increment);
}
}

public void visitTableSwitchInsn(

final int min,
final int max,
final Label dflt,
final Label[] labels){
minSize += 13 + labels.length * 4;
maxSize += 16 + labels.length * 4;
if(mv != null)
7.4. EMPTYVISITOR.JAVA 329

{
mv.visitTableSwitchInsn(min, max, dflt, labels);
}
}

public void visitLookupSwitchInsn(

final Label dflt,
final int[] keys,
final Label[] labels){
minSize += 9 + keys.length * 8;
maxSize += 12 + keys.length * 8;
if(mv != null)
{
mv.visitLookupSwitchInsn(dflt, keys, labels);
}
}

public void visitMultiANewArrayInsn(final String desc, final int dims){

minSize += 4;
maxSize += 4;
if(mv != null)
{
mv.visitMultiANewArrayInsn(desc, dims);
}
}
}

———-

7.4 EmptyVisitor.java

— EmptyVisitor.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

final String name,
final String desc){
return this;
}

public AnnotationVisitor visitArray(final String name){

return this;
}
}

———-

7.5 GeneratorAdapter.java

— GeneratorAdapter.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import clojure.asm.ClassVisitor;
import clojure.asm.Label;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;
334 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

import clojure.asm.Type;

/**
* A {@link clojure.asm.MethodAdapter} with convenient methods to
* generate code. For example, using this adapter, the class below
* 
* <pre>
* public class Example {
* public static void main(String[] args) {
* System.out.println("Hello world!");
* }
* }
* </pre>
* 
* can be generated as follows:
* 
* <pre>
* ClassWriter cw = new ClassWriter(true);
* cw.visit(V1_1, ACC_PUBLIC, "Example", null,
* "java/lang/Object", null);
* 
* Method m = Method.getMethod("void <init> ()");
* GeneratorAdapter mg =
* new GeneratorAdapter(ACC_PUBLIC, m, null, null, cw);
* mg.loadThis();
* mg.invokeConstructor(Type.getType(Object.class), m);
* mg.returnValue();
* mg.endMethod();
* 
* m = Method.getMethod("void main (String[])");
* mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);
* mg.getStatic(Type.getType(System.class), "out",
* Type.getType(PrintStream.class));
* mg.push("Hello world!");
* mg.invokeVirtual(Type.getType(PrintStream.class),
* Method.getMethod("void println (String)"));
* mg.returnValue();
* mg.endMethod();
* 
* cw.visitEnd();
* </pre>
*
* @author Juozas Baliuka
* @author Chris Nokleberg
* @author Eric Bruneton
*/
public class GeneratorAdapter extends LocalVariablesSorter{

private final static Type BYTE_TYPE =

Type.getObjectType("java/lang/Byte");
7.5. GENERATORADAPTER.JAVA 335

private final static Type BOOLEAN_TYPE =

Type.getObjectType("java/lang/Boolean");

private final static Type SHORT_TYPE =

Type.getObjectType("java/lang/Short");

private final static Type CHARACTER_TYPE =

Type.getObjectType("java/lang/Character");

private final static Type INTEGER_TYPE =

Type.getObjectType("java/lang/Integer");

private final static Type FLOAT_TYPE =

Type.getObjectType("java/lang/Float");

private final static Type LONG_TYPE =

Type.getObjectType("java/lang/Long");

private final static Type DOUBLE_TYPE =

Type.getObjectType("java/lang/Double");

private final static Type NUMBER_TYPE =

Type.getObjectType("java/lang/Number");

private final static Type OBJECT_TYPE =

Type.getObjectType("java/lang/Object");

private final static Method BOOLEAN_VALUE =

Method.getMethod("boolean booleanValue()");

private final static Method CHAR_VALUE =

Method.getMethod("char charValue()");

private final static Method INT_VALUE =

Method.getMethod("int intValue()");

private final static Method FLOAT_VALUE =

Method.getMethod("float floatValue()");

private final static Method LONG_VALUE =

Method.getMethod("long longValue()");

private final static Method DOUBLE_VALUE =

Method.getMethod("double doubleValue()");

/**
* Constant for the {@link #math math} method.
*/
public final static int ADD = Opcodes.IADD;
336 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

/**
* Constant for the {@link #math math} method.
*/
public final static int SUB = Opcodes.ISUB;

/**
* Constant for the {@link #math math} method.
*/
public final static int MUL = Opcodes.IMUL;

/**
* Constant for the {@link #math math} method.
*/
public final static int DIV = Opcodes.IDIV;

/**
* Constant for the {@link #math math} method.
*/
public final static int REM = Opcodes.IREM;

/**
* Constant for the {@link #math math} method.
*/
public final static int NEG = Opcodes.INEG;

/**
* Constant for the {@link #math math} method.
*/
public final static int SHL = Opcodes.ISHL;

/**
* Constant for the {@link #math math} method.
*/
public final static int SHR = Opcodes.ISHR;

/**
* Constant for the {@link #math math} method.
*/
public final static int USHR = Opcodes.IUSHR;

/**
* Constant for the {@link #math math} method.
*/
public final static int AND = Opcodes.IAND;

/**
* Constant for the {@link #math math} method.
*/
public final static int OR = Opcodes.IOR;
7.5. GENERATORADAPTER.JAVA 337

/**
* Constant for the {@link #math math} method.
*/
public final static int XOR = Opcodes.IXOR;

/**
* Constant for the {@link #ifCmp ifCmp} method.
*/
public final static int EQ = Opcodes.IFEQ;

/**
* Constant for the {@link #ifCmp ifCmp} method.
*/
public final static int NE = Opcodes.IFNE;

/**
* Constant for the {@link #ifCmp ifCmp} method.
*/
public final static int LT = Opcodes.IFLT;

/**
* Constant for the {@link #ifCmp ifCmp} method.
*/
public final static int GE = Opcodes.IFGE;

/**
* Constant for the {@link #ifCmp ifCmp} method.
*/
public final static int GT = Opcodes.IFGT;

/**
* Constant for the {@link #ifCmp ifCmp} method.
*/
public final static int LE = Opcodes.IFLE;

/**
* Access flags of the method visited by this adapter.
*/
private final int access;

/**
* Return type of the method visited by this adapter.
*/
private final Type returnType;

/**
* Argument types of the method visited by this adapter.
*/
private final Type[] argumentTypes;
338 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

/**
* Types of the local variables of the method visited by this adapter.
*/
private final List localTypes = new ArrayList();

/**
* Creates a new {@link GeneratorAdapter}.
*
* @param mv the method visitor to which this adapter delegates
* calls.
* @param access the method’s access flags (see {@link Opcodes}).
* @param name the method’s name.
* @param desc the method’s descriptor (see {@link Type Type}).
*/
public GeneratorAdapter(
final MethodVisitor mv,
final int access,
final String name,
final String desc){
super(access, desc, mv);
this.access = access;
this.returnType = Type.getReturnType(desc);
this.argumentTypes = Type.getArgumentTypes(desc);
}

/**
* Creates a new {@link GeneratorAdapter}.
*
* @param access access flags of the adapted method.
* @param method the adapted method.
* @param mv the method visitor to which this adapter delegates
* calls.
*/
public GeneratorAdapter(
final int access,
final Method method,
final MethodVisitor mv){
super(access, method.getDescriptor(), mv);
this.access = access;
this.returnType = method.getReturnType();
this.argumentTypes = method.getArgumentTypes();
}

/**
* Creates a new {@link GeneratorAdapter}.
*
* @param access access flags of the adapted method.
* @param method the adapted method.
* @param signature the signature of the adapted method (may be
7.5. GENERATORADAPTER.JAVA 339

* <tt>null</tt>).
* @param exceptions the exceptions thrown by the adapted method
* (may be <tt>null</tt>).
* @param cv the class visitor to which this adapter delegates
* calls.
*/
public GeneratorAdapter(
final int access,
final Method method,
final String signature,
final Type[] exceptions,
final ClassVisitor cv){
this(access, method, cv.visitMethod(access,
method.getName(),
method.getDescriptor(),
signature,
getInternalNames(exceptions)));
}

/**
* Returns the internal names of the given types.
*
* @param types a set of types.
* @return the internal names of the given types.
*/
private static String[] getInternalNames(final Type[] types){
if(types == null)
{
return null;
}
String[] names = new String[types.length];
for(int i = 0; i < names.length; ++i)
{
names[i] = types[i].getInternalName();
}
return names;
}

// -------------------------------------------------------------------
// Instructions to push constants on the stack
// -------------------------------------------------------------------

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack.
*/
public void push(final boolean value){
push(value ? 1 : 0);
}
340 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack.
*/
public void push(final int value){
if(value >= -1 && value <= 5)
{
mv.visitInsn(Opcodes.ICONST_0 + value);
}
else if(value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE)
{
mv.visitIntInsn(Opcodes.BIPUSH, value);
}
else if(value >= Short.MIN_VALUE && value <= Short.MAX_VALUE)
{
mv.visitIntInsn(Opcodes.SIPUSH, value);
}
else
{
mv.visitLdcInsn(new Integer(value));
}
}

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack.
*/
public void push(final long value){
if(value == 0L || value == 1L)
{
mv.visitInsn(Opcodes.LCONST_0 + (int) value);
}
else
{
mv.visitLdcInsn(new Long(value));
}
}

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack.
*/
public void push(final float value){
int bits = Float.floatToIntBits(value);
if(bits == 0L || bits == 0x3f800000 || bits == 0x40000000)
{ // 0..2
7.5. GENERATORADAPTER.JAVA 341

mv.visitInsn(Opcodes.FCONST_0 + (int) value);

}
else
{
mv.visitLdcInsn(new Float(value));
}
}

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack.
*/
public void push(final double value){
long bits = Double.doubleToLongBits(value);
if(bits == 0L || bits == 0x3ff0000000000000L)
{ // +0.0d and 1.0d
mv.visitInsn(Opcodes.DCONST_0 + (int) value);
}
else
{
mv.visitLdcInsn(new Double(value));
}
}

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack. May be
* <tt>null</tt>.
*/
public void push(final String value){
if(value == null)
{
mv.visitInsn(Opcodes.ACONST_NULL);
}
else
{
mv.visitLdcInsn(value);
}
}

/**
* Generates the instruction to push the given value on the stack.
*
* @param value the value to be pushed on the stack.
*/
public void push(final Type value){
if(value == null)
{
342 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

mv.visitInsn(Opcodes.ACONST_NULL);
}
else
{
mv.visitLdcInsn(value);
}
}

// -------------------------------------------------------------------
// Instructions to load and store method arguments
// ------------------------------------------------------------------

/**
* Returns the index of the given method argument in the frame’s local
* variables array.
*
* @param arg the index of a method argument.
* @return the index of the given method argument in the frame’s local
* variables array.
*/
private int getArgIndex(final int arg){
int index = (access & Opcodes.ACC_STATIC) == 0 ? 1 : 0;
for(int i = 0; i < arg; i++)
{
index += argumentTypes[i].getSize();
}
return index;
}

/**
* Generates the instruction to push a local variable on the stack.
*
* @param type the type of the local variable to be loaded.
* @param index an index in the frame’s local variables array.
*/
private void loadInsn(final Type type, final int index){
mv.visitVarInsn(type.getOpcode(Opcodes.ILOAD), index);
}

/**
* Generates the instruction to store the top stack value in a local
* variable.
*
* @param type the type of the local variable to be stored.
* @param index an index in the frame’s local variables array.
*/
private void storeInsn(final Type type, final int index){
mv.visitVarInsn(type.getOpcode(Opcodes.ISTORE), index);
}
7.5. GENERATORADAPTER.JAVA 343

/**
* Generates the instruction to load ’this’ on the stack.
*/
public void loadThis(){
if((access & Opcodes.ACC_STATIC) != 0)
{
throw new IllegalStateException(
"no ’this’ pointer within static method");
}
mv.visitVarInsn(Opcodes.ALOAD, 0);
}

/**
* Generates the instruction to load the given method argument
* on the stack.
*
* @param arg the index of a method argument.
*/
public void loadArg(final int arg){
loadInsn(argumentTypes[arg], getArgIndex(arg));
}

/**
* Generates the instructions to load the given method arguments
* on the stack.
*
* @param arg the index of the first method argument to be loaded.
* @param count the number of method arguments to be loaded.
*/
public void loadArgs(final int arg, final int count){
int index = getArgIndex(arg);
for(int i = 0; i < count; ++i)
{
Type t = argumentTypes[arg + i];
loadInsn(t, index);
index += t.getSize();
}
}

/**
* Generates the instructions to load all the method arguments
* on the stack.
*/
public void loadArgs(){
loadArgs(0, argumentTypes.length);
}

/**
* Generates the instructions to load all the method arguments
* on the stack, as a single object array.
344 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*/
public void loadArgArray(){
push(argumentTypes.length);
newArray(OBJECT_TYPE);
for(int i = 0; i < argumentTypes.length; i++)
{
dup();
push(i);
loadArg(i);
box(argumentTypes[i]);
arrayStore(OBJECT_TYPE);
}
}

/**
* Generates the instruction to store the top stack value in the given
* method argument.
*
* @param arg the index of a method argument.
*/
public void storeArg(final int arg){
storeInsn(argumentTypes[arg], getArgIndex(arg));
}

// -------------------------------------------------------------------
// Instructions to load and store local variables
// -------------------------------------------------------------------

/**
* Returns the type of the given local variable.
*
* @param local a local variable identifier, as returned by
* {@link LocalVariablesSorter#newLocal(Type) newLocal()}.
* @return the type of the given local variable.
*/
public Type getLocalType(final int local){
return (Type) localTypes.get(local - firstLocal);
}

protected void setLocalType(final int local, final Type type){

int index = local - firstLocal;
while(localTypes.size() < index + 1)
{
localTypes.add(null);
}
localTypes.set(index, type);
}

/**
* Generates the instruction to load the given local variable
7.5. GENERATORADAPTER.JAVA 345

* on the stack.
*
* @param local a local variable identifier, as returned by
* {@link LocalVariablesSorter#newLocal(Type) newLocal()}.
*/
public void loadLocal(final int local){
loadInsn(getLocalType(local), local);
}

/**
* Generates the instruction to load the given local variable
* on the stack.
*
* @param local a local variable identifier, as returned by
* {@link LocalVariablesSorter#newLocal(Type) newLocal()}.
* @param type the type of this local variable.
*/
public void loadLocal(final int local, final Type type){
setLocalType(local, type);
loadInsn(type, local);
}

/**
* Generates the instruction to store the top stack value in the given
* local variable.
*
* @param local a local variable identifier, as returned by
* {@link LocalVariablesSorter#newLocal(Type) newLocal()}.
*/
public void storeLocal(final int local){
storeInsn(getLocalType(local), local);
}

/**
* Generates the instruction to store the top stack value in the given
* local variable.
*
* @param local a local variable identifier, as returned by
* {@link LocalVariablesSorter#newLocal(Type) newLocal()}.
* @param type the type of this local variable.
*/
public void storeLocal(final int local, final Type type){
setLocalType(local, type);
storeInsn(type, local);
}

/**
* Generates the instruction to load an element from an array.
*
* @param type the type of the array element to be loaded.
346 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*/
public void arrayLoad(final Type type){
mv.visitInsn(type.getOpcode(Opcodes.IALOAD));
}

/**
* Generates the instruction to store an element in an array.
*
* @param type the type of the array element to be stored.
*/
public void arrayStore(final Type type){
mv.visitInsn(type.getOpcode(Opcodes.IASTORE));
}

// -------------------------------------------------------------------
// Instructions to manage the stack
// -------------------------------------------------------------------

/**
* Generates a POP instruction.
*/
public void pop(){
mv.visitInsn(Opcodes.POP);
}

/**
* Generates a POP2 instruction.
*/
public void pop2(){
mv.visitInsn(Opcodes.POP2);
}

/**
* Generates a DUP instruction.
*/
public void dup(){
mv.visitInsn(Opcodes.DUP);
}

/**
* Generates a DUP2 instruction.
*/
public void dup2(){
mv.visitInsn(Opcodes.DUP2);
}

/**
* Generates a DUP_X1 instruction.
*/
public void dupX1(){
7.5. GENERATORADAPTER.JAVA 347

mv.visitInsn(Opcodes.DUP_X1);
}

/**
* Generates a DUP_X2 instruction.
*/
public void dupX2(){
mv.visitInsn(Opcodes.DUP_X2);
}

/**
* Generates a DUP2_X1 instruction.
*/
public void dup2X1(){
mv.visitInsn(Opcodes.DUP2_X1);
}

/**
* Generates a DUP2_X2 instruction.
*/
public void dup2X2(){
mv.visitInsn(Opcodes.DUP2_X2);
}

/**
* Generates a SWAP instruction.
*/
public void swap(){
mv.visitInsn(Opcodes.SWAP);
}

/**
* Generates the instructions to swap the top two stack values.
*
* @param prev type of the top - 1 stack value.
* @param type type of the top stack value.
*/
public void swap(final Type prev, final Type type){
if(type.getSize() == 1)
{
if(prev.getSize() == 1)
{
swap(); // same as dupX1(), pop();
}
else
{
dupX2();
pop();
}
}
348 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

else
{
if(prev.getSize() == 1)
{
dup2X1();
pop2();
}
else
{
dup2X2();
pop2();
}
}
}

// -------------------------------------------------------------------
// Instructions to do mathematical and logical operations
// -------------------------------------------------------------------

/**
* Generates the instruction to do the specified mathematical or logical
* operation.
*
* @param op a mathematical or logical operation. Must be one of ADD,
* SUB, MUL, DIV, REM, NEG, SHL, SHR, USHR, AND, OR, XOR.
* @param type the type of the operand(s) for this operation.
*/
public void math(final int op, final Type type){
mv.visitInsn(type.getOpcode(op));
}

/**
* Generates the instructions to compute the bitwise negation of the top
* stack value.
*/
public void not(){
mv.visitInsn(Opcodes.ICONST_1);
mv.visitInsn(Opcodes.IXOR);
}

/**
* Generates the instruction to increment the given local variable.
*
* @param local the local variable to be incremented.
* @param amount the amount by which the local variable must be
* incremented.
*/
public void iinc(final int local, final int amount){
mv.visitIincInsn(local, amount);
}
7.5. GENERATORADAPTER.JAVA 349

/**
* Generates the instructions to cast a numerical value from one type to
* another.
*
* @param from the type of the top stack value
* @param to the type into which this value must be cast.
*/
public void cast(final Type from, final Type to){
if(from != to)
{
if(from == Type.DOUBLE_TYPE)
{
if(to == Type.FLOAT_TYPE)
{
mv.visitInsn(Opcodes.D2F);
}
else if(to == Type.LONG_TYPE)
{
mv.visitInsn(Opcodes.D2L);
}
else
{
mv.visitInsn(Opcodes.D2I);
cast(Type.INT_TYPE, to);
}
}
else if(from == Type.FLOAT_TYPE)
{
if(to == Type.DOUBLE_TYPE)
{
mv.visitInsn(Opcodes.F2D);
}
else if(to == Type.LONG_TYPE)
{
mv.visitInsn(Opcodes.F2L);
}
else
{
mv.visitInsn(Opcodes.F2I);
cast(Type.INT_TYPE, to);
}
}
else if(from == Type.LONG_TYPE)
{
if(to == Type.DOUBLE_TYPE)
{
mv.visitInsn(Opcodes.L2D);
}
else if(to == Type.FLOAT_TYPE)
350 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

{
mv.visitInsn(Opcodes.L2F);
}
else
{
mv.visitInsn(Opcodes.L2I);
cast(Type.INT_TYPE, to);
}
}
else
{
if(to == Type.BYTE_TYPE)
{
mv.visitInsn(Opcodes.I2B);
}
else if(to == Type.CHAR_TYPE)
{
mv.visitInsn(Opcodes.I2C);
}
else if(to == Type.DOUBLE_TYPE)
{
mv.visitInsn(Opcodes.I2D);
}
else if(to == Type.FLOAT_TYPE)
{
mv.visitInsn(Opcodes.I2F);
}
else if(to == Type.LONG_TYPE)
{
mv.visitInsn(Opcodes.I2L);
}
else if(to == Type.SHORT_TYPE)
{
mv.visitInsn(Opcodes.I2S);
}
}
}
}

// -------------------------------------------------------------------
// Instructions to do boxing and unboxing operations
// -------------------------------------------------------------------

/**
* Generates the instructions to box the top stack value. This value is
* replaced by its boxed equivalent on top of the stack.
*
* @param type the type of the top stack value.
*/
public void box(final Type type){
7.5. GENERATORADAPTER.JAVA 351

if(type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY)

{
return;
}
if(type == Type.VOID_TYPE)
{
push((String) null);
}
else
{
Type boxed = type;
switch(type.getSort())
{
case Type.BYTE:
boxed = BYTE_TYPE;
break;
case Type.BOOLEAN:
boxed = BOOLEAN_TYPE;
break;
case Type.SHORT:
boxed = SHORT_TYPE;
break;
case Type.CHAR:
boxed = CHARACTER_TYPE;
break;
case Type.INT:
boxed = INTEGER_TYPE;
break;
case Type.FLOAT:
boxed = FLOAT_TYPE;
break;
case Type.LONG:
boxed = LONG_TYPE;
break;
case Type.DOUBLE:
boxed = DOUBLE_TYPE;
break;
}
newInstance(boxed);
if(type.getSize() == 2)
{
// Pp -> Ppo -> oPpo -> ooPpo -> ooPp -> o
dupX2();
dupX2();
pop();
}
else
{
// p -> po -> opo -> oop -> o
dupX1();
352 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

swap();
}
invokeConstructor(boxed, new Method("<init>",
Type.VOID_TYPE,
new Type[]{type}));
}
}

/**
* Generates the instructions to unbox the top stack value. This value is
* replaced by its unboxed equivalent on top of the stack.
*
* @param type the type of the top stack value.
*/
public void unbox(final Type type){
Type t = NUMBER_TYPE;
Method sig = null;
switch(type.getSort())
{
case Type.VOID:
return;
case Type.CHAR:
t = CHARACTER_TYPE;
sig = CHAR_VALUE;
break;
case Type.BOOLEAN:
t = BOOLEAN_TYPE;
sig = BOOLEAN_VALUE;
break;
case Type.DOUBLE:
sig = DOUBLE_VALUE;
break;
case Type.FLOAT:
sig = FLOAT_VALUE;
break;
case Type.LONG:
sig = LONG_VALUE;
break;
case Type.INT:
case Type.SHORT:
case Type.BYTE:
sig = INT_VALUE;
}
if(sig == null)
{
checkCast(type);
}
else
{
checkCast(t);
7.5. GENERATORADAPTER.JAVA 353

invokeVirtual(t, sig);
}
}

// -------------------------------------------------------------------
// Instructions to jump to other instructions
// -------------------------------------------------------------------

/**
* Creates a new {@link Label}.
*
* @return a new {@link Label}.
*/
public Label newLabel(){
return new Label();
}

/**
* Marks the current code position with the given label.
*
* @param label a label.
*/
public void mark(final Label label){
mv.visitLabel(label);
}

/**
* Marks the current code position with a new label.
*
* @return the label that was created to mark the current code position.
*/
public Label mark(){
Label label = new Label();
mv.visitLabel(label);
return label;
}

/**
* Generates the instructions to jump to a label based on the
* comparison of the top two stack values.
*
* @param type the type of the top two stack values.
* @param mode how these values must be compared. One of EQ, NE, LT,
* GE, GT, LE.
* @param label where to jump if the comparison result is <tt>true</tt>.
*/
public void ifCmp(final Type type, final int mode, final Label label){
int intOp = -1;
switch(type.getSort())
{
354 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

case Type.LONG:
mv.visitInsn(Opcodes.LCMP);
break;
case Type.DOUBLE:
mv.visitInsn(Opcodes.DCMPG);
break;
case Type.FLOAT:
mv.visitInsn(Opcodes.FCMPG);
break;
case Type.ARRAY:
case Type.OBJECT:
switch(mode)
{
case EQ:
mv.visitJumpInsn(Opcodes.IF_ACMPEQ, label);
return;
case NE:
mv.visitJumpInsn(Opcodes.IF_ACMPNE, label);
return;
}
throw new IllegalArgumentException("Bad comparison for type "
+ type);
default:
switch(mode)
{
case EQ:
intOp = Opcodes.IF_ICMPEQ;
break;
case NE:
intOp = Opcodes.IF_ICMPNE;
break;
case GE:
intOp = Opcodes.IF_ICMPGE;
break;
case LT:
intOp = Opcodes.IF_ICMPLT;
break;
case LE:
intOp = Opcodes.IF_ICMPLE;
break;
case GT:
intOp = Opcodes.IF_ICMPGT;
break;
}
mv.visitJumpInsn(intOp, label);
return;
}
int jumpMode = mode;
switch(mode)
{
7.5. GENERATORADAPTER.JAVA 355

case GE:
jumpMode = LT;
break;
case LE:
jumpMode = GT;
break;
}
mv.visitJumpInsn(jumpMode, label);
}

/**
* Generates the instructions to jump to a label based on the
* comparison of the top two integer stack values.
*
* @param mode how these values must be compared. One of EQ, NE, LT,
* GE, GT, LE.
* @param label where to jump if the comparison result is <tt>true</tt>.
*/
public void ifICmp(final int mode, final Label label){
ifCmp(Type.INT_TYPE, mode, label);
}

/**
* Generates the instructions to jump to a label based on the
* comparison of the top integer stack value with zero.
*
* @param mode how these values must be compared. One of EQ, NE, LT,
* GE, GT, LE.
* @param label where to jump if the comparison result is <tt>true</tt>.
*/
public void ifZCmp(final int mode, final Label label){
mv.visitJumpInsn(mode, label);
}

/**
* Generates the instruction to jump to the given label if the top stack
* value is null.
*
* @param label where to jump if the condition is <tt>true</tt>.
*/
public void ifNull(final Label label){
mv.visitJumpInsn(Opcodes.IFNULL, label);
}

/**
* Generates the instruction to jump to the given label if the top stack
* value is not null.
*
* @param label where to jump if the condition is <tt>true</tt>.
*/
356 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

public void ifNonNull(final Label label){

mv.visitJumpInsn(Opcodes.IFNONNULL, label);
}

/**
* Generates the instruction to jump to the given label.
*
* @param label where to jump if the condition is <tt>true</tt>.
*/
public void goTo(final Label label){
mv.visitJumpInsn(Opcodes.GOTO, label);
}

/**
* Generates a RET instruction.
*
* @param local a local variable identifier, as returned by
* {@link LocalVariablesSorter#newLocal(Type) newLocal()}.
*/
public void ret(final int local){
mv.visitVarInsn(Opcodes.RET, local);
}

/**
* Generates the instructions for a switch statement.
*
* @param keys the switch case keys.
* @param generator a generator to generate the code for the switch
* cases.
*/
public void tableSwitch(
final int[] keys,
final TableSwitchGenerator generator){
float density;
if(keys.length == 0)
{
density = 0;
}
else
{
density = (float) keys.length
/ (keys[keys.length - 1] - keys[0] + 1);
}
tableSwitch(keys, generator, density >= 0.5f);
}

/**
* Generates the instructions for a switch statement.
*
* @param keys the switch case keys.
7.5. GENERATORADAPTER.JAVA 357

* @param generator a generator to generate the code for the switch

* cases.
* @param useTable <tt>true</tt> to use a TABLESWITCH instruction, or
* <tt>false</tt> to use a LOOKUPSWITCH instruction.
*/
public void tableSwitch(
final int[] keys,
final TableSwitchGenerator generator,
final boolean useTable){
for(int i = 1; i < keys.length; ++i)
{
if(keys[i] < keys[i - 1])
{
throw new IllegalArgumentException(
"keys must be sorted ascending");
}
}
Label def = newLabel();
Label end = newLabel();
if(keys.length > 0)
{
int len = keys.length;
int min = keys[0];
int max = keys[len - 1];
int range = max - min + 1;
if(useTable)
{
Label[] labels = new Label[range];
Arrays.fill(labels, def);
for(int i = 0; i < len; ++i)
{
labels[keys[i] - min] = newLabel();
}
mv.visitTableSwitchInsn(min, max, def, labels);
for(int i = 0; i < range; ++i)
{
Label label = labels[i];
if(label != def)
{
mark(label);
generator.generateCase(i + min, end);
}
}
}
else
{
Label[] labels = new Label[len];
for(int i = 0; i < len; ++i)
{
labels[i] = newLabel();
358 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

}
mv.visitLookupSwitchInsn(def, keys, labels);
for(int i = 0; i < len; ++i)
{
mark(labels[i]);
generator.generateCase(keys[i], end);
}
}
}
mark(def);
generator.generateDefault();
mark(end);
}

/**
* Generates the instruction to return the top stack value to the caller.
*/
public void returnValue(){
mv.visitInsn(returnType.getOpcode(Opcodes.IRETURN));
}

// -------------------------------------------------------------------
// Instructions to load and store fields
// -------------------------------------------------------------------

/**
* Generates a get field or set field instruction.
*
* @param opcode the instruction’s opcode.
* @param ownerType the class in which the field is defined.
* @param name the name of the field.
* @param fieldType the type of the field.
*/
private void fieldInsn(
final int opcode,
final Type ownerType,
final String name,
final Type fieldType){
mv.visitFieldInsn(opcode,
ownerType.getInternalName(),
name,
fieldType.getDescriptor());
}

/**
* Generates the instruction to push the value of a static field on the
* stack.
*
* @param owner the class in which the field is defined.
* @param name the name of the field.
7.5. GENERATORADAPTER.JAVA 359

* @param type the type of the field.

*/
public void getStatic(final Type owner,
final String name,
final Type type){
fieldInsn(Opcodes.GETSTATIC, owner, name, type);
}

/**
* Generates the instruction to store the top stack value
* in a static field.
*
* @param owner the class in which the field is defined.
* @param name the name of the field.
* @param type the type of the field.
*/
public void putStatic(final Type owner,
final String name,
final Type type){
fieldInsn(Opcodes.PUTSTATIC, owner, name, type);
}

/**
* Generates the instruction to push the value of a non static field
* on the stack.
*
* @param owner the class in which the field is defined.
* @param name the name of the field.
* @param type the type of the field.
*/
public void getField(final Type owner,
final String name,
final Type type){
fieldInsn(Opcodes.GETFIELD, owner, name, type);
}

/**
* Generates the instruction to store the top stack value in a
* non static field.
*
* @param owner the class in which the field is defined.
* @param name the name of the field.
* @param type the type of the field.
*/
public void putField(final Type owner,
final String name,
final Type type){
fieldInsn(Opcodes.PUTFIELD, owner, name, type);
}
360 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

// -------------------------------------------------------------------
// Instructions to invoke methods
// -------------------------------------------------------------------

/**
* Generates an invoke method instruction.
*
* @param opcode the instruction’s opcode.
* @param type the class in which the method is defined.
* @param method the method to be invoked.
*/
private void invokeInsn(
final int opcode,
final Type type,
final Method method){
String owner = type.getSort() == Type.ARRAY
? type.getDescriptor()
: type.getInternalName();
mv.visitMethodInsn(opcode,
owner,
method.getName(),
method.getDescriptor());
}

/**
* Generates the instruction to invoke a normal method.
*
* @param owner the class in which the method is defined.
* @param method the method to be invoked.
*/
public void invokeVirtual(final Type owner, final Method method){
invokeInsn(Opcodes.INVOKEVIRTUAL, owner, method);
}

/**
* Generates the instruction to invoke a constructor.
*
* @param type the class in which the constructor is defined.
* @param method the constructor to be invoked.
*/
public void invokeConstructor(final Type type, final Method method){
invokeInsn(Opcodes.INVOKESPECIAL, type, method);
}

/**
* Generates the instruction to invoke a static method.
*
* @param owner the class in which the method is defined.
* @param method the method to be invoked.
*/
7.5. GENERATORADAPTER.JAVA 361

public void invokeStatic(final Type owner, final Method method){

invokeInsn(Opcodes.INVOKESTATIC, owner, method);
}

/**
* Generates the instruction to invoke an interface method.
*
* @param owner the class in which the method is defined.
* @param method the method to be invoked.
*/
public void invokeInterface(final Type owner, final Method method){
invokeInsn(Opcodes.INVOKEINTERFACE, owner, method);
}

// -------------------------------------------------------------------
// Instructions to create objects and arrays
// -------------------------------------------------------------------

/**
* Generates a type dependent instruction.
*
* @param opcode the instruction’s opcode.
* @param type the instruction’s operand.
*/
private void typeInsn(final int opcode, final Type type){
String desc;
if(type.getSort() == Type.ARRAY)
{
desc = type.getDescriptor();
}
else
{
desc = type.getInternalName();
}
mv.visitTypeInsn(opcode, desc);
}

/**
* Generates the instruction to create a new object.
*
* @param type the class of the object to be created.
*/
public void newInstance(final Type type){
typeInsn(Opcodes.NEW, type);
}

/**
* Generates the instruction to create a new array.
*
* @param type the type of the array elements.
362 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*/
public void newArray(final Type type){
int typ;
switch(type.getSort())
{
case Type.BOOLEAN:
typ = Opcodes.T_BOOLEAN;
break;
case Type.CHAR:
typ = Opcodes.T_CHAR;
break;
case Type.BYTE:
typ = Opcodes.T_BYTE;
break;
case Type.SHORT:
typ = Opcodes.T_SHORT;
break;
case Type.INT:
typ = Opcodes.T_INT;
break;
case Type.FLOAT:
typ = Opcodes.T_FLOAT;
break;
case Type.LONG:
typ = Opcodes.T_LONG;
break;
case Type.DOUBLE:
typ = Opcodes.T_DOUBLE;
break;
default:
typeInsn(Opcodes.ANEWARRAY, type);
return;
}
mv.visitIntInsn(Opcodes.NEWARRAY, typ);
}

// -------------------------------------------------------------------
// Miscelaneous instructions
// -------------------------------------------------------------------

/**
* Generates the instruction to compute the length of an array.
*/
public void arrayLength(){
mv.visitInsn(Opcodes.ARRAYLENGTH);
}

/**
* Generates the instruction to throw an exception.
*/
7.5. GENERATORADAPTER.JAVA 363

public void throwException(){

mv.visitInsn(Opcodes.ATHROW);
}

/**
* Generates the instructions to create and throw an exception. The
* exception class must have a constructor with a single String argument.
*
* @param type the class of the exception to be thrown.
* @param msg the detailed message of the exception.
*/
public void throwException(final Type type, final String msg){
newInstance(type);
dup();
push(msg);
invokeConstructor(type, Method.getMethod("void <init> (String)"));
throwException();
}

/**
* Generates the instruction to check that the top stack value is of the
* given type.
*
* @param type a class or interface type.
*/
public void checkCast(final Type type){
if(!type.equals(OBJECT_TYPE))
{
typeInsn(Opcodes.CHECKCAST, type);
}
}

/**
* Generates the instruction to test if the top stack value is
* of the given type.
*
* @param type a class or interface type.
*/
public void instanceOf(final Type type){
typeInsn(Opcodes.INSTANCEOF, type);
}

/**
* Generates the instruction to get the monitor of the top stack value.
*/
public void monitorEnter(){
mv.visitInsn(Opcodes.MONITORENTER);
}

/**
364 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

* Generates the instruction to release the monitor of

* the top stack value.
*/
public void monitorExit(){
mv.visitInsn(Opcodes.MONITOREXIT);
}

// -------------------------------------------------------------------
// Non instructions
// -------------------------------------------------------------------

/**
* Marks the end of the visited method.
*/
public void endMethod(){
if((access & Opcodes.ACC_ABSTRACT) == 0)
{
mv.visitMaxs(0, 0);
}
mv.visitEnd();
}

/**
* Marks the start of an exception handler.
*
* @param start beginning of the exception handler’s scope
* (inclusive).
* @param end end of the exception handler’s scope (exclusive).
* @param exception internal name of the type of exceptions handled
* by the handler.
*/
public void catchException(
final Label start,
final Label end,
final Type exception){
mv.visitTryCatchBlock(start, end, mark(),
exception.getInternalName());
}
}

———-

7.6 LocalVariablesSorter.java

— LocalVariablesSorter.java —

\getchunk{France Telecom Copyright}

7.6. LOCALVARIABLESSORTER.JAVA 365

package clojure.asm.commons;

import clojure.asm.Label;
import clojure.asm.MethodAdapter;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;
import clojure.asm.Type;

/**
* A {@link MethodAdapter} that renumbers local variables in their
* order of appearance. This adapter allows one to easily add new
* local variables to a method. It may be used by inheriting from
* this class, but the preferred way of using it is via delegation:
* the next visitor in the chain can indeed add new locals when needed
* by calling {@link #newLocal} on this adapter (this requires a
* reference back to this {@link LocalVariablesSorter}).
*
* @author Chris Nokleberg
* @author Eugene Kuleshov
* @author Eric Bruneton
*/
public class LocalVariablesSorter extends MethodAdapter{

private final static Type OBJECT_TYPE =

Type.getObjectType("java/lang/Object");

/**
* Mapping from old to new local variable indexes. A local variable
* at index i of size 1 is remapped to ’mapping[2*i]’, while a local
* variable at index i of size 2 is remapped to ’mapping[2*i+1]’.
*/
private int[] mapping = new int[40];

/**
* Array used to store stack map local variable types after remapping.
*/
private Object[] newLocals = new Object[20];

/**
* Index of the first local variable, after formal parameters.
*/
protected final int firstLocal;

/**
* Index of the next local variable to be created by {@link #newLocal}.
*/
protected int nextLocal;

/**
* Indicates if at least one local variable has moved due to remapping.
366 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*/
private boolean changed;

/**
* Creates a new {@link LocalVariablesSorter}.
*
* @param access access flags of the adapted method.
* @param desc the method’s descriptor (see {@link Type Type}).
* @param mv the method visitor to which this adapter delegates
* calls.
*/
public LocalVariablesSorter(
final int access,
final String desc,
final MethodVisitor mv){
super(mv);
Type[] args = Type.getArgumentTypes(desc);
nextLocal = (Opcodes.ACC_STATIC & access) != 0 ? 0 : 1;
for(int i = 0; i < args.length; i++)
{
nextLocal += args[i].getSize();
}
firstLocal = nextLocal;
}

public void visitVarInsn(final int opcode, final int var){

Type type;
switch(opcode)
{
case Opcodes.LLOAD:
case Opcodes.LSTORE:
type = Type.LONG_TYPE;
break;

case Opcodes.DLOAD:
case Opcodes.DSTORE:
type = Type.DOUBLE_TYPE;
break;

case Opcodes.FLOAD:
case Opcodes.FSTORE:
type = Type.FLOAT_TYPE;
break;

case Opcodes.ILOAD:
case Opcodes.ISTORE:
type = Type.INT_TYPE;
break;

case Opcodes.ALOAD:
7.6. LOCALVARIABLESSORTER.JAVA 367

case Opcodes.ASTORE:
type = OBJECT_TYPE;
break;

// case RET:
default:
type = Type.VOID_TYPE;
}
mv.visitVarInsn(opcode, remap(var, type));
}

public void visitIincInsn(final int var, final int increment){

mv.visitIincInsn(remap(var, Type.INT_TYPE), increment);
}

public void visitMaxs(final int maxStack, final int maxLocals){

mv.visitMaxs(maxStack, nextLocal);
}

public void visitLocalVariable(

final String name,
final String desc,
final String signature,
final Label start,
final Label end,
final int index){
int size = "J".equals(desc) || "D".equals(desc) ? 2 : 1;
int newIndex = remap(index, size);
mv.visitLocalVariable(name, desc, signature, start, end, newIndex);
}

public void visitFrame(

final int type,
final int nLocal,
final Object[] local,
final int nStack,
final Object[] stack){
if(type != Opcodes.F_NEW)
{ // uncompressed frame
throw new IllegalStateException(
"ClassReader.accept() should be called with EXPAND_FRAMES flag");
}

if(!changed)
{ // optimization for the case where mapping = identity
mv.visitFrame(type, nLocal, local, nStack, stack);
return;
}

// creates a copy of newLocals

368 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

Object[] oldLocals = new Object[newLocals.length];

System.arraycopy(newLocals, 0, oldLocals, 0, oldLocals.length);

// copies types from ’local’ to ’newLocals’

// ’newLocals’ already contains the variables added with ’newLocal’

int index = 0; // old local variable index

int number = 0; // old local variable number
for(; number < nLocal; ++number)
{
Object t = local[number];
int size = t == Opcodes.LONG ||
t == Opcodes.DOUBLE ? 2 : 1;
if(t != Opcodes.TOP)
{
setFrameLocal(remap(index, size), t);
}
index += size;
}

// removes TOP after long and double types as well as trailing TOPs

index = 0;
number = 0;
for(int i = 0; index < newLocals.length; ++i)
{
Object t = newLocals[index++];
if(t != null && t != Opcodes.TOP)
{
newLocals[i] = t;
number = i + 1;
if(t == Opcodes.LONG || t == Opcodes.DOUBLE)
{
index += 1;
}
}
else
{
newLocals[i] = Opcodes.TOP;
}
}

// visits remapped frame

mv.visitFrame(type, number, newLocals, nStack, stack);

// restores original value of ’newLocals’

newLocals = oldLocals;
}

// -------------
7.6. LOCALVARIABLESSORTER.JAVA 369

/**
* Creates a new local variable of the given type.
*
* @param type the type of the local variable to be created.
* @return the identifier of the newly created local variable.
*/
public int newLocal(final Type type){
Object t;
switch(type.getSort())
{
case Type.BOOLEAN:
case Type.CHAR:
case Type.BYTE:
case Type.SHORT:
case Type.INT:
t = Opcodes.INTEGER;
break;
case Type.FLOAT:
t = Opcodes.FLOAT;
break;
case Type.LONG:
t = Opcodes.LONG;
break;
case Type.DOUBLE:
t = Opcodes.DOUBLE;
break;
case Type.ARRAY:
t = type.getDescriptor();
break;
// case Type.OBJECT:
default:
t = type.getInternalName();
break;
}
int local = nextLocal;
setLocalType(local, type);
setFrameLocal(local, t);
nextLocal += type.getSize();
return local;
}

/**
* Sets the current type of the given local variable. The default
* implementation of this method does nothing.
*
* @param local a local variable identifier, as returned by
* {@link #newLocal newLocal()}.
* @param type the type of the value being stored in the local
* variable
370 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*/
protected void setLocalType(final int local, final Type type){
}

private void setFrameLocal(final int local, final Object type){

int l = newLocals.length;
if(local >= l)
{
Object[] a = new Object[Math.max(2 * l, local + 1)];
System.arraycopy(newLocals, 0, a, 0, l);
newLocals = a;
}
newLocals[local] = type;
}

private int remap(final int var, final Type type){

if(var < firstLocal)
{
return var;
}
int key = 2 * var + type.getSize() - 1;
int size = mapping.length;
if(key >= size)
{
int[] newMapping = new int[Math.max(2 * size, key + 1)];
System.arraycopy(mapping, 0, newMapping, 0, size);
mapping = newMapping;
}
int value = mapping[key];
if(value == 0)
{
value = nextLocal + 1;
mapping[key] = value;
setLocalType(nextLocal, type);
nextLocal += type.getSize();
}
if(value - 1 != var)
{
changed = true;
}
return value - 1;
}

private int remap(final int var, final int size){

if(var < firstLocal || !changed)
{
return var;
}
int key = 2 * var + size - 1;
int value = key < mapping.length ? mapping[key] : 0;
7.7. METHOD.JAVA 371

if(value == 0)
{
throw new
IllegalStateException("Unknown local variable " + var);
}
return value - 1;
}
}

———-

7.7 Method.java

— Method.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import java.util.HashMap;
import java.util.Map;

import clojure.asm.Type;

/**
* A named method descriptor.
*
* @author Juozas Baliuka
* @author Chris Nokleberg
* @author Eric Bruneton
*/
public class Method{

/**
* The method name.
*/
private final String name;

/**
* The method descriptor.
*/
private final String desc;

/**
* Maps primitive Java type names to their descriptors.
*/
private final static Map DESCRIPTORS;
372 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

static
{
DESCRIPTORS = new HashMap();
DESCRIPTORS.put("void", "V");
DESCRIPTORS.put("byte", "B");
DESCRIPTORS.put("char", "C");
DESCRIPTORS.put("double", "D");
DESCRIPTORS.put("float", "F");
DESCRIPTORS.put("int", "I");
DESCRIPTORS.put("long", "J");
DESCRIPTORS.put("short", "S");
DESCRIPTORS.put("boolean", "Z");
}

/**
* Creates a new {@link Method}.
*
* @param name the method’s name.
* @param desc the method’s descriptor.
*/
public Method(final String name, final String desc){
this.name = name;
this.desc = desc;
}

/**
* Creates a new {@link Method}.
*
* @param name the method’s name.
* @param returnType the method’s return type.
* @param argumentTypes the method’s argument types.
*/
public Method(
final String name,
final Type returnType,
final Type[] argumentTypes){
this(name, Type.getMethodDescriptor(returnType, argumentTypes));
}

/**
* Returns a {@link Method} corresponding to the given Java method
* declaration.
*
* @param method a Java method declaration, without argument names, of
* the form
* "returnType name (argumentType1, ... argumentTypeN)",
* where the types are in plain Java (e.g. "int", "float",
* "java.util.List", ...). Classes of the
* java.lang package can be specified by their
* unqualified name; all other classes names must be
7.7. METHOD.JAVA 373

* fully qualified.
* @return a {@link Method} corresponding to the given Java method
* declaration.
* @throws IllegalArgumentException if <code>method</code> could not get
* parsed.
*/
public static Method getMethod(final String method)
throws IllegalArgumentException{
return getMethod(method, false);
}

/**
* Returns a {@link Method} corresponding to the given Java method
* declaration.
*
* @param method a Java method declaration, without argument
* names, of the form
* "returnType name (argumentType1,...argumentTypeN)",
* where the types are in plain Java (e.g. "int",
* "float", "java.util.List", ...). Classes of the
* java.lang package may be specified by their
* unqualified name, depending on the
* defaultPackage argument; all other classes
* names must be fully qualified.
* @param defaultPackage true if unqualified class names belong to the
* default package, or false if they correspond
* to java.lang classes. For instance "Object"
* means "Object" if this option is true, or
* "java.lang.Object" otherwise.
* @return a {@link Method} corresponding to the given Java method
* declaration.
* @throws IllegalArgumentException if <code>method</code> could not get
* parsed.
*/
public static Method getMethod(
final String method,
final boolean defaultPackage) throws IllegalArgumentException{
int space = method.indexOf(’ ’);
int start = method.indexOf(’(’, space) + 1;
int end = method.indexOf(’)’, start);
if(space == -1 || start == -1 || end == -1)
{
throw new IllegalArgumentException();
}
// TODO: Check validity of returnType, methodName and arguments.
String returnType = method.substring(0, space);
String methodName = method.substring(space + 1, start - 1).trim();
StringBuffer sb = new StringBuffer();
sb.append(’(’);
int p;
374 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

do
{
String s;
p = method.indexOf(’,’, start);
if(p == -1)
{
s = map(method.substring(start, end).trim(), defaultPackage);
}
else
{
s = map(method.substring(start, p).trim(), defaultPackage);
start = p + 1;
}
sb.append(s);
} while(p != -1);
sb.append(’)’);
sb.append(map(returnType, defaultPackage));
return new Method(methodName, sb.toString());
}

private static String map(final String type,

final boolean defaultPackage){
if(type.equals(""))
{
return type;
}

StringBuffer sb = new StringBuffer();

int index = 0;
while((index = type.indexOf("[]", index) + 1) > 0)
{
sb.append(’[’);
}

String t = type.substring(0, type.length() - sb.length() * 2);

String desc = (String) DESCRIPTORS.get(t);
if(desc != null)
{
sb.append(desc);
}
else
{
sb.append(’L’);
if(t.indexOf(’.’) < 0)
{
if(!defaultPackage)
{
sb.append("java/lang/");
}
sb.append(t);
7.7. METHOD.JAVA 375

}
else
{
sb.append(t.replace(’.’, ’/’));
}
sb.append(’;’);
}
return sb.toString();
}

/**
* Returns the name of the method described by this object.
*
* @return the name of the method described by this object.
*/
public String getName(){
return name;
}

/**
* Returns the descriptor of the method described by this object.
*
* @return the descriptor of the method described by this object.
*/
public String getDescriptor(){
return desc;
}

/**
* Returns the return type of the method described by this object.
*
* @return the return type of the method described by this object.
*/
public Type getReturnType(){
return Type.getReturnType(desc);
}

/**
* Returns the argument types of the method described by this object.
*
* @return the argument types of the method described by this object.
*/
public Type[] getArgumentTypes(){
return Type.getArgumentTypes(desc);
}

public String toString(){

return name + desc;
}
376 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

public boolean equals(final Object o){

if(!(o instanceof Method))
{
return false;
}
Method other = (Method) o;
return name.equals(other.name) && desc.equals(other.desc);
}

public int hashCode(){

return name.hashCode() ^ desc.hashCode();
}
}

———-

7.8 SerialVersionUIDAdder.java

— SerialVersionUIDAdder.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

import clojure.asm.ClassAdapter;
import clojure.asm.ClassVisitor;
import clojure.asm.FieldVisitor;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;

/**
* A {@link ClassAdapter} that adds a serial version unique identifier
* to a class if missing. Here is typical usage of this class:
* 
* <pre>
* ClassWriter cw = new ClassWriter(...);
* ClassVisitor sv = new SerialVersionUIDAdder(cw);
* ClassVisitor ca = new MyClassAdapter(sv);
* new ClassReader(orginalClass).accept(ca, false);
* </pre>
7.8. SERIALVERSIONUIDADDER.JAVA 377

* 
* The SVUID algorithm can be found on the java.sun.com website under
* "j2se/1.4.2/docs/guide/serialization/spec/class.html"
* 
* <pre>
* The serialVersionUID is computed using the signature of a stream of
* bytes that reflect the class definition. The National Institute of
* Standards and Technology (NIST) Secure Hash Algorithm (SHA-1) is
* used to compute a signature for the stream. The first two 32-bit
* quantities are used to form a 64-bit hash. A
* java.lang.DataOutputStream is used to convert primitive data types
* to a sequence of bytes. The values input to the stream are defined
* by the Java Virtual Machine (VM) specification for classes.
* 
* The sequence of items in the stream is as follows:
* 
* 1. The class name written using UTF encoding.
* 2. The class modifiers written as a 32-bit integer.
* 3. The name of each interface sorted by name written using UTF
* encoding.
* 4. For each field of the class sorted by field name (except
* private static and private transient fields):
* 1. The name of the field in UTF encoding.
* 2. The modifiers of the field written as a 32-bit integer.
* 3. The descriptor of the field in UTF encoding
* 5. If a class initializer exists, write out the following:
* 1. The name of the method, <clinit>, in UTF encoding.
* 2. The modifier of the method, java.lang.reflect.Modifier.STATIC,
* written as a 32-bit integer.
* 3. The descriptor of the method, ()V, in UTF encoding.
* 6. For each non-private constructor sorted by method name and
* signature:
* 1. The name of the method, <init>, in UTF encoding.
* 2. The modifiers of the method written as a 32-bit integer.
* 3. The descriptor of the method in UTF encoding.
* 7. For each non-private method sorted by method name and signature:
* 1. The name of the method in UTF encoding.
* 2. The modifiers of the method written as a 32-bit integer.
* 3. The descriptor of the method in UTF encoding.
* 8. The SHA-1 algorithm is executed on the stream of bytes produced by
* DataOutputStream and produces five 32-bit values sha[0..4].
* 
* 9. The hash value is assembled from the first and second 32-bit
* values of the SHA-1 message digest. If the result of the message
* digest, the five 32-bit words H0 H1 H2 H3 H4, is in an array of
* five int values named sha, the hash value would be computed as
* follows:
* 
* long hash = ((sha[0] >>> 24) & 0xFF) |
* ((sha[0] >>> 16) & 0xFF) << 8 |
378 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

* ((sha[0] >>> 8) & 0xFF) << 16 |

* ((sha[0] >>> 0) & 0xFF) << 24 |
* ((sha[1] >>> 24) & 0xFF) << 32 |
* ((sha[1] >>> 16) & 0xFF) << 40 |
* ((sha[1] >>> 8) & 0xFF) << 48 |
* ((sha[1] >>> 0) & 0xFF) << 56;
* </pre>
*
* @author Rajendra Inamdar, Vishal Vishnoi
*/
public class SerialVersionUIDAdder extends ClassAdapter{

/**
* Flag that indicates if we need to compute SVUID.
*/
protected boolean computeSVUID;

/**
* Set to true if the class already has SVUID.
*/
protected boolean hasSVUID;

/**
* Classes access flags.
*/
protected int access;

/**
* Internal name of the class
*/
protected String name;

/**
* Interfaces implemented by the class.
*/
protected String[] interfaces;

/**
* Collection of fields. (except private static and private transient
* fields)
*/
protected Collection svuidFields;

/**
* Set to true if the class has static initializer.
*/
protected boolean hasStaticInitializer;

/**
* Collection of non-private constructors.
7.8. SERIALVERSIONUIDADDER.JAVA 379

*/
protected Collection svuidConstructors;

/**
* Collection of non-private methods.
*/
protected Collection svuidMethods;

/**
* Creates a new {@link SerialVersionUIDAdder}.
*
* @param cv a {@link ClassVisitor} to which this visitor will delegate
* calls.
*/
public SerialVersionUIDAdder(final ClassVisitor cv){
super(cv);
svuidFields = new ArrayList();
svuidConstructors = new ArrayList();
svuidMethods = new ArrayList();
}

// -------------------------------------------------------------------
// Overriden methods
// -------------------------------------------------------------------

/*
* Visit class header and get class name, access , and interfaces
* informatoin (step 1,2, and 3) for SVUID computation.
*/

public void visit(

final int version,
final int access,
final String name,
final String signature,
final String superName,
final String[] interfaces){
computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0;

if(computeSVUID)
{
this.name = name;
this.access = access;
this.interfaces = interfaces;
}

super.visit(version, access, name, signature, superName, interfaces);

}

/*
380 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

* Visit the methods and get constructor and method information

* (step 5 and 7). Also determince if there is a class initializer
* (step 6).
*/
public MethodVisitor visitMethod(
final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions){
if(computeSVUID)
{
if(name.equals("<clinit>"))
{
hasStaticInitializer = true;
}
/*
* Remembers non private constructors and methods for SVUID
* computation For constructor and method modifiers, only the
* ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
* ACC_FINAL, ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and
* ACC_STRICT flags are used.
*/
int mods = access
& (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
| Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
| Opcodes.ACC_FINAL | Opcodes.ACC_SYNCHRONIZED
| Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT
| Opcodes.ACC_STRICT);

// all non private methods

if((access & Opcodes.ACC_PRIVATE) == 0)
{
if(name.equals("<init>"))
{
svuidConstructors.add(new Item(name, mods, desc));
}
else if(!name.equals("<clinit>"))
{
svuidMethods.add(new Item(name, mods, desc));
}
}
}

return cv.visitMethod(access, name, desc, signature, exceptions);

}

/*
* Gets class field information for step 4 of the alogrithm. Also
* determines if the class already has a SVUID.
7.8. SERIALVERSIONUIDADDER.JAVA 381

*/
public FieldVisitor visitField(
final int access,
final String name,
final String desc,
final String signature,
final Object value){
if(computeSVUID)
{
if(name.equals("serialVersionUID"))
{
// since the class already has SVUID, we won’t be
// computing it.
computeSVUID = false;
hasSVUID = true;
}
/*
* Remember field for SVUID computation For field modifiers, only
* the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
* ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when
* computing serialVersionUID values.
*/
int mods = access
& (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
| Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
| Opcodes.ACC_FINAL | Opcodes.ACC_VOLATILE
| Opcodes.ACC_TRANSIENT);

if((access & Opcodes.ACC_PRIVATE) == 0

|| (access & (Opcodes.ACC_STATIC |
Opcodes.ACC_TRANSIENT)) == 0)
{
svuidFields.add(new Item(name, mods, desc));
}
}

return super.visitField(access, name, desc, signature, value);

}

/*
* Add the SVUID if class doesn’t have one
*/
public void visitEnd(){
// compute SVUID and add it to the class
if(computeSVUID && !hasSVUID)
{
try
{
cv.visitField(Opcodes.ACC_FINAL + Opcodes.ACC_STATIC,
"serialVersionUID",
382 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

"J",
null,
new Long(computeSVUID()));
}
catch(Throwable e)
{
throw new RuntimeException("Error while computing SVUID for "
+ name, e);
}
}

super.visitEnd();
}

// -------------------------------------------------------------------
// Utility methods
// -------------------------------------------------------------------

/**
* Returns the value of SVUID if the class doesn’t have one already.
* Please note that 0 is returned if the class already has SVUID, thus
* use <code>isHasSVUID</code> to determine if the class already had
* an SVUID.
*
* @return Returns the serial version UID
* @throws IOException
*/
protected long computeSVUID() throws IOException{
ByteArrayOutputStream bos = null;
DataOutputStream dos = null;
long svuid = 0;

try
{
bos = new ByteArrayOutputStream();
dos = new DataOutputStream(bos);

/*
* 1. The class name written using UTF encoding.
*/
dos.writeUTF(name.replace(’/’, ’.’));

/*
* 2. The class modifiers written as a 32-bit integer.
*/
dos.writeInt(access
& (Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL
| Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT));

/*
7.8. SERIALVERSIONUIDADDER.JAVA 383

* 3. The name of each interface sorted by name written using UTF

* encoding.
*/
Arrays.sort(interfaces);
for(int i = 0; i < interfaces.length; i++)
{
dos.writeUTF(interfaces[i].replace(’/’, ’.’));
}

/*
* 4. For each field of the class sorted by field name (except
* private static and private transient fields):
*
* 1. The name of the field in UTF encoding. 2. The modifiers
* of the field written as a 32-bit integer. 3. The descriptor
* of the field in UTF encoding
*
* Note that field signatutes are not dot separated. Method and
* constructor signatures are dot separated. Go figure...
*/
writeItems(svuidFields, dos, false);

/*
* 5. If a class initializer exists, write out the following: 1.
* The name of the method, <clinit>, in UTF encoding. 2. The
* modifier of the method, java.lang.reflect.Modifier.STATIC,
* written as a 32-bit integer. 3. The descriptor of the method,
* ()V, in UTF encoding.
*/
if(hasStaticInitializer)
{
dos.writeUTF("<clinit>");
dos.writeInt(Opcodes.ACC_STATIC);
dos.writeUTF("()V");
} // if..

/*
* 6. For each non-private constructor sorted by method name
* and signature: 1. The name of the method, <init>, in UTF
* encoding. 2. The modifiers of the method written as a
* 32-bit integer. 3. The descriptor of the method in UTF
* encoding.
*/
writeItems(svuidConstructors, dos, true);

/*
* 7. For each non-private method sorted by method name and
* signature: 1. The name of the method in UTF encoding. 2. The
* modifiers of the method written as a 32-bit integer. 3. The
* descriptor of the method in UTF encoding.
384 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

*/
writeItems(svuidMethods, dos, true);

dos.flush();

/*
* 8. The SHA-1 algorithm is executed on the stream of bytes
* produced by DataOutputStream and produces five 32-bit values
* sha[0..4].
*/
byte[] hashBytes = computeSHAdigest(bos.toByteArray());

/*
* 9. The hash value is assembled from the first and second
* 32-bit values of the SHA-1 message digest. If the result
* of the message digest, the five 32-bit words H0 H1 H2 H3 H4,
* is in an array of five int values named sha, the hash value
* would be computed as follows:
*
* long hash = ((sha[0] >>> 24) & 0xFF) |
* ((sha[0] >>> 16) & 0xFF) << 8 |
* ((sha[0] >>> 8) & 0xFF) << 16 |
* ((sha[0] >>> 0) & 0xFF) << 24 |
* ((sha[1] >>> 24) & 0xFF) << 32 |
* ((sha[1] >>> 16) & 0xFF) << 40 |
* ((sha[1] >>> 8) & 0xFF) << 48 |
* ((sha[1] >>> 0) & 0xFF) << 56;
*/
for(int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--)
{
svuid = (svuid << 8) | (hashBytes[i] & 0xFF);
}
}
finally
{
// close the stream (if open)
if(dos != null)
{
dos.close();
}
}

return svuid;
}

/**
* Returns the SHA-1 message digest of the given value.
*
* @param value the value whose SHA message digest must be computed.
* @return the SHA-1 message digest of the given value.
7.8. SERIALVERSIONUIDADDER.JAVA 385

*/
protected byte[] computeSHAdigest(final byte[] value){
try
{
return MessageDigest.getInstance("SHA").digest(value);
}
catch(Exception e)
{
throw new UnsupportedOperationException(e);
}
}

/**
* Sorts the items in the collection and writes it to the data output
* stream
*
* @param itemCollection collection of items
* @param dos a <code>DataOutputStream</code> value
* @param dotted a <code>boolean</code> value
* @throws IOException if an error occurs
*/
private void writeItems(
final Collection itemCollection,
final DataOutputStream dos,
final boolean dotted) throws IOException{
int size = itemCollection.size();
Item items[] = (Item[]) itemCollection.toArray(new Item[size]);
Arrays.sort(items);
for(int i = 0; i < size; i++)
{
dos.writeUTF(items[i].name);
dos.writeInt(items[i].access);
dos.writeUTF(dotted
? items[i].desc.replace(’/’, ’.’)
: items[i].desc);
}
}

// -------------------------------------------------------------------
// Inner classes
// -------------------------------------------------------------------

static class Item implements Comparable{

String name;

int access;

String desc;
386 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

Item(final String name, final int access, final String desc){

this.name = name;
this.access = access;
this.desc = desc;
}

public int compareTo(final Object o){

Item other = (Item) o;
int retVal = name.compareTo(other.name);
if(retVal == 0)
{
retVal = desc.compareTo(other.desc);
}
return retVal;
}
}
}

———-

7.9 StaticInitMerger.java

— StaticInitMerger.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import clojure.asm.ClassAdapter;
import clojure.asm.ClassVisitor;
import clojure.asm.MethodVisitor;
import clojure.asm.Opcodes;

/**
* A {@link ClassAdapter} that merges clinit methods into a single one.
*
* @author Eric Bruneton
*/
public class StaticInitMerger extends ClassAdapter{

private String name;

private MethodVisitor clinit;

private String prefix;

private int counter;

7.9. STATICINITMERGER.JAVA 387

public StaticInitMerger(final String prefix, final ClassVisitor cv){

super(cv);
this.prefix = prefix;
}

public void visit(

public MethodVisitor visitMethod(

final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions){
MethodVisitor mv;
if(name.equals("<clinit>"))
{
int a = Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC;
String n = prefix + counter++;
mv = cv.visitMethod(a, n, desc, signature, exceptions);

if(clinit == null)
{
clinit = cv.visitMethod(a, name, desc, null, null);
}
clinit.visitMethodInsn(Opcodes.INVOKESTATIC, this.name, n, desc);
}
else
{
mv = cv.visitMethod(access, name, desc, signature, exceptions);
}
return mv;
}

public void visitEnd(){

if(clinit != null)
{
clinit.visitInsn(Opcodes.RETURN);
clinit.visitMaxs(0, 0);
}
cv.visitEnd();
}
388 CHAPTER 7. JVM/CLOJURE/ASM/COMMONS

———-

7.10 TableSwitchGenerator.java

— TableSwitchGenerator.java —

\getchunk{France Telecom Copyright}

package clojure.asm.commons;

import clojure.asm.Label;

/**
* A code generator for switch statements.
*
* @author Juozas Baliuka
* @author Chris Nokleberg
* @author Eric Bruneton
*/
public interface TableSwitchGenerator{

/**
* Generates the code for a switch case.
*
* @param key the switch case key.
* @param end a label that corresponds to the end of the switch
* statement.
*/
void generateCase(int key, Label end);

/**
* Generates the code for the default switch case.
*/
void generateDefault();
}

———-
Chapter 8

jvm/clojure/lang/

8.1 AFn.java

— AFn.java —
\getchunk{Clojure Copyright}
/* rich Mar 25, 2006 4:05:37 PM */

package clojure.lang;

public abstract class AFn implements IFn {

public Object call() throws Exception{

return invoke();
}

public void run(){

try
{
invoke();
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}

public Object invoke()

throws Exception{
return throwArity(0);

389
390 CHAPTER 8. JVM/CLOJURE/LANG/

public Object invoke(Object arg1)

throws Exception{
return throwArity(1);
}

public Object invoke(Object arg1, Object arg2)

throws Exception{
return throwArity(2);
}

public Object invoke(Object arg1, Object arg2, Object arg3)

throws Exception{
return throwArity(3);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4)
throws Exception{
return throwArity(4);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5)
throws Exception{
return throwArity(5);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6)
throws Exception{
return throwArity(6);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7)
throws Exception{
return throwArity(7);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8) throws Exception{
return throwArity(8);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
8.1. AFN.JAVA 391

Object arg7, Object arg8, Object arg9)

throws Exception{
return throwArity(9);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10)
throws Exception{
return throwArity(10);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11)
throws Exception{
return throwArity(11);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12)
throws Exception{
return throwArity(12);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13)
throws Exception{
return throwArity(13);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14)
throws Exception{
return throwArity(14);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
392 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg10, Object arg11, Object arg12,

Object arg13, Object arg14, Object arg15)
throws Exception{
return throwArity(15);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
8.1. AFN.JAVA 393

Object arg10, Object arg11, Object arg12,

Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19, Object arg20)
throws Exception{
return throwArity(20);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

public Object applyTo(ISeq arglist) throws Exception{

return applyToHelper(this, Util.ret1(arglist,arglist = null));
}

static public Object applyToHelper(IFn ifn, ISeq arglist)

throws Exception{
switch(RT.boundedLength(arglist, 20))
{
case 0:
arglist = null;
return ifn.invoke();
case 1:
Object a1 = arglist.first();
arglist = null;
return ifn.invoke(a1);
case 2:
return ifn.invoke(arglist.first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 3:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 4:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
394 CHAPTER 8. JVM/CLOJURE/LANG/

, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 5:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 6:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 7:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 8:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 9:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
8.1. AFN.JAVA 395

, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 10:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 11:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 12:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 13:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
396 CHAPTER 8. JVM/CLOJURE/LANG/

, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 14:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 15:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 16:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
8.1. AFN.JAVA 397

, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 17:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 18:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
398 CHAPTER 8. JVM/CLOJURE/LANG/

, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 19:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
);
case 20:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, Util.ret1(
(arglist = arglist.next()).first(),arglist = null)
8.2. AFUNCTION.JAVA 399

);
default:
return ifn.invoke(arglist.first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, (arglist = arglist.next()).first()
, RT.seqToArray(
Util.ret1(arglist.next(),arglist = null)));
}
}

public Object throwArity(int n){

String name = getClass().getSimpleName();
int suffix = name.lastIndexOf("__");
throw new ArityException(n,
(suffix == -1
? name
: name.substring(0, suffix)).replace(’_’, ’-’));
}
}

———-

8.2 AFunction.java

— AFunction.java —

\getchunk{Clojure Copyright}
/* rich Dec 16, 2008 */

package clojure.lang;
400 CHAPTER 8. JVM/CLOJURE/LANG/

import java.io.Serializable;
import java.util.Comparator;

public abstract class AFunction

extends AFn
implements IObj, Comparator, Fn, Serializable {

public volatile MethodImplCache __methodImplCache;

public int compare(Object o1, Object o2){

try
{
Object o = invoke(o1, o2);

if(o instanceof Boolean)

{
if(RT.booleanCast(o))
return -1;
return RT.booleanCast(invoke(o2,o1))? 1 : 0;
}

Number n = (Number) o;
return n.intValue();
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}
}

———-

8.3 Agent.java

— Agent.java —

\getchunk{Clojure Copyright}
/* rich Nov 17, 2007 */

package clojure.lang;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;
8.3. AGENT.JAVA 401

import java.util.concurrent.atomic.AtomicReference;

public class Agent extends ARef {

static class ActionQueue {

public final IPersistentStack q;
public final Throwable error; // non-null indicates fail state
static final ActionQueue EMPTY =
new ActionQueue(PersistentQueue.EMPTY, null);

public ActionQueue( IPersistentStack q, Throwable error )

{
this.q = q;
this.error = error;
}
}

static final Keyword CONTINUE = Keyword.intern(null, "continue");

static final Keyword FAIL = Keyword.intern(null, "fail");

volatile Object state;

AtomicReference<ActionQueue> aq =
new AtomicReference<ActionQueue>(ActionQueue.EMPTY);

volatile Keyword errorMode = CONTINUE;

volatile IFn errorHandler = null;

final private static AtomicLong sendThreadPoolCounter =

new AtomicLong(0);

final private static AtomicLong sendOffThreadPoolCounter =

new AtomicLong(0);

final public static ExecutorService pooledExecutor =

Executors.newFixedThreadPool(
2 + Runtime.getRuntime().availableProcessors(),
createThreadFactory("clojure-agent-send-pool-%d",
sendThreadPoolCounter));

final public static ExecutorService soloExecutor =

Executors.newCachedThreadPool(
createThreadFactory("clojure-agent-send-off-pool-%d",
sendOffThreadPoolCounter));

final static ThreadLocal<IPersistentVector> nested =

new ThreadLocal<IPersistentVector>();

private static ThreadFactory

createThreadFactory(final String format,
final AtomicLong threadPoolCounter) {
402 CHAPTER 8. JVM/CLOJURE/LANG/

return new ThreadFactory() {

public Thread newThread(Runnable runnable) {
Thread thread = new Thread(runnable);
thread.setName(String.format(format,
threadPoolCounter.getAndIncrement()));
return thread;
}
};
}

public static void shutdown(){

soloExecutor.shutdown();
pooledExecutor.shutdown();
}

static class Action implements Runnable{

final Agent agent;
final IFn fn;
final ISeq args;
final boolean solo;

public Action(Agent agent, IFn fn, ISeq args, boolean solo){

this.agent = agent;
this.args = args;
this.fn = fn;
this.solo = solo;
}

void execute(){
try
{
if(solo)
soloExecutor.execute(this);
else
pooledExecutor.execute(this);
}
catch(Throwable error)
{
if(agent.errorHandler != null)
{
try
{
agent.errorHandler.invoke(agent, error);
}
catch(Throwable e) {} // ignore errorHandler errors
}
}
}
8.3. AGENT.JAVA 403

static void doRun(Action action){

try
{
nested.set(PersistentVector.EMPTY);

Throwable error = null;

try
{
Object oldval = action.agent.state;
Object newval =
action.fn.applyTo(
RT.cons(action.agent.state, action.args));
action.agent.setState(newval);
action.agent.notifyWatches(oldval,newval);
}
catch(Throwable e)
{
error = e;
}

if(error == null)
{
releasePendingSends();
}
else
{
nested.set(null); // allow errorHandler to send
if(action.agent.errorHandler != null)
{
try
{
action.agent.errorHandler.invoke(action.agent,
error);
}
catch(Throwable e) {} // ignore errorHandler errors
}
if(action.agent.errorMode == CONTINUE)
{
error = null;
}
}

boolean popped = false;

ActionQueue next = null;
while(!popped)
{
ActionQueue prior = action.agent.aq.get();
next = new ActionQueue(prior.q.pop(), error);
popped = action.agent.aq.compareAndSet(prior, next);
}
404 CHAPTER 8. JVM/CLOJURE/LANG/

if(error == null && next.q.count() > 0)

((Action) next.q.peek()).execute();
}
finally
{
nested.set(null);
}
}

public void run(){

doRun(this);
}
}

public Agent(Object state) throws Exception{

this(state,null);
}

public Agent(Object state, IPersistentMap meta) throws Exception {

super(meta);
setState(state);
}

boolean setState(Object newState) throws Exception{

validate(newState);
boolean ret = state != newState;
state = newState;
return ret;
}

public Object deref() throws Exception{

return state;
}

public Throwable getError(){

return aq.get().error;
}

public void setErrorMode(Keyword k){

errorMode = k;
}

public Keyword getErrorMode(){

return errorMode;
}

public void setErrorHandler(IFn f){

errorHandler = f;
}
8.3. AGENT.JAVA 405

public IFn getErrorHandler(){

return errorHandler;
}

synchronized public Object restart(Object newState,

boolean clearActions){
if(getError() == null)
{
throw new RuntimeException("Agent does not need a restart");
}
validate(newState);
state = newState;

if(clearActions)
aq.set(ActionQueue.EMPTY);
else
{
boolean restarted = false;
ActionQueue prior = null;
while(!restarted)
{
prior = aq.get();
restarted =
aq.compareAndSet(prior, new ActionQueue(prior.q, null));
}

if(prior.q.count() > 0)
((Action) prior.q.peek()).execute();
}

return newState;
}

public Object dispatch(IFn fn, ISeq args, boolean solo) {

Throwable error = getError();
if(error != null)
{
throw new RuntimeException("Agent is failed, needs restart",
error);
}
Action action = new Action(this, fn, args, solo);
dispatchAction(action);

return this;
}

static void dispatchAction(Action action){

LockingTransaction trans = LockingTransaction.getRunning();
if(trans != null)
406 CHAPTER 8. JVM/CLOJURE/LANG/

trans.enqueue(action);
else if(nested.get() != null)
{
nested.set(nested.get().cons(action));
}
else
action.agent.enqueue(action);
}

void enqueue(Action action){

boolean queued = false;
ActionQueue prior = null;
while(!queued)
{
prior = aq.get();
queued =
aq.compareAndSet(prior,
new ActionQueue((IPersistentStack)prior.q.cons(action),
prior.error));
}

if(prior.q.count() == 0 && prior.error == null)

action.execute();
}

public int getQueueCount(){

return aq.get().q.count();
}

static public int releasePendingSends(){

IPersistentVector sends = nested.get();
if(sends == null)
return 0;
for(int i=0;i<sends.count();i++)
{
Action a = (Action) sends.valAt(i);
a.agent.enqueue(a);
}
nested.set(PersistentVector.EMPTY);
return sends.count();
}
}

———-

8.4 AMapEntry.java
8.4. AMAPENTRY.JAVA 407

— AMapEntry.java —

\getchunk{Clojure Copyright}
/* rich Mar 1, 2008 */

package clojure.lang;

import java.io.StringWriter;

public abstract class AMapEntry

extends APersistentVector implements IMapEntry{

public Object nth(int i){

if(i == 0)
return key();
else if(i == 1)
return val();
else
throw new IndexOutOfBoundsException();
}

private IPersistentVector asVector(){

return LazilyPersistentVector.createOwning(key(), val());
}

public IPersistentVector assocN(int i, Object val){

return asVector().assocN(i, val);
}

public int count(){

return 2;
}

public ISeq seq(){

return asVector().seq();
}

public IPersistentVector cons(Object o){

return asVector().cons(o);
}

public IPersistentCollection empty(){

return null;
}

public IPersistentStack pop(){

return LazilyPersistentVector.createOwning(key());
}

public Object setValue(Object value){

408 CHAPTER 8. JVM/CLOJURE/LANG/

throw new UnsupportedOperationException();

}

public boolean equals(Object obj){

return APersistentVector.doEquals(this, obj);
}

public int hashCode(){

//must match logic in APersistentVector
return 31 * (31 + Util.hash(key())) + Util.hash(val());
// return Util.hashCombine(
Util.hashCombine(0, Util.hash(key())), Util.hash(val()));
}

public String toString(){

StringWriter sw = new StringWriter();
try
{
RT.print(this, sw);
}
catch(Exception e)
{
//checked exceptions stink!
throw new RuntimeException(e);
}
return sw.toString();
}

public int length(){

return 2;
}

public Object nth(int i){

if(i == 0)
return key();
else if(i == 1)
return val();
else
throw new IndexOutOfBoundsException();
}

private IPersistentVector asVector(){

return LazilyPersistentVector.createOwning(key(), val());
}

public IPersistentVector assocN(int i, Object val){

return asVector().assocN(i, val);
}
8.4. AMAPENTRY.JAVA 409

public int count(){

return 2;
}

public ISeq seq(){

return asVector().seq();
}

public IPersistentVector cons(Object o){

return asVector().cons(o);
}

public boolean containsKey(Object key){

return asVector().containsKey(key);
}

public IMapEntry entryAt(Object key){

return asVector().entryAt(key);
}

public Associative assoc(Object key, Object val){

return asVector().assoc(key, val);
}

public Object valAt(Object key){

return asVector().valAt(key);
}

public Object valAt(Object key, Object notFound){

return asVector().valAt(key, notFound);
}

public Object peek(){

return val();
}

public ISeq rseq() throws Exception{

return asVector().rseq();
}
*/

———-
410 CHAPTER 8. JVM/CLOJURE/LANG/

8.5 APersistentMap.java

— APersistentMap.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.Serializable;
import java.util.*;

public abstract class APersistentMap

extends AFn
implements IPersistentMap, Map, Iterable, Serializable,
MapEquivalence {
int _hash = -1;

public String toString(){

return RT.printString(this);
}

public IPersistentCollection cons(Object o){

if(o instanceof Map.Entry)
{
Map.Entry e = (Map.Entry) o;

return assoc(e.getKey(), e.getValue());

}
else if(o instanceof IPersistentVector)
{
IPersistentVector v = (IPersistentVector) o;
if(v.count() != 2)
throw new IllegalArgumentException(
"Vector arg to map conj must be a pair");
return assoc(v.nth(0), v.nth(1));
}

IPersistentMap ret = this;

for(ISeq es = RT.seq(o); es != null; es = es.next())
{
Map.Entry e = (Map.Entry) es.first();
ret = ret.assoc(e.getKey(), e.getValue());
}
return ret;
}

public boolean equals(Object obj){

return mapEquals(this, obj);
}
8.5. APERSISTENTMAP.JAVA 411

static public boolean mapEquals(IPersistentMap m1, Object obj){

if(m1 == obj) return true;
if(!(obj instanceof Map))
return false;
Map m = (Map) obj;

if(m.size() != m1.count() || m.hashCode() != m1.hashCode())

return false;

for(ISeq s = m1.seq(); s != null; s = s.next())

{
Map.Entry e = (Map.Entry) s.first();
boolean found = m.containsKey(e.getKey());

if(!found ||
!Util.equals(e.getValue(), m.get(e.getKey())))
return false;
}

return true;
}

public boolean equiv(Object obj){

if(!(obj instanceof Map))
return false;
if(obj instanceof IPersistentMap &&
!(obj instanceof MapEquivalence))
return false;

Map m = (Map) obj;

if(m.size() != size())
return false;

for(ISeq s = seq(); s != null; s = s.next())

{
Map.Entry e = (Map.Entry) s.first();
boolean found = m.containsKey(e.getKey());

if(!found ||
!Util.equiv(e.getValue(), m.get(e.getKey())))
return false;
}

return true;
}
public int hashCode(){
if(_hash == -1)
{
412 CHAPTER 8. JVM/CLOJURE/LANG/

this._hash = mapHash(this);
}
return _hash;
}

static public int mapHash(IPersistentMap m){

int hash = 0;
for(ISeq s = m.seq(); s != null; s = s.next())
{
Map.Entry e = (Map.Entry) s.first();
hash += (e.getKey() == null ? 0 :
e.getKey().hashCode()) ^
(e.getValue() == null ? 0 : e.getValue().hashCode());
}
return hash;
}

static public class KeySeq extends ASeq{

ISeq seq;

static public KeySeq create(ISeq seq){

if(seq == null)
return null;
return new KeySeq(seq);
}

private KeySeq(ISeq seq){

this.seq = seq;
}

private KeySeq(IPersistentMap meta, ISeq seq){

super(meta);
this.seq = seq;
}

public Object first(){

return ((Map.Entry) seq.first()).getKey();
}

public ISeq next(){

return create(seq.next());
}

public KeySeq withMeta(IPersistentMap meta){

return new KeySeq(meta, seq);
}
}

static public class ValSeq extends ASeq{

ISeq seq;
8.5. APERSISTENTMAP.JAVA 413

static public ValSeq create(ISeq seq){

if(seq == null)
return null;
return new ValSeq(seq);
}

private ValSeq(ISeq seq){

this.seq = seq;
}

private ValSeq(IPersistentMap meta, ISeq seq){

super(meta);
this.seq = seq;
}

public Object first(){

return ((Map.Entry) seq.first()).getValue();
}

public ISeq next(){

return create(seq.next());
}

public ValSeq withMeta(IPersistentMap meta){

return new ValSeq(meta, seq);
}
}

public Object invoke(Object arg1) throws Exception{

return valAt(arg1);
}

public Object invoke(Object arg1, Object notFound) throws Exception{

return valAt(arg1, notFound);
}

// java.util.Map implementation

public void clear(){

throw new UnsupportedOperationException();
}

public boolean containsValue(Object value){

return values().contains(value);
}

public Set entrySet(){

return new AbstractSet(){
414 CHAPTER 8. JVM/CLOJURE/LANG/

public Iterator iterator(){

return APersistentMap.this.iterator();
}

public int size(){

return count();
}

public int hashCode(){

return APersistentMap.this.hashCode();
}

public boolean contains(Object o){

if(o instanceof Entry)
{
Entry e = (Entry) o;
Entry found = entryAt(e.getKey());
if(found != null &&
Util.equals(found.getValue(), e.getValue()))
return true;
}
return false;
}
};
}

public Object get(Object key){

return valAt(key);
}

public boolean isEmpty(){

return count() == 0;
}

public Set keySet(){

return new AbstractSet(){

public Iterator iterator(){

final Iterator mi = APersistentMap.this.iterator();

return new Iterator(){

public boolean hasNext(){

return mi.hasNext();
}

public Object next(){

Entry e = (Entry) mi.next();
8.5. APERSISTENTMAP.JAVA 415

return e.getKey();
}

public void remove(){

throw new UnsupportedOperationException();
}
};
}

public int size(){

return count();
}

public boolean contains(Object o){

return APersistentMap.this.containsKey(o);
}
};
}

public Object put(Object key, Object value){

throw new UnsupportedOperationException();
}

public void putAll(Map t){

throw new UnsupportedOperationException();
}

public Object remove(Object key){

throw new UnsupportedOperationException();
}

public int size(){

return count();
}

public Collection values(){

return new AbstractCollection(){

public Iterator iterator(){

final Iterator mi = APersistentMap.this.iterator();

return new Iterator(){

public boolean hasNext(){

return mi.hasNext();
}

public Object next(){

Entry e = (Entry) mi.next();
416 CHAPTER 8. JVM/CLOJURE/LANG/

return e.getValue();
}

public void remove(){

throw new UnsupportedOperationException();
}
};
}

public int size(){

return count();
}
};
}

/*
// java.util.Collection implementation

public Object[] toArray(){

return RT.seqToArray(seq());
}

public boolean add(Object o){

throw new UnsupportedOperationException();
}

public boolean remove(Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(Collection c){

throw new UnsupportedOperationException();
}

public void clear(){

throw new UnsupportedOperationException();
}

public boolean retainAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean removeAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean containsAll(Collection c){

for(Object o : c)
{
if(!contains(o))
8.6. APERSISTENTSET.JAVA 417

return false;
}
return true;
}

public Object[] toArray(Object[] a){

if(a.length >= count())
{
ISeq s = seq();
for(int i = 0; s != null; ++i, s = s.rest())
{
a[i] = s.first();
}
if(a.length > count())
a[count()] = null;
return a;
}
else
return toArray();
}

public int size(){

return count();
}

public boolean isEmpty(){

return count() == 0;
}

public boolean contains(Object o){

if(o instanceof Map.Entry)
{
Map.Entry e = (Map.Entry) o;
Map.Entry v = entryAt(e.getKey());
return (v != null && Util.equal(v.getValue(), e.getValue()));
}
return false;
}
*/
}

———-

8.6 APersistentSet.java

— APersistentSet.java —
418 CHAPTER 8. JVM/CLOJURE/LANG/

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;

public abstract class APersistentSet

extends AFn
implements IPersistentSet, Collection, Set, Serializable {
int _hash = -1;
final IPersistentMap impl;

protected APersistentSet(IPersistentMap impl){

this.impl = impl;
}

public String toString(){

return RT.printString(this);
}

public boolean contains(Object key){

return impl.containsKey(key);
}

public Object get(Object key){

return impl.valAt(key);
}

public int count(){

return impl.count();
}

public ISeq seq(){

return RT.keys(impl);
}

public Object invoke(Object arg1) throws Exception{

return get(arg1);
}

public boolean equals(Object obj){

if(this == obj) return true;
if(!(obj instanceof Set))
return false;
Set m = (Set) obj;
8.6. APERSISTENTSET.JAVA 419

if(m.size() != count() || m.hashCode() != hashCode())

return false;

for(Object aM : m)
{
if(!contains(aM))
return false;
}
// for(ISeq s = seq(); s != null; s = s.rest())
// {
// if(!m.contains(s.first()))
// return false;
// }

return true;
}

public boolean equiv(Object o){

return equals(o);
}

public int hashCode(){

if(_hash == -1)
{
//int hash = count();
int hash = 0;
for(ISeq s = seq(); s != null; s = s.next())
{
Object e = s.first();
// hash = Util.hashCombine(hash, Util.hash(e));
hash += Util.hash(e);
}
this._hash = hash;
}
return _hash;
}

public Object[] toArray(){

return RT.seqToArray(seq());
}

public boolean add(Object o){

throw new UnsupportedOperationException();
}

public boolean remove(Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(Collection c){

420 CHAPTER 8. JVM/CLOJURE/LANG/

throw new UnsupportedOperationException();

}

public void clear(){

throw new UnsupportedOperationException();
}

public boolean retainAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean removeAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean containsAll(Collection c){

for(Object o : c)
{
if(!contains(o))
return false;
}
return true;
}

public Object[] toArray(Object[] a){

if(a.length >= count())
{
ISeq s = seq();
for(int i = 0; s != null; ++i, s = s.next())
{
a[i] = s.first();
}
if(a.length > count())
a[count()] = null;
return a;
}
else
return toArray();
}

public int size(){

return count();
}

public boolean isEmpty(){

return count() == 0;
}

public Iterator iterator(){

return new SeqIterator(seq());
8.7. APERSISTENTVECTOR.JAVA 421

———-

8.7 APersistentVector.java

— APersistentVector.java —

\getchunk{Clojure Copyright}
/* rich Dec 18, 2007 */

package clojure.lang;

import java.io.Serializable;
import java.util.*;

public abstract class APersistentVector

extends AFn
implements IPersistentVector, Iterable, List, RandomAccess,
Comparable, Serializable {
int _hash = -1;

public String toString(){

return RT.printString(this);
}

public ISeq seq(){

if(count() > 0)
return new Seq(this, 0);
return null;
}

public ISeq rseq(){

if(count() > 0)
return new RSeq(this, count() - 1);
return null;
}

static boolean doEquals(IPersistentVector v, Object obj){

if(v == obj) return true;
if(obj instanceof List || obj instanceof IPersistentVector)
{
Collection ma = (Collection) obj;
if(ma.size() != v.count() || ma.hashCode() != v.hashCode())
return false;
422 CHAPTER 8. JVM/CLOJURE/LANG/

for(Iterator i1 = ((List) v).iterator(), i2 = ma.iterator();

i1.hasNext();)
{
if(!Util.equals(i1.next(), i2.next()))
return false;
}
return true;
}
// if(obj instanceof IPersistentVector)
// {
// IPersistentVector ma = (IPersistentVector) obj;
// if(ma.count() != v.count() || ma.hashCode() != v.hashCode())
// return false;
// for(int i = 0; i < v.count(); i++)
// {
// if(!Util.equal(v.nth(i), ma.nth(i)))
// return false;
// }
// }
else
{
if(!(obj instanceof Sequential))
return false;
ISeq ms = RT.seq(obj);
for(int i = 0; i < v.count(); i++, ms = ms.next())
{
if(ms == null || !Util.equals(v.nth(i), ms.first()))
return false;
}
if(ms != null)
return false;
}

return true;

static boolean doEquiv(IPersistentVector v, Object obj){

if(obj instanceof List || obj instanceof IPersistentVector)
{
Collection ma = (Collection) obj;
if(ma.size() != v.count())
return false;
for(Iterator i1 = ((List) v).iterator(), i2 = ma.iterator();
i1.hasNext();)
{
if(!Util.equiv(i1.next(), i2.next()))
return false;
}
return true;
8.7. APERSISTENTVECTOR.JAVA 423

}
// if(obj instanceof IPersistentVector)
// {
// IPersistentVector ma = (IPersistentVector) obj;
// if(ma.count() != v.count() || ma.hashCode() != v.hashCode())
// return false;
// for(int i = 0; i < v.count(); i++)
// {
// if(!Util.equal(v.nth(i), ma.nth(i)))
// return false;
// }
// }
else
{
if(!(obj instanceof Sequential))
return false;
ISeq ms = RT.seq(obj);
for(int i = 0; i < v.count(); i++, ms = ms.next())
{
if(ms == null || !Util.equiv(v.nth(i), ms.first()))
return false;
}
if(ms != null)
return false;
}

return true;

public boolean equals(Object obj){

return doEquals(this, obj);
}

public boolean equiv(Object obj){

return doEquiv(this, obj);
}

public int hashCode(){

if(_hash == -1)
{
int hash = 1;
Iterator i = iterator();
while(i.hasNext())
{
Object obj = i.next();
hash = 31 * hash + (obj == null ? 0 : obj.hashCode());
}
// int hash = 0;
// for(int i = 0; i < count(); i++)
424 CHAPTER 8. JVM/CLOJURE/LANG/

// {
// hash = Util.hashCombine(hash, Util.hash(nth(i)));
// }
this._hash = hash;
}
return _hash;
}

public Object get(int index){

return nth(index);
}

public Object nth(int i, Object notFound){

if(i >= 0 && i < count())
return nth(i);
return notFound;
}

public Object remove(int i){

throw new UnsupportedOperationException();
}

public int indexOf(Object o){

for(int i = 0; i < count(); i++)
if(Util.equiv(nth(i), o))
return i;
return -1;
}

public int lastIndexOf(Object o){

for(int i = count() - 1; i >= 0; i--)
if(Util.equiv(nth(i), o))
return i;
return -1;
}

public ListIterator listIterator(){

return listIterator(0);
}

public ListIterator listIterator(final int index){

return new ListIterator(){
int nexti = index;

public boolean hasNext(){

return nexti < count();
}

public Object next(){

return nth(nexti++);
8.7. APERSISTENTVECTOR.JAVA 425

public boolean hasPrevious(){

return nexti > 0;
}

public Object previous(){

return nth(--nexti);
}

public int nextIndex(){

return nexti;
}

public int previousIndex(){

return nexti - 1;
}

public void remove(){

throw new UnsupportedOperationException();
}

public void set(Object o){

throw new UnsupportedOperationException();
}

public void add(Object o){

throw new UnsupportedOperationException();
}
};
}

public List subList(int fromIndex, int toIndex){

return (List) RT.subvec(this, fromIndex, toIndex);
}

public Object set(int i, Object o){

throw new UnsupportedOperationException();
}

public void add(int i, Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(int i, Collection c){

throw new UnsupportedOperationException();
}
426 CHAPTER 8. JVM/CLOJURE/LANG/

public Object invoke(Object arg1) throws Exception{

if(Util.isInteger(arg1))
return nth(((Number) arg1).intValue());
throw new IllegalArgumentException("Key must be integer");
}

public Iterator iterator(){

//todo - something more efficient
return new Iterator(){
int i = 0;

public boolean hasNext(){

return i < count();
}

public Object next(){

return nth(i++);
}

public void remove(){

throw new UnsupportedOperationException();
}
};
}

public Object peek(){

if(count() > 0)
return nth(count() - 1);
return null;
}

public boolean containsKey(Object key){

if(!(Util.isInteger(key)))
return false;
int i = ((Number) key).intValue();
return i >= 0 && i < count();
}

public IMapEntry entryAt(Object key){

if(Util.isInteger(key))
{
int i = ((Number) key).intValue();
if(i >= 0 && i < count())
return new MapEntry(key, nth(i));
}
return null;
}

public IPersistentVector assoc(Object key, Object val){

if(Util.isInteger(key))
8.7. APERSISTENTVECTOR.JAVA 427

{
int i = ((Number) key).intValue();
return assocN(i, val);
}
throw new IllegalArgumentException("Key must be integer");
}

public Object valAt(Object key, Object notFound){

if(Util.isInteger(key))
{
int i = ((Number) key).intValue();
if(i >= 0 && i < count())
return nth(i);
}
return notFound;
}

public Object valAt(Object key){

return valAt(key, null);
}

// java.util.Collection implementation

public Object[] toArray(){

return RT.seqToArray(seq());
}

public boolean add(Object o){

throw new UnsupportedOperationException();
}

public boolean remove(Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(Collection c){

throw new UnsupportedOperationException();
}

public void clear(){

throw new UnsupportedOperationException();
}

public boolean retainAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean removeAll(Collection c){

throw new UnsupportedOperationException();
}
428 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean containsAll(Collection c){

for(Object o : c)
{
if(!contains(o))
return false;
}
return true;
}

public Object[] toArray(Object[] a){

if(a.length >= count())
{
ISeq s = seq();
for(int i = 0; s != null; ++i, s = s.next())
{
a[i] = s.first();
}
if(a.length > count())
a[count()] = null;
return a;
}
else
return toArray();
}

public int size(){

return count();
}

public boolean isEmpty(){

return count() == 0;
}

public boolean contains(Object o){

for(ISeq s = seq(); s != null; s = s.next())
{
if(Util.equiv(s.first(), o))
return true;
}
return false;
}

public int length(){

return count();
}

public int compareTo(Object o){

IPersistentVector v = (IPersistentVector) o;
if(count() < v.count())
8.7. APERSISTENTVECTOR.JAVA 429

return -1;
else if(count() > v.count())
return 1;
for(int i = 0; i < count(); i++)
{
int c = Util.compare(nth(i),v.nth(i));
if(c != 0)
return c;
}
return 0;
}

static class Seq extends ASeq implements IndexedSeq, IReduce{

//todo - something more efficient
final IPersistentVector v;
final int i;

public Seq(IPersistentVector v, int i){

this.v = v;
this.i = i;
}

Seq(IPersistentMap meta, IPersistentVector v, int i){

super(meta);
this.v = v;
this.i = i;
}

public Object first(){

return v.nth(i);
}

public ISeq next(){

if(i + 1 < v.count())
return new APersistentVector.Seq(v, i + 1);
return null;
}

public int index(){

return i;
}

public int count(){

return v.count() - i;
}

public APersistentVector.Seq withMeta(IPersistentMap meta){

return new APersistentVector.Seq(meta, v, i);
}
430 CHAPTER 8. JVM/CLOJURE/LANG/

public Object reduce(IFn f) throws Exception{

Object ret = v.nth(i);
for(int x = i + 1; x < v.count(); x++)
ret = f.invoke(ret, v.nth(x));
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, v.nth(i));
for(int x = i + 1; x < v.count(); x++)
ret = f.invoke(ret, v.nth(x));
return ret;
}
}

public static class RSeq extends ASeq implements IndexedSeq, Counted{

final IPersistentVector v;
final int i;

public RSeq(IPersistentVector vector, int i){

this.v = vector;
this.i = i;
}

RSeq(IPersistentMap meta, IPersistentVector v, int i){

super(meta);
this.v = v;
this.i = i;
}

public Object first(){

return v.nth(i);
}

public ISeq next(){

if(i > 0)
return new APersistentVector.RSeq(v, i - 1);
return null;
}

public int index(){

return i;
}

public int count(){

return i + 1;
}

public APersistentVector.RSeq withMeta(IPersistentMap meta){

8.7. APERSISTENTVECTOR.JAVA 431

return new APersistentVector.RSeq(meta, v, i);

}
}

static class SubVector extends APersistentVector implements IObj{

final IPersistentVector v;
final int start;
final int end;
final IPersistentMap _meta;

public SubVector(IPersistentMap meta,

IPersistentVector v,
int start,
int end){
this._meta = meta;

if(v instanceof APersistentVector.SubVector)

{
APersistentVector.SubVector sv =
(APersistentVector.SubVector) v;
start += sv.start;
end += sv.start;
v = sv.v;
}
this.v = v;
this.start = start;
this.end = end;
}

public Object nth(int i){

if(start + i >= end)
throw new IndexOutOfBoundsException();
return v.nth(start + i);
}

public IPersistentVector assocN(int i, Object val){

if(start + i > end)
throw new IndexOutOfBoundsException();
else if(start + i == end)
return cons(val);
return
new SubVector(_meta, v.assocN(start + i, val), start, end);
}

public int count(){

return end - start;
}
432 CHAPTER 8. JVM/CLOJURE/LANG/

public IPersistentVector cons(Object o){

return new SubVector(_meta, v.assocN(end, o), start, end + 1);
}

public IPersistentCollection empty(){

return PersistentVector.EMPTY.withMeta(meta());
}

public IPersistentStack pop(){

if(end - 1 == start)
{
return PersistentVector.EMPTY;
}
return new SubVector(_meta, v, start, end - 1);
}

public SubVector withMeta(IPersistentMap meta){

if(meta == _meta)
return this;
return new SubVector(meta, v, start, end);
}

public IPersistentMap meta(){

return _meta;
}
}
}

———-

8.8 AReference.java

— AReference.java —

\getchunk{Clojure Copyright}
/* rich Dec 31, 2008 */

package clojure.lang;

public class AReference implements IReference {

private IPersistentMap _meta;

public AReference() {
this(null);
}

public AReference(IPersistentMap meta) {

8.9. AREF.JAVA 433

_meta = meta;
}

synchronized public IPersistentMap meta() {

return _meta;
}

synchronized public IPersistentMap alterMeta(IFn alter, ISeq args)

throws Exception {
_meta = (IPersistentMap) alter.applyTo(new Cons(_meta, args));
return _meta;
}

synchronized public IPersistentMap resetMeta(IPersistentMap m) {

_meta = m;
return m;
}

———-

8.9 ARef.java

— ARef.java —

\getchunk{Clojure Copyright}
/* rich Jan 1, 2009 */

package clojure.lang;

import java.util.Map;

public abstract class ARef extends AReference implements IRef{

protected volatile IFn validator = null;
private volatile IPersistentMap watches = PersistentHashMap.EMPTY;

public ARef(){
super();
}

public ARef(IPersistentMap meta){

super(meta);
}

void validate(IFn vf, Object val){

try
434 CHAPTER 8. JVM/CLOJURE/LANG/

{
if(vf != null && !RT.booleanCast(vf.invoke(val)))
throw new IllegalStateException("Invalid reference state");
}
catch(RuntimeException re)
{
throw re;
}
catch(Exception e)
{
throw new IllegalStateException("Invalid reference state", e);
}
}

void validate(Object val){

validate(validator, val);
}

public void setValidator(IFn vf){

try
{
validate(vf, deref());
}
catch(Exception e)
{
throw new RuntimeException(e);
}
validator = vf;
}

public IFn getValidator(){

return validator;
}

public IPersistentMap getWatches(){

return watches;
}

synchronized public IRef addWatch(Object key, IFn callback){

watches = watches.assoc(key, callback);
return this;
}

synchronized public IRef removeWatch(Object key){

try
{
watches = watches.without(key);
}
catch(Exception e)
{
8.10. ARITYEXCEPTION.JAVA 435

throw new RuntimeException(e);

}

return this;
}

public void notifyWatches(Object oldval, Object newval){

IPersistentMap ws = watches;
if(ws.count() > 0)
{
for(ISeq s = ws.seq(); s != null; s = s.next())
{
Map.Entry e = (Map.Entry) s.first();
IFn fn = (IFn) e.getValue();
try
{
if(fn != null)
fn.invoke(e.getKey(), this, oldval, newval);
}
catch(Exception e1)
{
throw new RuntimeException(e1);
}
}
}
}
}

———-

8.10 ArityException.java

— ArityException.java —

\getchunk{Clojure Copyright}
package clojure.lang;

/**
* @since 1.3
*/
public class ArityException extends IllegalArgumentException {

final public int actual;

final public String name;

public ArityException(int actual, String name) {

436 CHAPTER 8. JVM/CLOJURE/LANG/

this(actual, name, null);

}

public ArityException(int actual, String name, Throwable cause) {

super("Wrong number of args (" + actual +
") passed to: " + name, cause);
this.actual = actual;
this.name = name;
}

———-

8.11 ArrayChunk.java

— ArrayChunk.java —

\getchunk{Clojure Copyright}
/* rich May 24, 2009 */

package clojure.lang;

import java.io.Serializable;

public final class ArrayChunk implements IChunk, Serializable {

final Object[] array;

final int off;
final int end;

public ArrayChunk(Object[] array){

this(array, 0, array.length);
}

public ArrayChunk(Object[] array, int off){

this(array, off, array.length);
}

public ArrayChunk(Object[] array, int off, int end){

this.array = array;
this.off = off;
this.end = end;
}

public Object nth(int i){

return array[off + i];
8.12. ARRAYSEQ.JAVA 437

public Object nth(int i, Object notFound){

if(i >= 0 && i < count())
return nth(i);
return notFound;
}

public int count(){

return end - off;
}

public IChunk dropFirst(){

if(off==end)
throw new IllegalStateException("dropFirst of empty chunk");
return new ArrayChunk(array, off + 1, end);
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, array[off]);
for(int x = off + 1; x < end; x++)
ret = f.invoke(ret, array[x]);
return ret;
}
}

———-

8.12 ArraySeq.java

— ArraySeq.java —

\getchunk{Clojure Copyright}
/* rich Jun 19, 2006 */

package clojure.lang;

import java.lang.reflect.Array;

public class ArraySeq extends ASeq implements IndexedSeq, IReduce{

public final Object array;
final int i;
final Object[] oa;
final Class ct;
//ISeq _rest;

static public ArraySeq create(){

438 CHAPTER 8. JVM/CLOJURE/LANG/

return null;
}

static public ArraySeq create(Object... array){

if(array == null || array.length == 0)
return null;
return new ArraySeq(array, 0);
}

static ISeq createFromObject(Object array){

if(array == null || Array.getLength(array) == 0)
return null;
Class aclass = array.getClass();
if(aclass == int[].class)
return new ArraySeq_int(null, (int[]) array, 0);
if(aclass == float[].class)
return new ArraySeq_float(null, (float[]) array, 0);
if(aclass == double[].class)
return new ArraySeq_double(null, (double[]) array, 0);
if(aclass == long[].class)
return new ArraySeq_long(null, (long[]) array, 0);
if(aclass == byte[].class)
return new ArraySeq_byte(null, (byte[]) array, 0);
if(aclass == char[].class)
return new ArraySeq_char(null, (char[]) array, 0);
if(aclass == boolean[].class)
return new ArraySeq_boolean(null, (boolean[]) array, 0);
return new ArraySeq(array, 0);
}

ArraySeq(Object array, int i){

this.array = array;
this.ct = array.getClass().getComponentType();
this.i = i;
this.oa = (Object[]) (array instanceof Object[] ? array : null);
// this._rest = this;
}

ArraySeq(IPersistentMap meta, Object array, int i){

super(meta);
this.array = array;
this.ct = array.getClass().getComponentType();
this.i = i;
this.oa = (Object[]) (array instanceof Object[] ? array : null);
}

public Object first(){

if(oa != null)
return oa[i];
return Reflector.prepRet(ct, Array.get(array, i));
8.12. ARRAYSEQ.JAVA 439

public ISeq next(){

if(oa != null)
{
if(i + 1 < oa.length)
return new ArraySeq(array, i + 1);
}
else
{
if(i + 1 < Array.getLength(array))
return new ArraySeq(array, i + 1);
}
return null;
}

public int count(){

if(oa != null)
return oa.length - i;
return Array.getLength(array) - i;
}

public int index(){

return i;
}

public ArraySeq withMeta(IPersistentMap meta){

return new ArraySeq(meta, array, i);
}

public Object reduce(IFn f) throws Exception{

if(oa != null)
{
Object ret = oa[i];
for(int x = i + 1; x < oa.length; x++)
ret = f.invoke(ret, oa[x]);
return ret;
}

Object ret = Reflector.prepRet(ct, Array.get(array, i));

for(int x = i + 1; x < Array.getLength(array); x++)
ret = f.invoke(ret, Reflector.prepRet(ct, Array.get(array, x)));
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

if(oa != null)
{
Object ret = f.invoke(start, oa[i]);
for(int x = i + 1; x < oa.length; x++)
440 CHAPTER 8. JVM/CLOJURE/LANG/

ret = f.invoke(ret, oa[x]);

return ret;
}
Object ret =
f.invoke(start, Reflector.prepRet(ct, Array.get(array, i)));
for(int x = i + 1; x < Array.getLength(array); x++)
ret = f.invoke(ret, Reflector.prepRet(ct, Array.get(array, x)));
return ret;
}

public int indexOf(Object o) {

if (oa != null) {
for (int j = i; j < oa.length; j++)
if (Util.equals(o, oa[j])) return j - i;
} else {
int n = Array.getLength(array);
for (int j = i; j < n; j++)
if (Util.equals(o,
Reflector.prepRet(ct, Array.get(array, j))))
return j - i;
}
return -1;
}

public int lastIndexOf(Object o) {

if (oa != null) {
if (o == null) {
for (int j = oa.length - 1 ; j >= i; j--)
if (oa[j] == null) return j - i;
} else {
for (int j = oa.length - 1 ; j >= i; j--)
if (o.equals(oa[j])) return j - i;
}
} else {
if (o == null) {
for (int j = Array.getLength(array) - 1 ; j >= i; j--)
if (Reflector.prepRet(ct,
Array.get(array, j)) == null) return j - i;
} else {
for (int j = Array.getLength(array) - 1 ; j >= i; j--)
if (o.equals(Reflector.prepRet(ct,
Array.get(array, j)))) return j - i;
}
}
return -1;
}

//// specialized primitive versions ////

static public class ArraySeq_int

8.12. ARRAYSEQ.JAVA 441

extends ASeq implements IndexedSeq, IReduce{

public final int[] array;
final int i;

ArraySeq_int(IPersistentMap meta, int[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return array[i];
}

public ISeq next(){

if(i + 1 < array.length)
return new ArraySeq_int(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}

public ArraySeq_int withMeta(IPersistentMap meta){

return new ArraySeq_int(meta, array, i);
}

public Object reduce(IFn f) throws Exception{

Object ret = array[i];
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public int indexOf(Object o) {

if (o instanceof Number) {
int k = ((Number) o).intValue();
for (int j = i; j < array.length; j++)
442 CHAPTER 8. JVM/CLOJURE/LANG/

if (k == array[j]) return j - i;
}

return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Number) {
int k = ((Number) o).intValue();
for (int j = array.length - 1; j >= i; j--)
if (k == array[j]) return j - i;
}

return -1;
}
}

static public class ArraySeq_float

extends ASeq implements IndexedSeq, IReduce{
public final float[] array;
final int i;

ArraySeq_float(IPersistentMap meta, float[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return Numbers.num(array[i]);
}

public ISeq next(){

if(i + 1 < array.length)
return new ArraySeq_float(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}

public ArraySeq_float withMeta(IPersistentMap meta){

return new ArraySeq_float(meta, array, i);
}
8.12. ARRAYSEQ.JAVA 443

public Object reduce(IFn f) throws Exception{

Object ret = Numbers.num(array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, Numbers.num(array[x]));
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, Numbers.num(array[i]));
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, Numbers.num(array[x]));
return ret;
}

public int indexOf(Object o) {

if (o instanceof Number) {
float f = ((Number) o).floatValue();
for (int j = i; j < array.length; j++)
if (f == array[j]) return j - i;
}
return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Number) {
float f = ((Number) o).floatValue();
for (int j = array.length - 1; j >= i; j--)
if (f == array[j]) return j - i;
}
return -1;
}
}

static public class ArraySeq_double

extends ASeq implements IndexedSeq, IReduce{
public final double[] array;
final int i;

ArraySeq_double(IPersistentMap meta, double[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return array[i];
}

public ISeq next(){

444 CHAPTER 8. JVM/CLOJURE/LANG/

if(i + 1 < array.length)

return new ArraySeq_double(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}

public ArraySeq_double withMeta(IPersistentMap meta){

return new ArraySeq_double(meta, array, i);
}

public Object reduce(IFn f) throws Exception{

Object ret = array[i];
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public int indexOf(Object o) {

if (o instanceof Number) {
double d = ((Number) o).doubleValue();
for (int j = i; j < array.length; j++)
if (d == array[j]) return j - i;
}

return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Number) {
double d = ((Number) o).doubleValue();
for (int j = array.length - 1; j >= i; j--)
if (d == array[j]) return j - i;
}

return -1;
}
8.12. ARRAYSEQ.JAVA 445

static public class ArraySeq_long

extends ASeq implements IndexedSeq, IReduce{
public final long[] array;
final int i;

ArraySeq_long(IPersistentMap meta, long[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return Numbers.num(array[i]);
}

public ISeq next(){

if(i + 1 < array.length)
return new ArraySeq_long(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}

public ArraySeq_long withMeta(IPersistentMap meta){

return new ArraySeq_long(meta, array, i);
}

public Object reduce(IFn f) throws Exception{

Object ret = Numbers.num(array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, Numbers.num(array[x]));
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, Numbers.num(array[i]));
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, Numbers.num(array[x]));
return ret;
}

public int indexOf(Object o) {

446 CHAPTER 8. JVM/CLOJURE/LANG/

if (o instanceof Number) {
long l = ((Number) o).longValue();
for (int j = i; j < array.length; j++)
if (l == array[j]) return j - i;
}

return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Number) {
long l = ((Number) o).longValue();
for (int j = array.length - 1; j >= i; j--)
if (l == array[j]) return j - i;
}

return -1;
}
}

static public class ArraySeq_byte

extends ASeq implements IndexedSeq, IReduce{
public final byte[] array;
final int i;

ArraySeq_byte(IPersistentMap meta, byte[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return array[i];
}

public ISeq next(){

if(i + 1 < array.length)
return new ArraySeq_byte(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}

public ArraySeq_byte withMeta(IPersistentMap meta){

8.12. ARRAYSEQ.JAVA 447

return new ArraySeq_byte(meta, array, i);

}

public Object reduce(IFn f) throws Exception{

Object ret = array[i];
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public int indexOf(Object o) {

if (o instanceof Byte) {
byte b = ((Byte) o).byteValue();
for (int j = i; j < array.length; j++)
if (b == array[j]) return j - i;
}
if (o == null) {
return -1;
}
for (int j = i; j < array.length; j++)
if (o.equals(array[j])) return j - i;
return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Byte) {
byte b = ((Byte) o).byteValue();
for (int j = array.length - 1; j >= i; j--)
if (b == array[j]) return j - i;
}
if (o == null) {
return -1;
}
for (int j = array.length - 1; j >= i; j--)
if (o.equals(array[j])) return j - i;
return -1;
}
}

static public class ArraySeq_char

extends ASeq implements IndexedSeq, IReduce{
public final char[] array;
final int i;
448 CHAPTER 8. JVM/CLOJURE/LANG/

ArraySeq_char(IPersistentMap meta, char[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return array[i];
}

public ISeq next(){

if(i + 1 < array.length)
return new ArraySeq_char(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}

public ArraySeq_char withMeta(IPersistentMap meta){

return new ArraySeq_char(meta, array, i);
}

public Object reduce(IFn f) throws Exception{

Object ret = array[i];
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public int indexOf(Object o) {

if (o instanceof Character) {
char c = ((Character) o).charValue();
for (int j = i; j < array.length; j++)
if (c == array[j]) return j - i;
}
if (o == null) {
8.12. ARRAYSEQ.JAVA 449

return -1;
}
for (int j = i; j < array.length; j++)
if (o.equals(array[j])) return j - i;
return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Character) {
char c = ((Character) o).charValue();
for (int j = array.length - 1; j >= i; j--)
if (c == array[j]) return j - i;
}
if (o == null) {
return -1;
}
for (int j = array.length - 1; j >= i; j--)
if (o.equals(array[j])) return j - i;
return -1;
}
}

static public class ArraySeq_boolean

extends ASeq implements IndexedSeq, IReduce{
public final boolean[] array;
final int i;

ArraySeq_boolean(IPersistentMap meta, boolean[] array, int i){

super(meta);
this.array = array;
this.i = i;
}

public Object first(){

return array[i];
}

public ISeq next(){

if(i + 1 < array.length)
return new ArraySeq_boolean(meta(), array, i + 1);
return null;
}

public int count(){

return array.length - i;
}

public int index(){

return i;
}
450 CHAPTER 8. JVM/CLOJURE/LANG/

public ArraySeq_boolean withMeta(IPersistentMap meta){

return new ArraySeq_boolean(meta, array, i);
}

public Object reduce(IFn f) throws Exception{

Object ret = array[i];
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, array[i]);
for(int x = i + 1; x < array.length; x++)
ret = f.invoke(ret, array[x]);
return ret;
}

public int indexOf(Object o) {

if (o instanceof Boolean) {
boolean b = ((Boolean) o).booleanValue();
for (int j = i; j < array.length; j++)
if (b == array[j]) return j - i;
}
if (o == null) {
return -1;
}
for (int j = i; j < array.length; j++)
if (o.equals(array[j])) return j - i;
return -1;
}

public int lastIndexOf(Object o) {

if (o instanceof Boolean) {
boolean b = ((Boolean) o).booleanValue();
for (int j = array.length - 1; j >= i; j--)
if (b == array[j]) return j - i;
}
if (o == null) {
return -1;
}
for (int j = array.length - 1; j >= i; j--)
if (o.equals(array[j])) return j - i;
return -1;
}
}

}
8.13. ASEQ.JAVA 451

———-

8.13 ASeq.java

— ASeq.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.Serializable;
import java.util.*;

public abstract class ASeq

extends Obj implements ISeq, List, Serializable {
transient int _hash = -1;

public String toString(){

return RT.printString(this);
}

public IPersistentCollection empty(){

return PersistentList.EMPTY;
}

protected ASeq(IPersistentMap meta){

super(meta);
}

protected ASeq(){
}

public boolean equiv(Object obj){

if(!(obj instanceof Sequential || obj instanceof List))

return false;
ISeq ms = RT.seq(obj);
for(ISeq s = seq(); s != null; s = s.next(), ms = ms.next())
{
if(ms == null || !Util.equiv(s.first(), ms.first()))
return false;
}
return ms == null;

public boolean equals(Object obj){

452 CHAPTER 8. JVM/CLOJURE/LANG/

if(this == obj) return true;

if(!(obj instanceof Sequential || obj instanceof List))
return false;
ISeq ms = RT.seq(obj);
for(ISeq s = seq(); s != null; s = s.next(), ms = ms.next())
{
if(ms == null || !Util.equals(s.first(), ms.first()))
return false;
}
return ms == null;

public int hashCode(){

if(_hash == -1)
{
int hash = 1;
for(ISeq s = seq(); s != null; s = s.next())
{
hash = 31 * hash + (s.first() == null
? 0 : s.first().hashCode());
}
this._hash = hash;
}
return _hash;
}

//public Object reduce(IFn f) throws Exception{

// Object ret = first();
// for(ISeq s = rest(); s != null; s = s.rest())
// ret = f.invoke(ret, s.first());
// return ret;
//}
//
//public Object reduce(IFn f, Object start) throws Exception{
// Object ret = f.invoke(start, first());
// for(ISeq s = rest(); s != null; s = s.rest())
// ret = f.invoke(ret, s.first());
// return ret;
//}

//public Object peek(){

// return first();
//}
//
//public IPersistentList pop(){
// return rest();
//}
8.13. ASEQ.JAVA 453

public int count(){

int i = 1;
for(ISeq s = next(); s != null; s = s.next(), i++)
if(s instanceof Counted)
return i + s.count();
return i;
}

final public ISeq seq(){

return this;
}

public ISeq cons(Object o){

return new Cons(o, this);
}

public ISeq more(){

ISeq s = next();
if(s == null)
return PersistentList.EMPTY;
return s;
}

//final public ISeq rest(){

// Seqable m = more();
// if(m == null)
// return null;
// return m.seq();
//}

// java.util.Collection implementation

public Object[] toArray(){

return RT.seqToArray(seq());
}

public boolean add(Object o){

throw new UnsupportedOperationException();
}

public boolean remove(Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(Collection c){

throw new UnsupportedOperationException();
}

public void clear(){

throw new UnsupportedOperationException();
454 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean retainAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean removeAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean containsAll(Collection c){

for(Object o : c)
{
if(!contains(o))
return false;
}
return true;
}

public Object[] toArray(Object[] a){

if(a.length >= count())
{
ISeq s = seq();
for(int i = 0; s != null; ++i, s = s.next())
{
a[i] = s.first();
}
if(a.length > count())
a[count()] = null;
return a;
}
else
return toArray();
}

public int size(){

return count();
}

public boolean isEmpty(){

return seq() == null;
}

public boolean contains(Object o){

for(ISeq s = seq(); s != null; s = s.next())
{
if(Util.equiv(s.first(), o))
return true;
}
return false;
8.13. ASEQ.JAVA 455

public Iterator iterator(){

return new SeqIterator(this);
}

//////////// List stuff /////////////////

private List reify(){
return Collections.unmodifiableList(new ArrayList(this));
}

public List subList(int fromIndex, int toIndex){

return reify().subList(fromIndex, toIndex);
}

public Object set(int index, Object element){

throw new UnsupportedOperationException();
}

public Object remove(int index){

throw new UnsupportedOperationException();
}

public int indexOf(Object o){

ISeq s = seq();
for(int i = 0; s != null; s = s.next(), i++)
{
if(Util.equiv(s.first(), o))
return i;
}
return -1;
}

public int lastIndexOf(Object o){

return reify().lastIndexOf(o);
}

public ListIterator listIterator(){

return reify().listIterator();
}

public ListIterator listIterator(int index){

return reify().listIterator(index);
}

public Object get(int index){

return RT.nth(this, index);
456 CHAPTER 8. JVM/CLOJURE/LANG/

public void add(int index, Object element){

throw new UnsupportedOperationException();
}

public boolean addAll(int index, Collection c){

throw new UnsupportedOperationException();
}

———-

8.14 Associative.java

— Associative.java —

\getchunk{Clojure Copyright}
package clojure.lang;
public interface Associative extends IPersistentCollection, ILookup{
boolean containsKey(Object key);

IMapEntry entryAt(Object key);

Associative assoc(Object key, Object val);

———-

8.15 Atom.java

— Atom.java —

\getchunk{Clojure Copyright}
/* rich Jan 1, 2009 */

package clojure.lang;

import java.util.concurrent.atomic.AtomicReference;

final public class Atom extends ARef{

final AtomicReference state;
8.15. ATOM.JAVA 457

public Atom(Object state){

this.state = new AtomicReference(state);
}

public Atom(Object state, IPersistentMap meta){

super(meta);
this.state = new AtomicReference(state);
}

public Object deref(){

return state.get();
}

public Object swap(IFn f) throws Exception{

for(; ;)
{
Object v = deref();
Object newv = f.invoke(v);
validate(newv);
if(state.compareAndSet(v, newv))
{
notifyWatches(v, newv);
return newv;
}
}
}

public Object swap(IFn f, Object arg) throws Exception{

for(; ;)
{
Object v = deref();
Object newv = f.invoke(v, arg);
validate(newv);
if(state.compareAndSet(v, newv))
{
notifyWatches(v, newv);
return newv;
}
}
}

public Object swap(IFn f, Object arg1, Object arg2) throws Exception{

for(; ;)
{
Object v = deref();
Object newv = f.invoke(v, arg1, arg2);
validate(newv);
if(state.compareAndSet(v, newv))
{
458 CHAPTER 8. JVM/CLOJURE/LANG/

notifyWatches(v, newv);
return newv;
}
}
}

public Object swap(IFn f, Object x, Object y, ISeq args)

throws Exception{
for(; ;)
{
Object v = deref();
Object newv = f.applyTo(RT.listStar(v, x, y, args));
validate(newv);
if(state.compareAndSet(v, newv))
{
notifyWatches(v, newv);
return newv;
}
}
}

public boolean compareAndSet(Object oldv, Object newv){

validate(newv);
boolean ret = state.compareAndSet(oldv, newv);
if(ret)
notifyWatches(oldv, newv);
return ret;
}

public Object reset(Object newval){

Object oldval = state.get();
validate(newval);
state.set(newval);
notifyWatches(oldval, newval);
return newval;
}
}

———-

8.16 ATransientMap.java

— ATransientMap.java —

\getchunk{Clojure Copyright}
package clojure.lang;
8.16. ATRANSIENTMAP.JAVA 459

import java.util.Map;

import clojure.lang.PersistentHashMap.INode;

abstract class ATransientMap extends AFn implements ITransientMap {

abstract void ensureEditable();
abstract ITransientMap doAssoc(Object key, Object val);
abstract ITransientMap doWithout(Object key);
abstract Object doValAt(Object key, Object notFound);
abstract int doCount();
abstract IPersistentMap doPersistent();

public ITransientMap conj(Object o) {

ensureEditable();
if(o instanceof Map.Entry)
{
Map.Entry e = (Map.Entry) o;

return assoc(e.getKey(), e.getValue());

ITransientMap ret = this;

for(ISeq es = RT.seq(o); es != null; es = es.next())
{
Map.Entry e = (Map.Entry) es.first();
ret = ret.assoc(e.getKey(), e.getValue());
}
return ret;
}

public final Object invoke(Object arg1) throws Exception{

return valAt(arg1);
}

public final Object invoke(Object arg1, Object notFound)

throws Exception{
return valAt(arg1, notFound);
}

public final Object valAt(Object key) {

return valAt(key, null);
}
460 CHAPTER 8. JVM/CLOJURE/LANG/

public final ITransientMap assoc(Object key, Object val) {

ensureEditable();
return doAssoc(key, val);
}

public final ITransientMap without(Object key) {

ensureEditable();
return doWithout(key);
}

public final IPersistentMap persistent() {

ensureEditable();
return doPersistent();
}

public final Object valAt(Object key, Object notFound) {

ensureEditable();
return doValAt(key, notFound);
}

public final int count() {

ensureEditable();
return doCount();
}
}

———-

8.17 ATransientSet.java

— ATransientSet.java —

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

public abstract class ATransientSet

extends AFn implements ITransientSet{
ITransientMap impl;

ATransientSet(ITransientMap impl) {
this.impl = impl;
}

public int count() {

8.18. BIGINT.JAVA 461

return impl.count();
}

public ITransientSet conj(Object val) {

ITransientMap m = impl.assoc(val, val);
if (m != impl) this.impl = m;
return this;
}

public boolean contains(Object key) {

return this != impl.valAt(key, this);
}

public ITransientSet disjoin(Object key) throws Exception {

ITransientMap m = impl.without(key);
if (m != impl) this.impl = m;
return this;
}

public Object get(Object key) {

return impl.valAt(key);
}

public Object invoke(Object key, Object notFound) throws Exception {

return impl.valAt(key, notFound);
}

public Object invoke(Object key) throws Exception {

return impl.valAt(key);
}

———-

8.18 BigInt.java

— BigInt.java —

\getchunk{Clojure Copyright}
/* chouser Jun 23, 2010 */

package clojure.lang;

import java.math.BigInteger;

public final class BigInt extends Number{

462 CHAPTER 8. JVM/CLOJURE/LANG/

final public long lpart;

final public BigInteger bipart;

final public static BigInt ZERO = new BigInt(0,null);

final public static BigInt ONE = new BigInt(1,null);

//must follow Long

public int hashCode(){
if(bipart == null)
return (int) (this.lpart ^ (this.lpart >>> 32));
return bipart.hashCode();
}

public boolean equals(Object obj){

if(this == obj)
return true;
if(obj instanceof BigInt)
{
BigInt o = (BigInt) obj;
if(bipart == null)
return o.bipart == null && this.lpart == o.lpart;
return o.bipart != null && this.bipart.equals(o.bipart);
}
return false;
}

private BigInt(long lpart, BigInteger bipart){

this.lpart = lpart;
this.bipart = bipart;
}

public static BigInt fromBigInteger(BigInteger val){

if(val.bitLength() < 64)
return new BigInt(val.longValue(), null);
else
return new BigInt(0, val);
}

public static BigInt fromLong(long val){

return new BigInt(val, null);
}

public BigInteger toBigInteger(){

if(bipart == null)
return BigInteger.valueOf(lpart);
else
return bipart;
}
8.18. BIGINT.JAVA 463

///// java.lang.Number:

public int intValue(){

if(bipart == null)
return (int) lpart;
else
return bipart.intValue();
}

public long longValue(){

if(bipart == null)
return lpart;
else
return bipart.longValue();
}

public float floatValue(){

if(bipart == null)
return lpart;
else
return bipart.floatValue();
}

public double doubleValue(){

if(bipart == null)
return lpart;
else
return bipart.doubleValue();
}

public byte byteValue(){

if(bipart == null)
return (byte) lpart;
else
return bipart.byteValue();
}

public short shortValue(){

if(bipart == null)
return (short) lpart;
else
return bipart.shortValue();
}

public static BigInt valueOf(long val){

return new BigInt(val, null);
}

public String toString(){

464 CHAPTER 8. JVM/CLOJURE/LANG/

if(bipart == null)
return String.valueOf(lpart);
return bipart.toString();
}

public int bitLength(){

return toBigInteger().bitLength();
}

———-

8.19 Binding.java

— Binding.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public class Binding<T>{

public T val;
public final Binding rest;

public Binding(T val){

this.val = val;
this.rest = null;
}

public Binding(T val, Binding rest){

this.val = val;
this.rest = rest;
}
}

———-

8.20 Box.java

— Box.java —

\getchunk{Clojure Copyright}
/* rich Mar 27, 2006 8:40:19 PM */
8.21. CHUNKBUFFER.JAVA 465

package clojure.lang;

public class Box{

public Object val;

public Box(Object val){

this.val = val;
}
}

———-

8.21 ChunkBuffer.java

— ChunkBuffer.java —

\getchunk{Clojure Copyright}
/* rich May 26, 2009 */

package clojure.lang;

final public class ChunkBuffer implements Counted{

Object[] buffer;
int end;

public ChunkBuffer(int capacity){

buffer = new Object[capacity];
end = 0;
}

public void add(Object o){

buffer[end++] = o;
}

public IChunk chunk(){

ArrayChunk ret = new ArrayChunk(buffer, 0, end);
buffer = null;
return ret;
}

public int count(){

return end;
}
}

———-
466 CHAPTER 8. JVM/CLOJURE/LANG/

8.22 ChunkedCons.java

— ChunkedCons.java —

\getchunk{Clojure Copyright}
/* rich May 25, 2009 */

package clojure.lang;

final public class ChunkedCons extends ASeq implements IChunkedSeq{

final IChunk chunk;

final ISeq _more;

ChunkedCons(IPersistentMap meta, IChunk chunk, ISeq more){

super(meta);
this.chunk = chunk;
this._more = more;
}

public ChunkedCons(IChunk chunk, ISeq more){

this(null,chunk, more);
}

public Obj withMeta(IPersistentMap meta){

if(meta != _meta)
return new ChunkedCons(meta, chunk, _more);
return this;
}

public Object first(){

return chunk.nth(0);
}

public ISeq next(){

if(chunk.count() > 1)
return new ChunkedCons(chunk.dropFirst(), _more);
return chunkedNext();
}

public ISeq more(){

if(chunk.count() > 1)
return new ChunkedCons(chunk.dropFirst(), _more);
if(_more == null)
return PersistentList.EMPTY;
return _more;
}
8.23. COMPILE.JAVA 467

public IChunk chunkedFirst(){

return chunk;
}

public ISeq chunkedNext(){

return chunkedMore().seq();
}

public ISeq chunkedMore(){

if(_more == null)
return PersistentList.EMPTY;
return _more;
}
}

———-

8.23 Compile.java

— Compile.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.IOException;

// Compiles libs and generates class files stored within the directory
// named by the Java System property "clojure.compile.path". Arguments
// are strings naming the libs to be compiled. The libs and compile-path
// must all be within CLASSPATH.

public class Compile{

private static final String PATH_PROP =

"clojure.compile.path";
private static final String REFLECTION_WARNING_PROP =
"clojure.compile.warn-on-reflection";
private static final Var compile_path =
RT.var("clojure.core", "*compile-path*");
private static final Var compile =
RT.var("clojure.core", "compile");
private static final Var warn_on_reflection =
RT.var("clojure.core", "*warn-on-reflection*");

public static void main(String[] args) throws Exception{

468 CHAPTER 8. JVM/CLOJURE/LANG/

OutputStreamWriter out = (OutputStreamWriter) RT.OUT.deref();

PrintWriter err = RT.errPrintWriter();
String path = System.getProperty(PATH_PROP);
int count = args.length;

if(path == null)
{
err.println("ERROR: Must set system property " + PATH_PROP +
"\nto the location for compiled .class files." +
"\nThis directory must also be on your CLASSPATH.");
System.exit(1);
}

boolean warnOnReflection =
System.getProperty(REFLECTION_WARNING_PROP, "false").equals("true");

try
{
Var.pushThreadBindings(
RT.map(compile_path,
path,
warn_on_reflection,
warnOnReflection));

for(String lib : args)

{
out.write("Compiling " + lib + " to " + path + "\n");
out.flush();
compile.invoke(Symbol.intern(lib));
}
}
finally
{
Var.popThreadBindings();
try
{
out.flush();
out.close();
}
catch(IOException e)
{
e.printStackTrace(err);
}
}
}
}

———-
8.24. COMPILER.JAVA 469

8.24 Compiler.java

— Compiler.java —

\getchunk{Clojure Copyright}
/* rich Aug 21, 2007 */

package clojure.lang;

//*

import clojure.asm.*;
import clojure.asm.commons.Method;
import clojure.asm.commons.GeneratorAdapter;
//*/
/*

import org.objectweb.asm.*;
import org.objectweb.asm.commons.Method;
import org.objectweb.asm.commons.GeneratorAdapter;
import org.objectweb.asm.util.TraceClassVisitor;
import org.objectweb.asm.util.CheckClassAdapter;
//*/

import java.io.*;
import java.util.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

public class Compiler implements Opcodes{

static final Symbol DEF = Symbol.intern("def");

static final Symbol LOOP = Symbol.intern("loop*");
static final Symbol RECUR = Symbol.intern("recur");
static final Symbol IF = Symbol.intern("if");
static final Symbol LET = Symbol.intern("let*");
static final Symbol LETFN = Symbol.intern("letfn*");
static final Symbol DO = Symbol.intern("do");
static final Symbol FN = Symbol.intern("fn*");
static final Symbol QUOTE = Symbol.intern("quote");
static final Symbol THE_VAR = Symbol.intern("var");
static final Symbol DOT = Symbol.intern(".");
static final Symbol ASSIGN = Symbol.intern("set!");
//static final Symbol TRY_FINALLY = Symbol.intern("try-finally");
static final Symbol TRY = Symbol.intern("try");
static final Symbol CATCH = Symbol.intern("catch");
static final Symbol FINALLY = Symbol.intern("finally");
static final Symbol THROW = Symbol.intern("throw");
470 CHAPTER 8. JVM/CLOJURE/LANG/

static final Symbol MONITOR_ENTER = Symbol.intern("monitor-enter");

static final Symbol MONITOR_EXIT = Symbol.intern("monitor-exit");
static final Symbol IMPORT = Symbol.intern("clojure.core", "import*");
//static final Symbol INSTANCE = Symbol.intern("instance?");
static final Symbol DEFTYPE = Symbol.intern("deftype*");
static final Symbol CASE = Symbol.intern("case*");

//static final Symbol THISFN = Symbol.intern("thisfn");

static final Symbol CLASS = Symbol.intern("Class");
static final Symbol NEW = Symbol.intern("new");
static final Symbol THIS = Symbol.intern("this");
static final Symbol REIFY = Symbol.intern("reify*");
//static final Symbol UNQUOTE = Symbol.intern("unquote");
//static final Symbol UNQUOTE_SPLICING =
// Symbol.intern("unquote-splicing");
//static final Symbol SYNTAX_QUOTE =
// Symbol.intern("clojure.core", "syntax-quote");
static final Symbol LIST = Symbol.intern("clojure.core", "list");
static final Symbol HASHMAP = Symbol.intern("clojure.core", "hash-map");
static final Symbol VECTOR = Symbol.intern("clojure.core", "vector");
static final Symbol IDENTITY = Symbol.intern("clojure.core", "identity");

static final Symbol _AMP_ = Symbol.intern("&");

static final Symbol ISEQ = Symbol.intern("clojure.lang.ISeq");

static final Keyword inlineKey = Keyword.intern(null, "inline");

static final Keyword inlineAritiesKey =
Keyword.intern(null, "inline-arities");
static final Keyword staticKey = Keyword.intern(null, "static");
static final Keyword arglistsKey = Keyword.intern(null, "arglists");
static final Symbol INVOKE_STATIC = Symbol.intern("invokeStatic");

static final Keyword volatileKey = Keyword.intern(null, "volatile");

static final Keyword implementsKey = Keyword.intern(null, "implements");
static final String COMPILE_STUB_PREFIX = "compile__stub";

static final Keyword protocolKey = Keyword.intern(null, "protocol");

static final Keyword onKey = Keyword.intern(null, "on");
static Keyword dynamicKey = Keyword.intern("dynamic");

static final Symbol NS = Symbol.intern("ns");

static final Symbol IN_NS = Symbol.intern("in-ns");

//static final Symbol IMPORT = Symbol.intern("import");

//static final Symbol USE = Symbol.intern("use");

//static final Symbol IFN = Symbol.intern("clojure.lang", "IFn");

static final public IPersistentMap specials = PersistentHashMap.create(

DEF, new DefExpr.Parser(),
8.24. COMPILER.JAVA 471

LOOP, new LetExpr.Parser(),

RECUR, new RecurExpr.Parser(),
IF, new IfExpr.Parser(),
CASE, new CaseExpr.Parser(),
LET, new LetExpr.Parser(),
LETFN, new LetFnExpr.Parser(),
DO, new BodyExpr.Parser(),
FN, null,
QUOTE, new ConstantExpr.Parser(),
THE_VAR, new TheVarExpr.Parser(),
IMPORT, new ImportExpr.Parser(),
DOT, new HostExpr.Parser(),
ASSIGN, new AssignExpr.Parser(),
DEFTYPE, new NewInstanceExpr.DeftypeParser(),
REIFY, new NewInstanceExpr.ReifyParser(),
// TRY_FINALLY, new TryFinallyExpr.Parser(),
TRY, new TryExpr.Parser(),
THROW, new ThrowExpr.Parser(),
MONITOR_ENTER, new MonitorEnterExpr.Parser(),
MONITOR_EXIT, new MonitorExitExpr.Parser(),
// INSTANCE, new InstanceExpr.Parser(),
// IDENTICAL, new IdenticalExpr.Parser(),
//THISFN, null,
CATCH, null,
FINALLY, null,
// CLASS, new ClassExpr.Parser(),
NEW, new NewExpr.Parser(),
// UNQUOTE, null,
// UNQUOTE_SPLICING, null,
// SYNTAX_QUOTE, null,
_AMP_, null
);

private static final int MAX_POSITIONAL_ARITY = 20;

private static final Type OBJECT_TYPE;
private static final Type KEYWORD_TYPE = Type.getType(Keyword.class);
private static final Type VAR_TYPE = Type.getType(Var.class);
private static final Type SYMBOL_TYPE = Type.getType(Symbol.class);
//private static final Type NUM_TYPE = Type.getType(Num.class);
private static final Type IFN_TYPE = Type.getType(IFn.class);
private static final Type AFUNCTION_TYPE = Type.getType(AFunction.class);
private static final Type RT_TYPE = Type.getType(RT.class);
private static final Type NUMBERS_TYPE = Type.getType(Numbers.class);
final static Type CLASS_TYPE = Type.getType(Class.class);
final static Type NS_TYPE = Type.getType(Namespace.class);
final static Type UTIL_TYPE = Type.getType(Util.class);
final static Type REFLECTOR_TYPE = Type.getType(Reflector.class);
final static Type THROWABLE_TYPE = Type.getType(Throwable.class);
final static Type BOOLEAN_OBJECT_TYPE = Type.getType(Boolean.class);
final static Type IPERSISTENTMAP_TYPE =
472 CHAPTER 8. JVM/CLOJURE/LANG/

Type.getType(IPersistentMap.class);
final static Type IOBJ_TYPE = Type.getType(IObj.class);

private static final Type[][] ARG_TYPES;

private static final Type[] EXCEPTION_TYPES =
{Type.getType(Exception.class)};

static
{
OBJECT_TYPE = Type.getType(Object.class);
ARG_TYPES = new Type[MAX_POSITIONAL_ARITY + 2][];
for(int i = 0; i <= MAX_POSITIONAL_ARITY; ++i)
{
Type[] a = new Type[i];
for(int j = 0; j < i; j++)
a[j] = OBJECT_TYPE;
ARG_TYPES[i] = a;
}
Type[] a = new Type[MAX_POSITIONAL_ARITY + 1];
for(int j = 0; j < MAX_POSITIONAL_ARITY; j++)
a[j] = OBJECT_TYPE;
a[MAX_POSITIONAL_ARITY] = Type.getType("[Ljava/lang/Object;");
ARG_TYPES[MAX_POSITIONAL_ARITY + 1] = a;

//symbol->localbinding
static final public Var LOCAL_ENV = Var.create(null).setDynamic();

//vector<localbinding>
static final public Var LOOP_LOCALS = Var.create().setDynamic();

//Label
static final public Var LOOP_LABEL = Var.create().setDynamic();

//vector<object>
static final public Var CONSTANTS = Var.create().setDynamic();

//IdentityHashMap
static final public Var CONSTANT_IDS = Var.create().setDynamic();

//vector<keyword>
static final public Var KEYWORD_CALLSITES = Var.create().setDynamic();

//vector<var>
static final public Var PROTOCOL_CALLSITES = Var.create().setDynamic();

//set<var>
8.24. COMPILER.JAVA 473

static final public Var VAR_CALLSITES = Var.create().setDynamic();

//keyword->constid
static final public Var KEYWORDS = Var.create().setDynamic();

//var->constid
static final public Var VARS = Var.create().setDynamic();

//FnFrame
static final public Var METHOD = Var.create(null).setDynamic();

//null or not
static final public Var IN_CATCH_FINALLY = Var.create(null).setDynamic();

static final public Var NO_RECUR = Var.create(null).setDynamic();

//DynamicClassLoader
static final public Var LOADER = Var.create().setDynamic();

//String
static final public Var SOURCE =
Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("*source-path*"), "NO_SOURCE_FILE").setDynamic();

//String
static final public Var SOURCE_PATH =
Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("*file*"), "NO_SOURCE_PATH").setDynamic();

//String
static final public Var COMPILE_PATH =
Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("*compile-path*"), null).setDynamic();
//boolean
static final public Var COMPILE_FILES =
Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("*compile-files*"), Boolean.FALSE).setDynamic();

static final public Var INSTANCE =

Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("instance?"));

static final public Var ADD_ANNOTATIONS =

Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("add-annotations"));

//boolean
static final public Var UNCHECKED_MATH =
Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
Symbol.intern("*unchecked-math*"), Boolean.FALSE).setDynamic();
474 CHAPTER 8. JVM/CLOJURE/LANG/

//Integer
static final public Var LINE = Var.create(0).setDynamic();

//Integer
static final public Var LINE_BEFORE = Var.create(0).setDynamic();
static final public Var LINE_AFTER = Var.create(0).setDynamic();

//Integer
static final public Var NEXT_LOCAL_NUM = Var.create(0).setDynamic();

//Integer
static final public Var RET_LOCAL_NUM = Var.create().setDynamic();

static final public Var COMPILE_STUB_SYM =

Var.create(null).setDynamic();
static final public Var COMPILE_STUB_CLASS =
Var.create(null).setDynamic();

//PathNode chain
static final public Var CLEAR_PATH = Var.create(null).setDynamic();

//tail of PathNode chain

static final public Var CLEAR_ROOT = Var.create(null).setDynamic();

//LocalBinding -> Set<LocalBindingExpr>

static final public Var CLEAR_SITES = Var.create(null).setDynamic();

public enum C{
STATEMENT, //value ignored
EXPRESSION, //value required
RETURN, //tail position relative to enclosing recur frame
EVAL
}

interface Expr{
Object eval() throws Exception;

void emit(C context, ObjExpr objx, GeneratorAdapter gen);

boolean hasJavaClass() throws Exception;

Class getJavaClass() throws Exception;

}

public static abstract class UntypedExpr implements Expr{

public Class getJavaClass(){

8.24. COMPILER.JAVA 475

throw new IllegalArgumentException("Has no Java class");

}

public boolean hasJavaClass(){

return false;
}
}

interface IParser{
Expr parse(C context, Object form) throws Exception;
}

static boolean isSpecial(Object sym){

return specials.containsKey(sym);
}

static Symbol resolveSymbol(Symbol sym){

//already qualified or classname?
if(sym.name.indexOf(’.’) > 0)
return sym;
if(sym.ns != null)
{
Namespace ns = namespaceFor(sym);
if(ns == null || ns.name.name == sym.ns)
return sym;
return Symbol.intern(ns.name.name, sym.name);
}
Object o = currentNS().getMapping(sym);
if(o == null)
return Symbol.intern(currentNS().name.name, sym.name);
else if(o instanceof Class)
return Symbol.intern(null, ((Class) o).getName());
else if(o instanceof Var)
{
Var v = (Var) o;
return Symbol.intern(v.ns.name.name, v.sym.name);
}
return null;

static class DefExpr implements Expr{

public final Var var;
public final Expr init;
public final Expr meta;
public final boolean initProvided;
public final boolean isDynamic;
public final String source;
public final int line;
final static Method bindRootMethod =
476 CHAPTER 8. JVM/CLOJURE/LANG/

Method.getMethod("void bindRoot(Object)");
final static Method setTagMethod =
Method.getMethod("void setTag(clojure.lang.Symbol)");
final static Method setMetaMethod =
Method.getMethod("void setMeta(clojure.lang.IPersistentMap)");
final static Method setDynamicMethod =
Method.getMethod("clojure.lang.Var setDynamic(boolean)");
final static Method symintern =
Method.getMethod("clojure.lang.Symbol intern(String, String)");

public DefExpr(String source, int line, Var var, Expr init,

Expr meta, boolean initProvided, boolean isDynamic){
this.source = source;
this.line = line;
this.var = var;
this.init = init;
this.meta = meta;
this.isDynamic = isDynamic;
this.initProvided = initProvided;
}

private boolean includesExplicitMetadata(MapExpr expr) {

for(int i=0; i < expr.keyvals.count(); i += 2)
{
Keyword k = ((KeywordExpr) expr.keyvals.nth(i)).k;
if ((k != RT.FILE_KEY) &&
(k != RT.DECLARED_KEY) &&
(k != RT.LINE_KEY))
return true;
}
return false;
}

public Object eval() throws Exception{

try
{
if(initProvided)
{
// if(init instanceof FnExpr &&
// ((FnExpr) init).closes.count()==0)
// var.bindRoot(new FnLoaderThunk((FnExpr) init,var));
// else
var.bindRoot(init.eval());
}
if(meta != null)
{
IPersistentMap metaMap = (IPersistentMap) meta.eval();
//includesExplicitMetadata((MapExpr) meta))
if (initProvided || true)
var.setMeta((IPersistentMap) meta.eval());
8.24. COMPILER.JAVA 477

}
return var.setDynamic(isDynamic);
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(source, line, e);
else
throw (CompilerException) e;
}
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

objx.emitVar(gen, var);
if(isDynamic)
{
gen.push(isDynamic);
gen.invokeVirtual(VAR_TYPE, setDynamicMethod);
}
if(meta != null)
{
//includesExplicitMetadata((MapExpr) meta))
if (initProvided || true)
{
gen.dup();
meta.emit(C.EXPRESSION, objx, gen);
gen.checkCast(IPERSISTENTMAP_TYPE);
gen.invokeVirtual(VAR_TYPE, setMetaMethod);
}
}
if(initProvided)
{
gen.dup();
init.emit(C.EXPRESSION, objx, gen);
gen.invokeVirtual(VAR_TYPE, bindRootMethod);
}

if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass(){

return Var.class;
}

static class Parser implements IParser{

478 CHAPTER 8. JVM/CLOJURE/LANG/

public Expr parse(C context, Object form) throws Exception{

//(def x) or (def x initexpr) or (def x "docstring" initexpr)
String docstring = null;
if(RT.count(form) == 4 &&
(RT.third(form) instanceof String)) {
docstring = (String) RT.third(form);
form = RT.list(RT.first(form),
RT.second(form),
RT.fourth(form));
}
if(RT.count(form) > 3)
throw new Exception("Too many arguments to def");
else if(RT.count(form) < 2)
throw new Exception("Too few arguments to def");
else if(!(RT.second(form) instanceof Symbol))
throw new Exception(
"First argument to def must be a Symbol");
Symbol sym = (Symbol) RT.second(form);
Var v = lookupVar(sym, true);
if(v == null)
throw new Exception(
"Can’t refer to qualified var that doesn’t exist");
if(!v.ns.equals(currentNS()))
{
if(sym.ns == null)
v = currentNS().intern(sym);
// throw new Exception(
// "Name conflict, can’t def " + sym +
// " because namespace: " + currentNS().name +
// " refers to:" + v);
else
throw new Exception(
"Can’t create defs outside of current ns");
}
IPersistentMap mm = sym.meta();
boolean isDynamic = RT.booleanCast(RT.get(mm,dynamicKey));
if(!isDynamic &&
sym.name.startsWith("*") &&
sym.name.endsWith("*") &&
sym.name.length() > 1)
{
RT.errPrintWriter().format(
"Var %s not marked :dynamic true, setting to "+
":dynamic. You should fix this before next release!\n",
sym);
isDynamic = true;
mm = (IPersistentMap) RT.assoc(mm,dynamicKey, RT.T);
}
if(RT.booleanCast(RT.get(mm, arglistsKey)))
{
8.24. COMPILER.JAVA 479

IPersistentMap vm = v.meta();
//vm = (IPersistentMap) RT.assoc(vm,staticKey,RT.T);
//drop quote
vm = (IPersistentMap)
RT.assoc(vm,arglistsKey,
RT.second(mm.valAt(arglistsKey)));
v.setMeta(vm);
}
Object source_path = SOURCE_PATH.get();
source_path = source_path ==
null ? "NO_SOURCE_FILE" : source_path;
mm = (IPersistentMap) RT.assoc(mm, RT.LINE_KEY, LINE.get())
.assoc(RT.FILE_KEY, source_path);
if (docstring != null)
mm = (IPersistentMap) RT.assoc(mm, RT.DOC_KEY, docstring);
Expr meta =
analyze(context == C.EVAL ? context : C.EXPRESSION, mm);
return new DefExpr((String) SOURCE.deref(),
(Integer) LINE.deref(),
v, analyze(
context == C.EVAL ?
context : C.EXPRESSION,
RT.third(form),
v.sym.name),
meta, RT.count(form) == 3, isDynamic);
}
}
}

public static class AssignExpr implements Expr{

public final AssignableExpr target;
public final Expr val;

public AssignExpr(AssignableExpr target, Expr val){

this.target = target;
this.val = val;
}

public Object eval() throws Exception{

return target.evalAssign(val);
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

target.emitAssign(context, objx, gen, val);
}

public boolean hasJavaClass() throws Exception{

return val.hasJavaClass();
}
480 CHAPTER 8. JVM/CLOJURE/LANG/

public Class getJavaClass() throws Exception{

return val.getJavaClass();
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
ISeq form = (ISeq) frm;
if(RT.length(form) != 3)
throw new IllegalArgumentException(
"Malformed assignment, expecting (set! target val)");
Expr target = analyze(C.EXPRESSION, RT.second(form));
if(!(target instanceof AssignableExpr))
throw new IllegalArgumentException(
"Invalid assignment target");
return new AssignExpr((AssignableExpr) target,
analyze(C.EXPRESSION,
RT.third(form)));
}
}
}

public static class VarExpr implements Expr, AssignableExpr{

public final Var var;
public final Object tag;
final static Method getMethod =
Method.getMethod("Object get()");
final static Method setMethod =
Method.getMethod("Object set(Object)");

public VarExpr(Var var, Symbol tag){

this.var = var;
this.tag = tag != null ? tag : var.getTag();
}

public Object eval() throws Exception{

return var.deref();
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

objx.emitVarValue(gen,var);
if(context == C.STATEMENT)
{
gen.pop();
}
}

public boolean hasJavaClass(){

return tag != null;
}
8.24. COMPILER.JAVA 481

public Class getJavaClass() throws Exception{

return HostExpr.tagToClass(tag);
}

public Object evalAssign(Expr val) throws Exception{

return var.set(val.eval());
}

public void emitAssign(C context, ObjExpr objx, GeneratorAdapter gen,

Expr val){
objx.emitVar(gen, var);
val.emit(C.EXPRESSION, objx, gen);
gen.invokeVirtual(VAR_TYPE, setMethod);
if(context == C.STATEMENT)
gen.pop();
}
}

public static class TheVarExpr implements Expr{

public final Var var;

public TheVarExpr(Var var){

this.var = var;
}

public Object eval() throws Exception{

return var;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

objx.emitVar(gen, var);
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws ClassNotFoundException{

return Var.class;
}

static class Parser implements IParser{

public Expr parse(C context, Object form) throws Exception{
Symbol sym = (Symbol) RT.second(form);
Var v = lookupVar(sym, false);
if(v != null)
return new TheVarExpr(v);
throw new Exception("Unable to resolve var: " + sym +
482 CHAPTER 8. JVM/CLOJURE/LANG/

" in this context");

}
}
}

public static class KeywordExpr extends LiteralExpr{

public final Keyword k;

public KeywordExpr(Keyword k){

this.k = k;
}

Object val(){
return k;
}

public Object eval() {

return k;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

objx.emitKeyword(gen, k);
if(context == C.STATEMENT)
gen.pop();

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws ClassNotFoundException{

return Keyword.class;
}
}

public static class ImportExpr implements Expr{

public final String c;
final static Method forNameMethod =
Method.getMethod("Class forName(String)");
final static Method importClassMethod =
Method.getMethod("Class importClass(Class)");
final static Method derefMethod =
Method.getMethod("Object deref()");

public ImportExpr(String c){

this.c = c;
}

public Object eval() throws Exception{

8.24. COMPILER.JAVA 483

Namespace ns = (Namespace) RT.CURRENT_NS.deref();

ns.importClass(RT.classForName(c));
return null;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.getStatic(RT_TYPE,"CURRENT_NS",VAR_TYPE);
gen.invokeVirtual(VAR_TYPE, derefMethod);
gen.checkCast(NS_TYPE);
gen.push(c);
gen.invokeStatic(CLASS_TYPE, forNameMethod);
gen.invokeVirtual(NS_TYPE, importClassMethod);
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass(){

return false;
}

public Class getJavaClass() throws ClassNotFoundException{

throw
new IllegalArgumentException("ImportExpr has no Java class");
}

static class Parser implements IParser{

public Expr parse(C context, Object form) throws Exception{
return new ImportExpr((String) RT.second(form));
}
}
}

public static abstract class LiteralExpr implements Expr{

abstract Object val();

public Object eval(){

return val();
}
}

static interface AssignableExpr{

Object evalAssign(Expr val) throws Exception;

void emitAssign(C context,

ObjExpr objx,
GeneratorAdapter gen,
Expr val);
}

static public interface MaybePrimitiveExpr extends Expr{

484 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean canEmitPrimitive();

public void emitUnboxed(C context,
ObjExpr objx,
GeneratorAdapter gen);
}

static public abstract class HostExpr

implements Expr, MaybePrimitiveExpr{
final static Type BOOLEAN_TYPE = Type.getType(Boolean.class);
final static Type CHAR_TYPE = Type.getType(Character.class);
final static Type INTEGER_TYPE = Type.getType(Integer.class);
final static Type LONG_TYPE = Type.getType(Long.class);
final static Type FLOAT_TYPE = Type.getType(Float.class);
final static Type DOUBLE_TYPE = Type.getType(Double.class);
final static Type SHORT_TYPE = Type.getType(Short.class);
final static Type BYTE_TYPE = Type.getType(Byte.class);
final static Type NUMBER_TYPE = Type.getType(Number.class);

final static Method charValueMethod =

Method.getMethod("char charValue()");
final static Method booleanValueMethod =
Method.getMethod("boolean booleanValue()");

final static Method charValueOfMethod =

Method.getMethod("Character valueOf(char)");
final static Method intValueOfMethod =
Method.getMethod("Integer valueOf(int)");
final static Method longValueOfMethod =
Method.getMethod("Long valueOf(long)");
final static Method floatValueOfMethod =
Method.getMethod("Float valueOf(float)");
final static Method doubleValueOfMethod =
Method.getMethod("Double valueOf(double)");
final static Method shortValueOfMethod =
Method.getMethod("Short valueOf(short)");
final static Method byteValueOfMethod =
Method.getMethod("Byte valueOf(byte)");

final static Method intValueMethod =

Method.getMethod("int intValue()");
final static Method longValueMethod =
Method.getMethod("long longValue()");
final static Method floatValueMethod =
Method.getMethod("float floatValue()");
final static Method doubleValueMethod =
Method.getMethod("double doubleValue()");
final static Method byteValueMethod =
Method.getMethod("byte byteValue()");
final static Method shortValueMethod =
Method.getMethod("short shortValue()");
8.24. COMPILER.JAVA 485

final static Method fromIntMethod =

Method.getMethod("clojure.lang.Num from(int)");
final static Method fromLongMethod =
Method.getMethod("clojure.lang.Num from(long)");
final static Method fromDoubleMethod =
Method.getMethod("clojure.lang.Num from(double)");

//*
public static void emitBoxReturn(ObjExpr objx,
GeneratorAdapter gen,
Class returnType){
if(returnType.isPrimitive())
{
if(returnType == boolean.class)
{
Label falseLabel = gen.newLabel();
Label endLabel = gen.newLabel();
gen.ifZCmp(GeneratorAdapter.EQ, falseLabel);
gen.getStatic(BOOLEAN_OBJECT_TYPE, "TRUE",
BOOLEAN_OBJECT_TYPE);
gen.goTo(endLabel);
gen.mark(falseLabel);
gen.getStatic(BOOLEAN_OBJECT_TYPE, "FALSE",
BOOLEAN_OBJECT_TYPE);
// NIL_EXPR.emit(C.EXPRESSION, fn, gen);
gen.mark(endLabel);
}
else if(returnType == void.class)
{
NIL_EXPR.emit(C.EXPRESSION, objx, gen);
}
else if(returnType == char.class)
{
gen.invokeStatic(CHAR_TYPE, charValueOfMethod);
}
else
{
if(returnType == int.class)
{
gen.visitInsn(I2L);
gen.invokeStatic(NUMBERS_TYPE,
Method.getMethod("Number num(long)"));
}
else if(returnType == float.class)
{
gen.visitInsn(F2D);
gen.invokeStatic(DOUBLE_TYPE,
doubleValueOfMethod);
486 CHAPTER 8. JVM/CLOJURE/LANG/

}
else if(returnType == double.class)
gen.invokeStatic(DOUBLE_TYPE,
doubleValueOfMethod);
else if(returnType == long.class)
gen.invokeStatic(NUMBERS_TYPE,
Method.getMethod("Number num(long)"));
else if(returnType == byte.class)
gen.invokeStatic(BYTE_TYPE,
byteValueOfMethod);
else if(returnType == short.class)
gen.invokeStatic(SHORT_TYPE,
shortValueOfMethod);
}
}
}

//*/
public static void emitUnboxArg(ObjExpr objx,
GeneratorAdapter gen,
Class paramType){
if(paramType.isPrimitive())
{
if(paramType == boolean.class)
{
gen.checkCast(BOOLEAN_TYPE);
gen.invokeVirtual(BOOLEAN_TYPE, booleanValueMethod);
// Label falseLabel = gen.newLabel();
// Label endLabel = gen.newLabel();
// gen.ifNull(falseLabel);
// gen.push(1);
// gen.goTo(endLabel);
// gen.mark(falseLabel);
// gen.push(0);
// gen.mark(endLabel);
}
else if(paramType == char.class)
{
gen.checkCast(CHAR_TYPE);
gen.invokeVirtual(CHAR_TYPE, charValueMethod);
}
else
{
Method m = null;
gen.checkCast(NUMBER_TYPE);
if(RT.booleanCast(UNCHECKED_MATH.deref()))
{
if(paramType == int.class)
m = Method.getMethod(
"int uncheckedIntCast(Object)");
8.24. COMPILER.JAVA 487

else if(paramType == float.class)

m = Method.getMethod(
"float uncheckedFloatCast(Object)");
else if(paramType == double.class)
m = Method.getMethod(
"double uncheckedDoubleCast(Object)");
else if(paramType == long.class)
m = Method.getMethod(
"long uncheckedLongCast(Object)");
else if(paramType == byte.class)
m = Method.getMethod(
"byte uncheckedByteCast(Object)");
else if(paramType == short.class)
m = Method.getMethod(
"short uncheckedShortCast(Object)");
}
else
{
if(paramType == int.class)
m = Method.getMethod("int intCast(Object)");
else if(paramType == float.class)
m = Method.getMethod("float floatCast(Object)");
else if(paramType == double.class)
m = Method.getMethod("double doubleCast(Object)");
else if(paramType == long.class)
m = Method.getMethod("long longCast(Object)");
else if(paramType == byte.class)
m = Method.getMethod("byte byteCast(Object)");
else if(paramType == short.class)
m = Method.getMethod("short shortCast(Object)");
}
gen.invokeStatic(RT_TYPE, m);
}
}
else
{
gen.checkCast(Type.getType(paramType));
}
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
ISeq form = (ISeq) frm;
//(. x fieldname-sym) or
//(. x 0-ary-method)
// (. x methodname-sym args+)
// (. x (methodname-sym args?))
if(RT.length(form) < 3)
throw new IllegalArgumentException(
"Malformed member expression, expecting (. target member ...)");
488 CHAPTER 8. JVM/CLOJURE/LANG/

//determine static or instance

//static target must be symbol, either
// fully.qualified.Classname or Classname that has
// been imported
int line = (Integer) LINE.deref();
String source = (String) SOURCE.deref();
Class c = maybeClass(RT.second(form), false);
//at this point c will be non-null if static
Expr instance = null;
if(c == null)
instance =
analyze(context == C.EVAL ? context
: C.EXPRESSION, RT.second(form));
boolean maybeField = RT.length(form) == 3 &&
(RT.third(form) instanceof Symbol ||
RT.third(form) instanceof Keyword);
if(maybeField && !(RT.third(form) instanceof Keyword))
{
Symbol sym = (Symbol) RT.third(form);
if(c != null)
maybeField =
Reflector.getMethods(c, 0, munge(sym.name), true)
.size() == 0;
else if(instance != null &&
instance.hasJavaClass() &&
instance.getJavaClass() != null)
maybeField =
Reflector.getMethods(instance.getJavaClass(), 0,
munge(sym.name), false).size() == 0;
}
if(maybeField) //field
{
Symbol sym = (RT.third(form) instanceof Keyword)?
((Keyword)RT.third(form)).sym
:(Symbol) RT.third(form);
Symbol tag = tagOf(form);
if(c != null) {
return
new StaticFieldExpr(line, c, munge(sym.name), tag);
} else
return
new InstanceFieldExpr(line, instance,
munge(sym.name), tag);
}
else
{
ISeq call = (ISeq)
((RT.third(form) instanceof ISeq)
? RT.third(form)
: RT.next(RT.next(form)));
8.24. COMPILER.JAVA 489

if(!(RT.first(call) instanceof Symbol))

throw new IllegalArgumentException(
"Malformed member expression");
Symbol sym = (Symbol) RT.first(call);
Symbol tag = tagOf(form);
PersistentVector args = PersistentVector.EMPTY;
for(ISeq s = RT.next(call); s != null; s = s.next())
args =
args.cons(analyze(context == C.EVAL
? context
: C.EXPRESSION, s.first()));
if(c != null)
return
new StaticMethodExpr(source, line, tag, c,
munge(sym.name), args);
else
return
new InstanceMethodExpr(source, line, tag,
instance,
munge(sym.name), args);
}
}
}

private static Class maybeClass(Object form, boolean stringOk)

throws Exception{
if(form instanceof Class)
return (Class) form;
Class c = null;
if(form instanceof Symbol)
{
Symbol sym = (Symbol) form;
if(sym.ns == null) //if ns-qualified can’t be classname
{
if(Util.equals(sym,COMPILE_STUB_SYM.get()))
return (Class) COMPILE_STUB_CLASS.get();
if(sym.name.indexOf(’.’) > 0 ||
sym.name.charAt(0) == ’[’)
c = RT.classForName(sym.name);
else
{
Object o = currentNS().getMapping(sym);
if(o instanceof Class)
c = (Class) o;
else
{
try{
c = RT.classForName(sym.name);
}
catch(Exception e){
490 CHAPTER 8. JVM/CLOJURE/LANG/

//aargh
}
}
}
}
}
else if(stringOk && form instanceof String)
c = RT.classForName((String) form);
return c;
}

/*
private static String maybeClassName(Object form, boolean stringOk){
String className = null;
if(form instanceof Symbol)
{
Symbol sym = (Symbol) form;
if(sym.ns == null) //if ns-qualified can’t be classname
{
if(sym.name.indexOf(’.’) > 0 ||
sym.name.charAt(0) == ’[’)
className = sym.name;
else
{
IPersistentMap imports =
(IPersistentMap)
((Var) RT.NS_IMPORTS.get()).get();
className = (String) imports.valAt(sym);
}
}
}
else if(stringOk && form instanceof String)
className = (String) form;
return className;
}
*/
static Class tagToClass(Object tag) throws Exception{
Class c = maybeClass(tag, true);
if(tag instanceof Symbol)
{
Symbol sym = (Symbol) tag;
if(sym.ns == null) //if ns-qualified can’t be classname
{
if(sym.name.equals("objects"))
c = Object[].class;
else if(sym.name.equals("ints"))
c = int[].class;
else if(sym.name.equals("longs"))
c = long[].class;
else if(sym.name.equals("floats"))
8.24. COMPILER.JAVA 491

c = float[].class;
else if(sym.name.equals("doubles"))
c = double[].class;
else if(sym.name.equals("chars"))
c = char[].class;
else if(sym.name.equals("shorts"))
c = short[].class;
else if(sym.name.equals("bytes"))
c = byte[].class;
else if(sym.name.equals("booleans"))
c = boolean[].class;
}
}
if(c != null)
return c;
throw new IllegalArgumentException(
"Unable to resolve classname: " + tag);
}
}

static abstract class FieldExpr extends HostExpr{

}

static class InstanceFieldExpr extends FieldExpr

implements AssignableExpr{
public final Expr target;
public final Class targetClass;
public final java.lang.reflect.Field field;
public final String fieldName;
public final int line;
public final Symbol tag;
final static Method invokeNoArgInstanceMember =
Method.getMethod(
"Object invokeNoArgInstanceMember(Object,String)");
final static Method setInstanceFieldMethod =
Method.getMethod(
"Object setInstanceField(Object,String,Object)");

public InstanceFieldExpr(int line,

Expr target,
String fieldName,
Symbol tag) throws Exception{
this.target = target;
this.targetClass =
target.hasJavaClass() ? target.getJavaClass() : null;
this.field =
targetClass != null
? Reflector.getField(targetClass, fieldName, false)
: null;
492 CHAPTER 8. JVM/CLOJURE/LANG/

this.fieldName = fieldName;
this.line = line;
this.tag = tag;
if(field == null &&
RT.booleanCast(RT.WARN_ON_REFLECTION.deref()))
{
RT.errPrintWriter()
.format("Reflection warning, %s:%d - "+
"reference to field %s can’t be resolved.\n",
SOURCE_PATH.deref(), line, fieldName);
}
}

public Object eval() throws Exception{

return
Reflector.invokeNoArgInstanceMember(target.eval(), fieldName);
}

public boolean canEmitPrimitive(){

return targetClass != null && field != null &&
Util.isPrimitive(field.getType());
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
gen.visitLineNumber(line, gen.mark());
if(targetClass != null && field != null)
{
target.emit(C.EXPRESSION, objx, gen);
gen.checkCast(getType(targetClass));
gen.getField(getType(targetClass), fieldName,
Type.getType(field.getType()));
}
else
throw new UnsupportedOperationException(
"Unboxed emit of unknown member");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.visitLineNumber(line, gen.mark());
if(targetClass != null && field != null)
{
target.emit(C.EXPRESSION, objx, gen);
gen.checkCast(getType(targetClass));
gen.getField(getType(targetClass), fieldName,
Type.getType(field.getType()));
//if(context != C.STATEMENT)
HostExpr.emitBoxReturn(objx, gen, field.getType());
if(context == C.STATEMENT)
8.24. COMPILER.JAVA 493

{
gen.pop();
}
}
else
{
target.emit(C.EXPRESSION, objx, gen);
gen.push(fieldName);
gen.invokeStatic(REFLECTOR_TYPE, invokeNoArgInstanceMember);
if(context == C.STATEMENT)
gen.pop();
}
}

public boolean hasJavaClass() throws Exception{

return field != null || tag != null;
}

public Class getJavaClass() throws Exception{

return tag != null ? HostExpr.tagToClass(tag) : field.getType();
}

public Object evalAssign(Expr val) throws Exception{

return
Reflector.setInstanceField(target.eval(),
fieldName,
val.eval());
}

public void emitAssign(C context,

ObjExpr objx,
GeneratorAdapter gen,
Expr val){
gen.visitLineNumber(line, gen.mark());
if(targetClass != null && field != null)
{
target.emit(C.EXPRESSION, objx, gen);
gen.checkCast(Type.getType(targetClass));
val.emit(C.EXPRESSION, objx, gen);
gen.dupX1();
HostExpr.emitUnboxArg(objx, gen, field.getType());
gen.putField(Type.getType(targetClass), fieldName,
Type.getType(field.getType()));
}
else
{
target.emit(C.EXPRESSION, objx, gen);
gen.push(fieldName);
val.emit(C.EXPRESSION, objx, gen);
gen.invokeStatic(REFLECTOR_TYPE, setInstanceFieldMethod);
494 CHAPTER 8. JVM/CLOJURE/LANG/

}
if(context == C.STATEMENT)
gen.pop();
}
}

static class StaticFieldExpr extends FieldExpr implements AssignableExpr{

//final String className;
public final String fieldName;
public final Class c;
public final java.lang.reflect.Field field;
public final Symbol tag;
// final static Method getStaticFieldMethod =
// Method.getMethod("Object getStaticField(String,String)");
// final static Method setStaticFieldMethod =
// Method.getMethod("Object setStaticField(String,String,Object)");
final int line;

public StaticFieldExpr(int line,

Class c,
String fieldName,
Symbol tag) throws Exception{
//this.className = className;
this.fieldName = fieldName;
this.line = line;
//c = Class.forName(className);
this.c = c;
field = c.getField(fieldName);
this.tag = tag;
}

public Object eval() throws Exception{

return Reflector.getStaticField(c, fieldName);
}

public boolean canEmitPrimitive(){

return Util.isPrimitive(field.getType());
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
gen.visitLineNumber(line, gen.mark());
gen.getStatic(Type.getType(c), fieldName,
Type.getType(field.getType()));
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.visitLineNumber(line, gen.mark());
8.24. COMPILER.JAVA 495

gen.getStatic(Type.getType(c), fieldName,
Type.getType(field.getType()));
//if(context != C.STATEMENT)
HostExpr.emitBoxReturn(objx, gen, field.getType());
if(context == C.STATEMENT)
{
gen.pop();
}
// gen.push(className);
// gen.push(fieldName);
// gen.invokeStatic(REFLECTOR_TYPE, getStaticFieldMethod);
}

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws Exception{

//Class c = Class.forName(className);
//java.lang.reflect.Field field = c.getField(fieldName);
return tag != null ? HostExpr.tagToClass(tag) : field.getType();
}

public Object evalAssign(Expr val) throws Exception{

return Reflector.setStaticField(c, fieldName, val.eval());
}

public void emitAssign(C context, ObjExpr objx, GeneratorAdapter gen,

Expr val){
gen.visitLineNumber(line, gen.mark());
val.emit(C.EXPRESSION, objx, gen);
gen.dup();
HostExpr.emitUnboxArg(objx, gen, field.getType());
gen.putStatic(Type.getType(c),
fieldName, Type.getType(field.getType()));
if(context == C.STATEMENT)
gen.pop();
}

static Class maybePrimitiveType(Expr e){

try
{
if(e instanceof MaybePrimitiveExpr &&
e.hasJavaClass() &&
((MaybePrimitiveExpr)e).canEmitPrimitive())
{
Class c = e.getJavaClass();
496 CHAPTER 8. JVM/CLOJURE/LANG/

if(Util.isPrimitive(c))
return c;
}
}
catch(Exception ex)
{
throw new RuntimeException(ex);
}
return null;
}

static abstract class MethodExpr extends HostExpr{

static void emitArgsAsArray(IPersistentVector args,
ObjExpr objx,
GeneratorAdapter gen){
gen.push(args.count());
gen.newArray(OBJECT_TYPE);
for(int i = 0; i < args.count(); i++)
{
gen.dup();
gen.push(i);
((Expr) args.nth(i)).emit(C.EXPRESSION, objx, gen);
gen.arrayStore(OBJECT_TYPE);
}
}

public static void emitTypedArgs(ObjExpr objx,

GeneratorAdapter gen,
Class[] parameterTypes,
IPersistentVector args){
for(int i = 0; i < parameterTypes.length; i++)
{
Expr e = (Expr) args.nth(i);
try
{
final Class primc = maybePrimitiveType(e);
if(primc == parameterTypes[i])
{
final MaybePrimitiveExpr pe =
(MaybePrimitiveExpr) e;
pe.emitUnboxed(C.EXPRESSION, objx, gen);
}
else if(primc == int.class &&
parameterTypes[i] == long.class)
{
final MaybePrimitiveExpr pe =
(MaybePrimitiveExpr) e;
pe.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitInsn(I2L);
}
8.24. COMPILER.JAVA 497

else if(primc == long.class &&

parameterTypes[i] == int.class)
{
final MaybePrimitiveExpr pe =
(MaybePrimitiveExpr) e;
pe.emitUnboxed(C.EXPRESSION, objx, gen);
if(RT.booleanCast(UNCHECKED_MATH.deref()))
gen.invokeStatic(RT_TYPE,
Method.getMethod("int uncheckedIntCast(long)"));
else
gen.invokeStatic(RT_TYPE,
Method.getMethod("int intCast(long)"));
}
else if(primc == float.class &&
parameterTypes[i] == double.class)
{
final MaybePrimitiveExpr pe = (MaybePrimitiveExpr) e;
pe.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitInsn(F2D);
}
else if(primc == double.class &&
parameterTypes[i] == float.class)
{
final MaybePrimitiveExpr pe = (MaybePrimitiveExpr) e;
pe.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitInsn(D2F);
}
else
{
e.emit(C.EXPRESSION, objx, gen);
HostExpr.emitUnboxArg(objx, gen, parameterTypes[i]);
}
}
catch(Exception e1)
{
e1.printStackTrace(RT.errPrintWriter());
}

}
}
}

static class InstanceMethodExpr extends MethodExpr{

public final Expr target;
public final String methodName;
public final IPersistentVector args;
public final String source;
public final int line;
public final Symbol tag;
public final java.lang.reflect.Method method;
498 CHAPTER 8. JVM/CLOJURE/LANG/

final static Method invokeInstanceMethodMethod =

Method.getMethod(
"Object invokeInstanceMethod(Object,String,Object[])");

public InstanceMethodExpr(String source,

int line,
Symbol tag,
Expr target,
String methodName,
IPersistentVector args)
throws Exception{
this.source = source;
this.line = line;
this.args = args;
this.methodName = methodName;
this.target = target;
this.tag = tag;
if(target.hasJavaClass() && target.getJavaClass() != null)
{
List methods =
Reflector.getMethods(target.getJavaClass(),
args.count(), methodName, false);
if(methods.isEmpty())
method = null;
//throw new IllegalArgumentException(
// "No matching method found");
else
{
int methodidx = 0;
if(methods.size() > 1)
{
ArrayList<Class[]> params = new ArrayList();
ArrayList<Class> rets = new ArrayList();
for(int i = 0; i < methods.size(); i++)
{
java.lang.reflect.Method m =
(java.lang.reflect.Method) methods.get(i);
params.add(m.getParameterTypes());
rets.add(m.getReturnType());
}
methodidx =
getMatchingParams(methodName, params, args, rets);
}
java.lang.reflect.Method m =
(java.lang.reflect.Method)
(methodidx >= 0
? methods.get(methodidx)
: null);
8.24. COMPILER.JAVA 499

if(m != null &&

!Modifier.isPublic(m.getDeclaringClass()
.getModifiers()))
{
//public method of non-public class, try to find
// it in hierarchy
m = Reflector.getAsMethodOfPublicBase(
m.getDeclaringClass(), m);
}
method = m;
}
}
else
method = null;

if(method == null &&

RT.booleanCast(RT.WARN_ON_REFLECTION.deref()))
{
RT.errPrintWriter()
.format(
"Reflection warning, %s:%d - call to %s can’t be resolved.\n",
SOURCE_PATH.deref(), line, methodName);
}
}

public Object eval() throws Exception{

try
{
Object targetval = target.eval();
Object[] argvals = new Object[args.count()];
for(int i = 0; i < args.count(); i++)
argvals[i] = ((Expr) args.nth(i)).eval();
if(method != null)
{
LinkedList ms = new LinkedList();
ms.add(method);
return Reflector.invokeMatchingMethod(methodName, ms,
targetval,
argvals);
}
return Reflector.invokeInstanceMethod(targetval,
methodName,
argvals);
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(source, line, e);
else
throw (CompilerException) e;
500 CHAPTER 8. JVM/CLOJURE/LANG/

}
}

public boolean canEmitPrimitive(){

return method != null &&
Util.isPrimitive(method.getReturnType());
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
gen.visitLineNumber(line, gen.mark());
if(method != null)
{
Type type = Type.getType(method.getDeclaringClass());
target.emit(C.EXPRESSION, objx, gen);
//if(!method.getDeclaringClass().isInterface())
gen.checkCast(type);
MethodExpr.emitTypedArgs(objx, gen,
method.getParameterTypes(), args);
if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
Method m = new Method(methodName,
Type.getReturnType(method),
Type.getArgumentTypes(method));
if(method.getDeclaringClass().isInterface())
gen.invokeInterface(type, m);
else
gen.invokeVirtual(type, m);
}
else
throw new UnsupportedOperationException(
"Unboxed emit of unknown member");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.visitLineNumber(line, gen.mark());
if(method != null)
{
Type type = Type.getType(method.getDeclaringClass());
target.emit(C.EXPRESSION, objx, gen);
//if(!method.getDeclaringClass().isInterface())
gen.checkCast(type);
MethodExpr.emitTypedArgs(objx, gen,
method.getParameterTypes(), args);
if(context == C.RETURN)
{
8.24. COMPILER.JAVA 501

ObjMethod method = (ObjMethod) METHOD.deref();

method.emitClearLocals(gen);
}
Method m = new Method(methodName,
Type.getReturnType(method),
Type.getArgumentTypes(method));
if(method.getDeclaringClass().isInterface())
gen.invokeInterface(type, m);
else
gen.invokeVirtual(type, m);
//if(context != C.STATEMENT ||
method.getReturnType() == Void.TYPE)
HostExpr.emitBoxReturn(objx, gen, method.getReturnType());
}
else
{
target.emit(C.EXPRESSION, objx, gen);
gen.push(methodName);
emitArgsAsArray(args, objx, gen);
if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
gen.invokeStatic(REFLECTOR_TYPE, invokeInstanceMethodMethod);
}
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass(){

return method != null || tag != null;
}

public Class getJavaClass() throws Exception{

return tag != null
? HostExpr.tagToClass(tag)
: method.getReturnType();
}
}

static class StaticMethodExpr extends MethodExpr{

//final String className;
public final Class c;
public final String methodName;
public final IPersistentVector args;
public final String source;
public final int line;
public final java.lang.reflect.Method method;
502 CHAPTER 8. JVM/CLOJURE/LANG/

public final Symbol tag;

final static Method forNameMethod =
Method.getMethod("Class forName(String)");
final static Method invokeStaticMethodMethod =
Method.getMethod(
"Object invokeStaticMethod(Class,String,Object[])");

public StaticMethodExpr(String source, int line, Symbol tag,

Class c, String methodName,
IPersistentVector args)
throws Exception{
this.c = c;
this.methodName = methodName;
this.args = args;
this.source = source;
this.line = line;
this.tag = tag;

List methods =
Reflector.getMethods(c, args.count(), methodName, true);
if(methods.isEmpty())
throw new IllegalArgumentException(
"No matching method: " + methodName);

int methodidx = 0;
if(methods.size() > 1)
{
ArrayList<Class[]> params = new ArrayList();
ArrayList<Class> rets = new ArrayList();
for(int i = 0; i < methods.size(); i++)
{
java.lang.reflect.Method m =
(java.lang.reflect.Method) methods.get(i);
params.add(m.getParameterTypes());
rets.add(m.getReturnType());
}
methodidx =
getMatchingParams(methodName, params, args, rets);
}
method = (java.lang.reflect.Method)
(methodidx >= 0 ? methods.get(methodidx) : null);
if(method == null &&
RT.booleanCast(RT.WARN_ON_REFLECTION.deref()))
{
RT.errPrintWriter()
.format(
"Reflection warning, %s:%d - call to %s can’t be resolved.\n",
SOURCE_PATH.deref(), line, methodName);
}
8.24. COMPILER.JAVA 503

public Object eval() throws Exception{

try
{
Object[] argvals = new Object[args.count()];
for(int i = 0; i < args.count(); i++)
argvals[i] = ((Expr) args.nth(i)).eval();
if(method != null)
{
LinkedList ms = new LinkedList();
ms.add(method);
return Reflector.invokeMatchingMethod(methodName, ms,
null, argvals);
}
return Reflector.invokeStaticMethod(c, methodName, argvals);
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(source, line, e);
else
throw (CompilerException) e;
}
}

public boolean canEmitPrimitive(){

return method != null &&
Util.isPrimitive(method.getReturnType());
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
gen.visitLineNumber(line, gen.mark());
if(method != null)
{
MethodExpr.emitTypedArgs(objx, gen,
method.getParameterTypes(),
args);
//Type type =
// Type.getObjectType(className.replace(’.’, ’/’));
if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
Type type = Type.getType(c);
Method m = new Method(methodName,
Type.getReturnType(method),
504 CHAPTER 8. JVM/CLOJURE/LANG/

Type.getArgumentTypes(method));
gen.invokeStatic(type, m);
}
else
throw new UnsupportedOperationException(
"Unboxed emit of unknown member");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.visitLineNumber(line, gen.mark());
if(method != null)
{
MethodExpr.emitTypedArgs(objx, gen,
method.getParameterTypes(),
args);
//Type type =
// Type.getObjectType(className.replace(’.’, ’/’));
if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
Type type = Type.getType(c);
Method m = new Method(methodName,
Type.getReturnType(method),
Type.getArgumentTypes(method));
gen.invokeStatic(type, m);
//if(context != C.STATEMENT ||
// method.getReturnType() == Void.TYPE)
Class retClass = method.getReturnType();
if(context == C.STATEMENT)
{
if(retClass == long.class || retClass == double.class)
gen.pop2();
else if(retClass != void.class)
gen.pop();
}
else
{
HostExpr.emitBoxReturn(objx, gen,
method.getReturnType());
}
}
else
{
gen.push(c.getName());
gen.invokeStatic(CLASS_TYPE, forNameMethod);
gen.push(methodName);
emitArgsAsArray(args, objx, gen);
if(context == C.RETURN)
8.24. COMPILER.JAVA 505

{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
gen.invokeStatic(REFLECTOR_TYPE, invokeStaticMethodMethod);
if(context == C.STATEMENT)
gen.pop();
}
}

public boolean hasJavaClass(){

return method != null || tag != null;
}

public Class getJavaClass() throws Exception{

return tag != null
? HostExpr.tagToClass(tag)
: method.getReturnType();
}
}

static class UnresolvedVarExpr implements Expr{

public final Symbol symbol;

public UnresolvedVarExpr(Symbol symbol){

this.symbol = symbol;
}

public boolean hasJavaClass(){

return false;
}

public Class getJavaClass() throws Exception{

throw new IllegalArgumentException(
"UnresolvedVarExpr has no Java class");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

}

public Object eval() throws Exception{

throw new IllegalArgumentException(
"UnresolvedVarExpr cannot be evalled");
}
}

static class NumberExpr extends LiteralExpr

implements MaybePrimitiveExpr{
final Number n;
public final int id;
506 CHAPTER 8. JVM/CLOJURE/LANG/

public NumberExpr(Number n){

this.n = n;
this.id = registerConstant(n);
}

Object val(){
return n;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

if(context != C.STATEMENT)
{
objx.emitConstant(gen, id);
// emitUnboxed(context,objx,gen);
// HostExpr.emitBoxReturn(objx,gen,getJavaClass());
}
}

public boolean hasJavaClass() throws Exception{

return true;
}

public Class getJavaClass(){

if(n instanceof Integer)
return long.class;
else if(n instanceof Double)
return double.class;
else if(n instanceof Long)
return long.class;
else
throw new IllegalStateException(
"Unsupported Number type: " + n.getClass().getName());
}

public boolean canEmitPrimitive(){

return true;
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
if(n instanceof Integer)
gen.push(n.longValue());
else if(n instanceof Double)
gen.push(n.doubleValue());
else if(n instanceof Long)
gen.push(n.longValue());
}
8.24. COMPILER.JAVA 507

static public Expr parse(Number form){

if(form instanceof Integer
|| form instanceof Double
|| form instanceof Long)
return new NumberExpr(form);
else
return new ConstantExpr(form);
}
}

static class ConstantExpr extends LiteralExpr{

//stuff quoted vals in classloader at compile time, pull out
//at runtime this won’t work for static compilation...
public final Object v;
public final int id;

public ConstantExpr(Object v){

this.v = v;
this.id = registerConstant(v);
// this.id = RT.nextID();
// DynamicClassLoader loader = (DynamicClassLoader) LOADER.get();
// loader.registerQuotedVal(id, v);
}

Object val(){
return v;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

objx.emitConstant(gen, id);
if(context == C.STATEMENT)
{
gen.pop();
// gen.loadThis();
// gen.invokeVirtual(OBJECT_TYPE, getClassMethod);
// gen.invokeVirtual(CLASS_TYPE, getClassLoaderMethod);
// gen.checkCast(DYNAMIC_CLASSLOADER_TYPE);
// gen.push(id);
// gen.invokeVirtual(DYNAMIC_CLASSLOADER_TYPE,
// getQuotedValMethod);
}
}

public boolean hasJavaClass(){

return Modifier.isPublic(v.getClass().getModifiers());
//return false;
}

public Class getJavaClass() throws Exception{

return v.getClass();
508 CHAPTER 8. JVM/CLOJURE/LANG/

//throw new IllegalArgumentException("Has no Java class");

}

static class Parser implements IParser{

public Expr parse(C context, Object form){
Object v = RT.second(form);

if(v == null)
return NIL_EXPR;
// Class fclass = v.getClass();
// if(fclass == Keyword.class)
// return registerKeyword((Keyword) v);
// else if(v instanceof Num)
// return new NumExpr((Num) v);
// else if(fclass == String.class)
// return new StringExpr((String) v);
// else if(fclass == Character.class)
// return new CharExpr((Character) v);
// else if(v instanceof IPersistentCollection &&
// ((IPersistentCollection) v).count() == 0)
// return new EmptyExpr(v);
else
return new ConstantExpr(v);
}
}
}

static class NilExpr extends LiteralExpr{

Object val(){
return null;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.visitInsn(Opcodes.ACONST_NULL);
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws Exception{

return null;
}
}

final static NilExpr NIL_EXPR = new NilExpr();

static class BooleanExpr extends LiteralExpr{

8.24. COMPILER.JAVA 509

public final boolean val;

public BooleanExpr(boolean val){

this.val = val;
}

Object val(){
return val ? RT.T : RT.F;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

if(val)
gen.getStatic(BOOLEAN_OBJECT_TYPE, "TRUE",
BOOLEAN_OBJECT_TYPE);
else
gen.getStatic(BOOLEAN_OBJECT_TYPE, "FALSE",
BOOLEAN_OBJECT_TYPE);
if(context == C.STATEMENT)
{
gen.pop();
}
}

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws Exception{

return Boolean.class;
}
}

final static BooleanExpr TRUE_EXPR = new BooleanExpr(true);

final static BooleanExpr FALSE_EXPR = new BooleanExpr(false);

static class StringExpr extends LiteralExpr{

public final String str;

public StringExpr(String str){

this.str = str;
}

Object val(){
return str;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

if(context != C.STATEMENT)
gen.push(str);
510 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws Exception{

return String.class;
}
}

static class MonitorEnterExpr extends UntypedExpr{

final Expr target;

public MonitorEnterExpr(Expr target){

this.target = target;
}

public Object eval() throws Exception{

throw
new UnsupportedOperationException("Can’t eval monitor-enter");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

target.emit(C.EXPRESSION, objx, gen);
gen.monitorEnter();
NIL_EXPR.emit(context, objx, gen);
}

static class Parser implements IParser{

public Expr parse(C context, Object form) throws Exception{
return
new MonitorEnterExpr(analyze(C.EXPRESSION, RT.second(form)));
}
}
}

static class MonitorExitExpr extends UntypedExpr{

final Expr target;

public MonitorExitExpr(Expr target){

this.target = target;
}

public Object eval() throws Exception{

throw
new UnsupportedOperationException("Can’t eval monitor-exit");
}
8.24. COMPILER.JAVA 511

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

target.emit(C.EXPRESSION, objx, gen);
gen.monitorExit();
NIL_EXPR.emit(context, objx, gen);
}

static class Parser implements IParser{

public Expr parse(C context, Object form) throws Exception{
return
new MonitorExitExpr(analyze(C.EXPRESSION, RT.second(form)));
}
}

public static class TryExpr implements Expr{

public final Expr tryExpr;
public final Expr finallyExpr;
public final PersistentVector catchExprs;
public final int retLocal;
public final int finallyLocal;

public static class CatchClause{

//final String className;
public final Class c;
public final LocalBinding lb;
public final Expr handler;
Label label;
Label endLabel;

public CatchClause(Class c, LocalBinding lb, Expr handler){

this.c = c;
this.lb = lb;
this.handler = handler;
}
}

public TryExpr(Expr tryExpr,

PersistentVector catchExprs,
Expr finallyExpr,
int retLocal,
int finallyLocal){
this.tryExpr = tryExpr;
this.catchExprs = catchExprs;
this.finallyExpr = finallyExpr;
this.retLocal = retLocal;
this.finallyLocal = finallyLocal;
}
512 CHAPTER 8. JVM/CLOJURE/LANG/

public Object eval() throws Exception{

throw new UnsupportedOperationException("Can’t eval try");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

Label startTry = gen.newLabel();
Label endTry = gen.newLabel();
Label end = gen.newLabel();
Label ret = gen.newLabel();
Label finallyLabel = gen.newLabel();
for(int i = 0; i < catchExprs.count(); i++)
{
CatchClause clause = (CatchClause) catchExprs.nth(i);
clause.label = gen.newLabel();
clause.endLabel = gen.newLabel();
}

gen.mark(startTry);
tryExpr.emit(context, objx, gen);
if(context != C.STATEMENT)
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ISTORE),
retLocal);
gen.mark(endTry);
if(finallyExpr != null)
finallyExpr.emit(C.STATEMENT, objx, gen);
gen.goTo(ret);

for(int i = 0; i < catchExprs.count(); i++)

{
CatchClause clause = (CatchClause) catchExprs.nth(i);
gen.mark(clause.label);
//exception should be on stack
//put in clause local
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ISTORE),
clause.lb.idx);
clause.handler.emit(context, objx, gen);
if(context != C.STATEMENT)
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ISTORE),
retLocal);
gen.mark(clause.endLabel);

if(finallyExpr != null)
finallyExpr.emit(C.STATEMENT, objx, gen);
gen.goTo(ret);
}
if(finallyExpr != null)
{
gen.mark(finallyLabel);
//exception should be on stack
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ISTORE),
8.24. COMPILER.JAVA 513

finallyLocal);
finallyExpr.emit(C.STATEMENT, objx, gen);
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ILOAD),
finallyLocal);
gen.throwException();
}
gen.mark(ret);
if(context != C.STATEMENT)
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ILOAD),
retLocal);
gen.mark(end);
for(int i = 0; i < catchExprs.count(); i++)
{
CatchClause clause = (CatchClause) catchExprs.nth(i);
gen.visitTryCatchBlock(startTry, endTry, clause.label,
clause.c.getName()
.replace(’.’, ’/’));
}
if(finallyExpr != null)
{
gen.visitTryCatchBlock(startTry, endTry,
finallyLabel, null);
for(int i = 0; i < catchExprs.count(); i++)
{
CatchClause clause = (CatchClause) catchExprs.nth(i);
gen.visitTryCatchBlock(clause.label,
clause.endLabel,
finallyLabel, null);
}
}
for(int i = 0; i < catchExprs.count(); i++)
{
CatchClause clause = (CatchClause) catchExprs.nth(i);
gen.visitLocalVariable(clause.lb.name,
"Ljava/lang/Object;", null,
clause.label, clause.endLabel,
clause.lb.idx);
}
}

public boolean hasJavaClass() throws Exception{

return tryExpr.hasJavaClass();
}

public Class getJavaClass() throws Exception{

return tryExpr.getJavaClass();
}

static class Parser implements IParser{

514 CHAPTER 8. JVM/CLOJURE/LANG/

public Expr parse(C context, Object frm) throws Exception{

ISeq form = (ISeq) frm;
// if(context == C.EVAL || context == C.EXPRESSION)
if(context != C.RETURN)
return analyze(context,
RT.list(
RT.list(FN,
PersistentVector.EMPTY, form)));

//(try try-expr* catch-expr* finally-expr?)

//catch-expr: (catch class sym expr*)
//finally-expr: (finally expr*)

PersistentVector body = PersistentVector.EMPTY;

PersistentVector catches = PersistentVector.EMPTY;
Expr bodyExpr = null;
Expr finallyExpr = null;
boolean caught = false;

int retLocal = getAndIncLocalNum();

int finallyLocal = getAndIncLocalNum();
for(ISeq fs = form.next(); fs != null; fs = fs.next())
{
Object f = fs.first();
Object op =
(f instanceof ISeq) ? ((ISeq) f).first() : null;
if(!Util.equals(op, CATCH) &&
!Util.equals(op, FINALLY))
{
if(caught)
throw new Exception(
"Only catch or finally clause can follow catch in try expression");
body = body.cons(f);
}
else
{
if(bodyExpr == null)
try {
Var.pushThreadBindings(RT.map(NO_RECUR, true));
bodyExpr =
(new BodyExpr.Parser())
.parse(context, RT.seq(body));
} finally {
Var.popThreadBindings();
}
if(Util.equals(op, CATCH))
{
Class c =
HostExpr.maybeClass(RT.second(f), false);
if(c == null)
8.24. COMPILER.JAVA 515

throw new IllegalArgumentException(

"Unable to resolve classname: " +
RT.second(f));
if(!(RT.third(f) instanceof Symbol))
throw new IllegalArgumentException(
"Bad binding form, expected symbol, got: "
+ RT.third(f));
Symbol sym = (Symbol) RT.third(f);
if(sym.getNamespace() != null)
throw new Exception(
"Can’t bind qualified name:" + sym);

IPersistentMap dynamicBindings =
RT.map(LOCAL_ENV, LOCAL_ENV.deref(),
NEXT_LOCAL_NUM, NEXT_LOCAL_NUM.deref(),
IN_CATCH_FINALLY, RT.T);
try
{
Var.pushThreadBindings(dynamicBindings);
LocalBinding lb =
registerLocal(sym,
(Symbol)
(RT.second(f) instanceof Symbol
? RT.second(f)
: null),
null,false);
Expr handler =
(new BodyExpr.Parser())
.parse(context,
RT.next(RT.next(RT.next(f))));
catches =
catches.cons(
new CatchClause(c, lb, handler));
}
finally
{
Var.popThreadBindings();
}
caught = true;
}
else //finally
{
if(fs.next() != null)
throw new Exception(
"finally clause must be last in try expression");
try
{
Var.pushThreadBindings(
RT.map(IN_CATCH_FINALLY, RT.T));
finallyExpr =
516 CHAPTER 8. JVM/CLOJURE/LANG/

(new BodyExpr.Parser())
.parse(C.STATEMENT, RT.next(f));
}
finally
{
Var.popThreadBindings();
}
}
}
}
if(bodyExpr == null) {
try
{
Var.pushThreadBindings(
RT.map(NO_RECUR, true));
bodyExpr =
(new BodyExpr.Parser())
.parse(context, RT.seq(body));
}
finally
{
Var.popThreadBindings();
}
}

return new TryExpr(bodyExpr, catches, finallyExpr, retLocal,

finallyLocal);
}
}
}

//static class TryFinallyExpr implements Expr{

// final Expr tryExpr;
// final Expr finallyExpr;
//
//
// public TryFinallyExpr(Expr tryExpr, Expr finallyExpr){
// this.tryExpr = tryExpr;
// this.finallyExpr = finallyExpr;
// }
//
// public Object eval() throws Exception{
// throw new UnsupportedOperationException("Can’t eval try");
// }
//
// public void emit(C context, FnExpr fn, GeneratorAdapter gen){
// Label startTry = gen.newLabel();
// Label endTry = gen.newLabel();
// Label end = gen.newLabel();
// Label finallyLabel = gen.newLabel();
8.24. COMPILER.JAVA 517

// gen.visitTryCatchBlock(startTry, endTry, finallyLabel, null);

// gen.mark(startTry);
// tryExpr.emit(context, fn, gen);
// gen.mark(endTry);
// finallyExpr.emit(C.STATEMENT, fn, gen);
// gen.goTo(end);
// gen.mark(finallyLabel);
// //exception should be on stack
// finallyExpr.emit(C.STATEMENT, fn, gen);
// gen.throwException();
// gen.mark(end);
// }
//
// public boolean hasJavaClass() throws Exception{
// return tryExpr.hasJavaClass();
// }
//
// public Class getJavaClass() throws Exception{
// return tryExpr.getJavaClass();
// }
//
// static class Parser implements IParser{
// public Expr parse(C context, Object frm) throws Exception{
// ISeq form = (ISeq) frm;
// //(try-finally try-expr finally-expr)
// if(form.count() != 3)
// throw new IllegalArgumentException(
// "Wrong number of arguments, expecting: "+
// "(try-finally try-expr finally-expr) ");
//
// if(context == C.EVAL || context == C.EXPRESSION)
// return analyze(context,
// RT.list(
// RT.list(FN,
// PersistentVector.EMPTY,
// form)));
//
// return
// new TryFinallyExpr(analyze(context, RT.second(form)),
// analyze(C.STATEMENT, RT.third(form)));
// }
// }
//}

static class ThrowExpr extends UntypedExpr{

public final Expr excExpr;

public ThrowExpr(Expr excExpr){

this.excExpr = excExpr;
}
518 CHAPTER 8. JVM/CLOJURE/LANG/

public Object eval() throws Exception{

throw new Exception("Can’t eval throw");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

excExpr.emit(C.EXPRESSION, objx, gen);
gen.checkCast(THROWABLE_TYPE);
gen.throwException();
}

static class Parser implements IParser{

public Expr parse(C context, Object form) throws Exception{
if(context == C.EVAL)
return
analyze(context,
RT.list(
RT.list(FN, PersistentVector.EMPTY, form)));
return new ThrowExpr(analyze(C.EXPRESSION, RT.second(form)));
}
}
}

static public boolean subsumes(Class[] c1, Class[] c2){

//presumes matching lengths
Boolean better = false;
for(int i = 0; i < c1.length; i++)
{
if(c1[i] != c2[i])
// || c2[i].isPrimitive() && c1[i] == Object.class))
{
if(!c1[i].isPrimitive() && c2[i].isPrimitive()
//|| Number.class.isAssignableFrom(c1[i]) &&
// c2[i].isPrimitive()
||
c2[i].isAssignableFrom(c1[i]))
better = true;
else
return false;
}
}
return better;
}

static int getMatchingParams(String methodName,

ArrayList<Class[]> paramlists,
IPersistentVector argexprs,
List<Class> rets)
8.24. COMPILER.JAVA 519

throws Exception{
//presumes matching lengths
int matchIdx = -1;
boolean tied = false;
boolean foundExact = false;
for(int i = 0; i < paramlists.size(); i++)
{
boolean match = true;
ISeq aseq = argexprs.seq();
int exact = 0;
for(int p = 0; match &&
p < argexprs.count() &&
aseq != null;
++p, aseq = aseq.next())
{
Expr arg = (Expr) aseq.first();
Class aclass =
arg.hasJavaClass() ? arg.getJavaClass() : Object.class;
Class pclass = paramlists.get(i)[p];
if(arg.hasJavaClass() && aclass == pclass)
exact++;
else
match = Reflector.paramArgTypeMatch(pclass, aclass);
}
if(exact == argexprs.count())
{
if(!foundExact ||
matchIdx == -1 ||
rets.get(matchIdx).isAssignableFrom(rets.get(i)))
matchIdx = i;
foundExact = true;
}
else if(match && !foundExact)
{
if(matchIdx == -1)
matchIdx = i;
else
{
if(subsumes(paramlists.get(i), paramlists.get(matchIdx)))
{
matchIdx = i;
tied = false;
}
else if(Arrays.equals(paramlists.get(matchIdx),
paramlists.get(i)))
{
if(rets.get(matchIdx).isAssignableFrom(rets.get(i)))
matchIdx = i;
}
else if(!(subsumes(paramlists.get(matchIdx),
520 CHAPTER 8. JVM/CLOJURE/LANG/

paramlists.get(i))))
tied = true;
}
}
}
if(tied)
throw new IllegalArgumentException(
"More than one matching method found: " + methodName);

return matchIdx;
}

public static class NewExpr implements Expr{

public final IPersistentVector args;
public final Constructor ctor;
public final Class c;
final static Method invokeConstructorMethod =
Method.getMethod("Object invokeConstructor(Class,Object[])");
// final static Method forNameMethod =
// Method.getMethod("Class classForName(String)");
final static Method forNameMethod =
Method.getMethod("Class forName(String)");

public NewExpr(Class c, IPersistentVector args, int line)

throws Exception{
this.args = args;
this.c = c;
Constructor[] allctors = c.getConstructors();
ArrayList ctors = new ArrayList();
ArrayList<Class[]> params = new ArrayList();
ArrayList<Class> rets = new ArrayList();
for(int i = 0; i < allctors.length; i++)
{
Constructor ctor = allctors[i];
if(ctor.getParameterTypes().length == args.count())
{
ctors.add(ctor);
params.add(ctor.getParameterTypes());
rets.add(c);
}
}
if(ctors.isEmpty())
throw new IllegalArgumentException(
"No matching ctor found for " + c);

int ctoridx = 0;
if(ctors.size() > 1)
{
ctoridx = getMatchingParams(c.getName(), params, args, rets);
8.24. COMPILER.JAVA 521

this.ctor =
ctoridx >= 0 ? (Constructor) ctors.get(ctoridx) : null;
if(ctor == null &&
RT.booleanCast(RT.WARN_ON_REFLECTION.deref()))
{
RT.errPrintWriter()
.format(
"Reflection warning, %s:%d - call to %s ctor can’t be resolved.\n",
SOURCE_PATH.deref(), line, c.getName());
}
}

public Object eval() throws Exception{

Object[] argvals = new Object[args.count()];
for(int i = 0; i < args.count(); i++)
argvals[i] = ((Expr) args.nth(i)).eval();
if(this.ctor != null)
{
return
ctor.newInstance(
Reflector.boxArgs(ctor.getParameterTypes(), argvals));
}
return Reflector.invokeConstructor(c, argvals);
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

if(this.ctor != null)
{
Type type = getType(c);
gen.newInstance(type);
gen.dup();
MethodExpr.emitTypedArgs(objx, gen, ctor.
getParameterTypes(), args);
if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
gen.invokeConstructor(type,
new Method("<init>",
Type.getConstructorDescriptor(ctor)));
}
else
{
gen.push(destubClassName(c.getName()));
gen.invokeStatic(CLASS_TYPE, forNameMethod);
MethodExpr.emitArgsAsArray(args, objx, gen);
if(context == C.RETURN)
522 CHAPTER 8. JVM/CLOJURE/LANG/

{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
gen.invokeStatic(REFLECTOR_TYPE, invokeConstructorMethod);
}
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass(){

return true;
}

public Class getJavaClass() throws Exception{

return c;
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
int line = (Integer) LINE.deref();
ISeq form = (ISeq) frm;
//(new Classname args...)
if(form.count() < 2)
throw new Exception(
"wrong number of arguments, expecting: (new Classname args...)");
Class c = HostExpr.maybeClass(RT.second(form), false);
if(c == null)
throw new IllegalArgumentException(
"Unable to resolve classname: " + RT.second(form));
PersistentVector args = PersistentVector.EMPTY;
for(ISeq s = RT.next(RT.next(form)); s != null; s = s.next())
args =
args.cons(analyze(context == C.EVAL
? context
: C.EXPRESSION, s.first()));
return new NewExpr(c, args, line);
}
}

public static class MetaExpr implements Expr{

public final Expr expr;
public final Expr meta;
final static Type IOBJ_TYPE = Type.getType(IObj.class);
final static Method withMetaMethod =
Method.getMethod(
"clojure.lang.IObj withMeta(clojure.lang.IPersistentMap)");
8.24. COMPILER.JAVA 523

public MetaExpr(Expr expr, Expr meta){

this.expr = expr;
this.meta = meta;
}

public Object eval() throws Exception{

return ((IObj) expr.eval()).withMeta((IPersistentMap) meta.eval());
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

expr.emit(C.EXPRESSION, objx, gen);
gen.checkCast(IOBJ_TYPE);
meta.emit(C.EXPRESSION, objx, gen);
gen.checkCast(IPERSISTENTMAP_TYPE);
gen.invokeInterface(IOBJ_TYPE, withMetaMethod);
if(context == C.STATEMENT)
{
gen.pop();
}
}

public boolean hasJavaClass() throws Exception{

return expr.hasJavaClass();
}

public Class getJavaClass() throws Exception{

return expr.getJavaClass();
}
}

public static class IfExpr implements Expr, MaybePrimitiveExpr{

public final Expr testExpr;
public final Expr thenExpr;
public final Expr elseExpr;
public final int line;

public IfExpr(int line, Expr testExpr, Expr thenExpr, Expr elseExpr){

this.testExpr = testExpr;
this.thenExpr = thenExpr;
this.elseExpr = elseExpr;
this.line = line;
}

public Object eval() throws Exception{

Object t = testExpr.eval();
if(t != null && t != Boolean.FALSE)
return thenExpr.eval();
return elseExpr.eval();
524 CHAPTER 8. JVM/CLOJURE/LANG/

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

doEmit(context, objx, gen,false);
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
doEmit(context, objx, gen, true);
}

public void doEmit(C context,

ObjExpr objx,
GeneratorAdapter gen,
boolean emitUnboxed){
Label nullLabel = gen.newLabel();
Label falseLabel = gen.newLabel();
Label endLabel = gen.newLabel();

gen.visitLineNumber(line, gen.mark());

try
{
if(maybePrimitiveType(testExpr) == boolean.class)
{
((MaybePrimitiveExpr) testExpr)
.emitUnboxed(C.EXPRESSION, objx, gen);
gen.ifZCmp(gen.EQ, falseLabel);
}
else
{
testExpr.emit(C.EXPRESSION, objx, gen);
gen.dup();
gen.ifNull(nullLabel);
gen.getStatic(BOOLEAN_OBJECT_TYPE, "FALSE",
BOOLEAN_OBJECT_TYPE);
gen.visitJumpInsn(IF_ACMPEQ, falseLabel);
}
}
catch(Exception e)
{
throw new RuntimeException(e);
}
if(emitUnboxed)
((MaybePrimitiveExpr)thenExpr).emitUnboxed(context, objx, gen);
else
thenExpr.emit(context, objx, gen);
gen.goTo(endLabel);
gen.mark(nullLabel);
8.24. COMPILER.JAVA 525

gen.pop();
gen.mark(falseLabel);
if(emitUnboxed)
((MaybePrimitiveExpr)elseExpr).emitUnboxed(context, objx, gen);
else
elseExpr.emit(context, objx, gen);
gen.mark(endLabel);
}

public boolean hasJavaClass() throws Exception{

return thenExpr.hasJavaClass()
&& elseExpr.hasJavaClass()
&&
(thenExpr.getJavaClass() == elseExpr.getJavaClass()
|| (thenExpr.getJavaClass() == null
&& !elseExpr.getJavaClass().isPrimitive())
|| (elseExpr.getJavaClass() == null
&& !thenExpr.getJavaClass().isPrimitive()));
}

public boolean canEmitPrimitive(){

try
{
return thenExpr instanceof MaybePrimitiveExpr
&& elseExpr instanceof MaybePrimitiveExpr
&& thenExpr.getJavaClass() == elseExpr.getJavaClass()
&& ((MaybePrimitiveExpr)thenExpr).canEmitPrimitive()
&& ((MaybePrimitiveExpr)elseExpr).canEmitPrimitive();
}
catch(Exception e)
{
return false;
}
}

public Class getJavaClass() throws Exception{

Class thenClass = thenExpr.getJavaClass();
if(thenClass != null)
return thenClass;
return elseExpr.getJavaClass();
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
ISeq form = (ISeq) frm;
//(if test then) or (if test then else)
if(form.count() > 4)
throw new Exception("Too many arguments to if");
else if(form.count() < 3)
throw new Exception("Too few arguments to if");
526 CHAPTER 8. JVM/CLOJURE/LANG/

PathNode branch =
new PathNode(PATHTYPE.BRANCH, (PathNode) CLEAR_PATH.get());
Expr testexpr =
analyze(context == C.EVAL
? context
: C.EXPRESSION, RT.second(form));
Expr thenexpr, elseexpr;
try {
Var.pushThreadBindings(
RT.map(CLEAR_PATH,
new PathNode(PATHTYPE.PATH,branch)));
thenexpr = analyze(context, RT.third(form));
}
finally{
Var.popThreadBindings();
}
try {
Var.pushThreadBindings(
RT.map(CLEAR_PATH,
new PathNode(PATHTYPE.PATH,branch)));
elseexpr = analyze(context, RT.fourth(form));
}
finally{
Var.popThreadBindings();
}
return new IfExpr((Integer) LINE.deref(),
testexpr,
thenexpr,
elseexpr);
}
}
}

static final public IPersistentMap CHAR_MAP =

public Class getJavaClass() throws Exception{

return IPersistentMap.class;
}

static public Expr parse(C context, IPersistentMap form)

530 CHAPTER 8. JVM/CLOJURE/LANG/

throws Exception{
IPersistentVector keyvals = PersistentVector.EMPTY;
boolean constant = true;
for(ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry) s.first();
Expr k =
analyze(context == C.EVAL
? context
: C.EXPRESSION, e.key());
Expr v =
analyze(context == C.EVAL
? context
: C.EXPRESSION, e.val());
keyvals = (IPersistentVector) keyvals.cons(k);
keyvals = (IPersistentVector) keyvals.cons(v);
if(!(k instanceof LiteralExpr && v instanceof LiteralExpr))
constant = false;
}

Expr ret = new MapExpr(keyvals);

if(form instanceof IObj && ((IObj) form).meta() != null)
return new MetaExpr(ret, MapExpr
.parse(context == C.EVAL
? context
: C.EXPRESSION, ((IObj) form).meta()));
else if(constant)
{
IPersistentMap m = PersistentHashMap.EMPTY;
for(int i=0;i<keyvals.length();i+= 2)
{
m = m.assoc(((LiteralExpr)keyvals.nth(i)).val(),
((LiteralExpr)keyvals.nth(i+1)).val());
}
// System.err.println("Constant: " + m);
return new ConstantExpr(m);
}
else
return ret;
}
}

public static class SetExpr implements Expr{

public final IPersistentVector keys;
final static Method setMethod =
Method.getMethod("clojure.lang.IPersistentSet set(Object[])");

public SetExpr(IPersistentVector keys){

this.keys = keys;
8.24. COMPILER.JAVA 531

public Object eval() throws Exception{

Object[] ret = new Object[keys.count()];
for(int i = 0; i < keys.count(); i++)
ret[i] = ((Expr) keys.nth(i)).eval();
return RT.set(ret);
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

MethodExpr.emitArgsAsArray(keys, objx, gen);
gen.invokeStatic(RT_TYPE, setMethod);
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass() throws Exception{

return true;
}

public Class getJavaClass() throws Exception{

return IPersistentSet.class;
}

static public Expr parse(C context, IPersistentSet form)

throws Exception{
IPersistentVector keys = PersistentVector.EMPTY;
boolean constant = true;

for(ISeq s = RT.seq(form); s != null; s = s.next())

{
Object e = s.first();
Expr expr = analyze(context == C.EVAL
? context
: C.EXPRESSION, e);
keys = (IPersistentVector) keys.cons(expr);
if(!(expr instanceof LiteralExpr))
constant = false;
}
Expr ret = new SetExpr(keys);
if(form instanceof IObj && ((IObj) form).meta() != null)
return new MetaExpr(ret, MapExpr
.parse(context == C.EVAL
? context
: C.EXPRESSION, ((IObj) form).meta()));
else if(constant)
{
IPersistentSet set = PersistentHashSet.EMPTY;
for(int i=0;i<keys.count();i++)
532 CHAPTER 8. JVM/CLOJURE/LANG/

{
LiteralExpr ve = (LiteralExpr)keys.nth(i);
set = (IPersistentSet)set.cons(ve.val());
}
// System.err.println("Constant: " + set);
return new ConstantExpr(set);
}
else
return ret;
}
}

public static class VectorExpr implements Expr{

public final IPersistentVector args;
final static Method vectorMethod =
Method.getMethod(
"clojure.lang.IPersistentVector vector(Object[])");

public VectorExpr(IPersistentVector args){

this.args = args;
}

public Object eval() throws Exception{

IPersistentVector ret = PersistentVector.EMPTY;
for(int i = 0; i < args.count(); i++)
ret =
(IPersistentVector) ret.cons(((Expr) args.nth(i)).eval());
return ret;
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

MethodExpr.emitArgsAsArray(args, objx, gen);
gen.invokeStatic(RT_TYPE, vectorMethod);
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass() throws Exception{

return true;
}

public Class getJavaClass() throws Exception{

return IPersistentVector.class;
}

static public Expr parse(C context, IPersistentVector form)

throws Exception{
boolean constant = true;
8.24. COMPILER.JAVA 533

IPersistentVector args = PersistentVector.EMPTY;

for(int i = 0; i < form.count(); i++)
{
Expr v = analyze(context == C.EVAL
? context
: C.EXPRESSION, form.nth(i));
args = (IPersistentVector) args.cons(v);
if(!(v instanceof LiteralExpr))
constant = false;
}
Expr ret = new VectorExpr(args);
if(form instanceof IObj && ((IObj) form).meta() != null)
return new MetaExpr(ret, MapExpr
.parse(context == C.EVAL
? context
: C.EXPRESSION, ((IObj) form).meta()));
else if (constant)
{
PersistentVector rv = PersistentVector.EMPTY;
for(int i =0;i<args.count();i++)
{
LiteralExpr ve = (LiteralExpr)args.nth(i);
rv = rv.cons(ve.val());
}
// System.err.println("Constant: " + rv);
return new ConstantExpr(rv);
}
else
return ret;
}

static class KeywordInvokeExpr implements Expr{

public final KeywordExpr kw;
public final Object tag;
public final Expr target;
public final int line;
public final int siteIndex;
public final String source;
static Type ILOOKUP_TYPE = Type.getType(ILookup.class);

public KeywordInvokeExpr(String source, int line, Symbol tag,

KeywordExpr kw, Expr target){
this.source = source;
this.kw = kw;
this.target = target;
this.line = line;
this.tag = tag;
this.siteIndex = registerKeywordCallsite(kw.k);
534 CHAPTER 8. JVM/CLOJURE/LANG/

public Object eval() throws Exception{

try
{
return kw.k.invoke(target.eval());
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(source, line, e);
else
throw (CompilerException) e;
}
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

Label endLabel = gen.newLabel();
Label faultLabel = gen.newLabel();

gen.visitLineNumber(line, gen.mark());
gen.getStatic(objx.objtype,
objx.thunkNameStatic(siteIndex),
ObjExpr.ILOOKUP_THUNK_TYPE);
gen.dup(); //thunk, thunk
target.emit(C.EXPRESSION, objx, gen); //thunk,thunk,target
gen.dupX2(); //target,thunk,thunk,target
gen.invokeInterface(ObjExpr.ILOOKUP_THUNK_TYPE,
Method.getMethod("Object get(Object)"));
//target,thunk,result
gen.dupX2(); //result,target,thunk,result
gen.visitJumpInsn(IF_ACMPEQ, faultLabel); //result,target
gen.pop(); //result
gen.goTo(endLabel);

gen.mark(faultLabel); //result,target
gen.swap(); //target,result
gen.pop(); //target
gen.dup(); //target,target
gen.getStatic(objx.objtype,
objx.siteNameStatic(siteIndex),
ObjExpr.KEYWORD_LOOKUPSITE_TYPE);
//target,target,site
gen.swap(); //target,site,target
gen.invokeInterface(ObjExpr.ILOOKUP_SITE_TYPE,
Method.getMethod("clojure.lang.ILookupThunk fault(Object)"));
//target,new-thunk
gen.dup(); //target,new-thunk,new-thunk
gen.putStatic(objx.objtype,
objx.thunkNameStatic(siteIndex),
8.24. COMPILER.JAVA 535

ObjExpr.ILOOKUP_THUNK_TYPE); //target,new-thunk
gen.swap(); //new-thunk,target
gen.invokeInterface(ObjExpr.ILOOKUP_THUNK_TYPE,
Method.getMethod("Object get(Object)"));
//result

gen.mark(endLabel);
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass() throws Exception{

return tag != null;
}

public Class getJavaClass() throws Exception{

public boolean canEmitPrimitive(){

return retClass.isPrimitive();
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
Method ms =
new Method("invokeStatic", getReturnType(), paramtypes);
if(variadic)
{
for(int i = 0; i < paramclasses.length - 1; i++)
{
Expr e = (Expr) args.nth(i);
try
{
if(maybePrimitiveType(e) == paramclasses[i])
{
((MaybePrimitiveExpr) e)
.emitUnboxed(C.EXPRESSION, objx, gen);
}
else
{
e.emit(C.EXPRESSION, objx, gen);
HostExpr.emitUnboxArg(objx, gen,
paramclasses[i]);
}
}
catch(Exception ex)
{
8.24. COMPILER.JAVA 539

throw new RuntimeException(ex);

}
}
IPersistentVector restArgs =
RT.subvec(args,paramclasses.length - 1,args.count());
MethodExpr.emitArgsAsArray(restArgs,objx,gen);
gen.invokeStatic(Type.getType(ArraySeq.class),
Method.getMethod(
"clojure.lang.ArraySeq create(Object[])"));
}
else
MethodExpr.emitTypedArgs(objx, gen, paramclasses, args);

gen.invokeStatic(target, ms);
}

private Type getReturnType(){

return Type.getType(retClass);
}

public static Expr parse(Var v, ISeq args, Symbol tag)

throws Exception{
IPersistentCollection paramlists =
(IPersistentCollection) RT.get(v.meta(), arglistsKey);
if(paramlists == null)
throw new IllegalStateException(
"Can’t call static fn with no arglists: " + v);
IPersistentVector paramlist = null;
int argcount = RT.count(args);
boolean variadic = false;
for(ISeq aseq =
RT.seq(paramlists); aseq != null; aseq = aseq.next())
{
if(!(aseq.first() instanceof IPersistentVector))
throw new IllegalStateException(
"Expected vector arglist, had: " + aseq.first());
IPersistentVector alist = (IPersistentVector) aseq.first();
if(alist.count() > 1
&& alist.nth(alist.count() - 2).equals(_AMP_))
{
if(argcount >= alist.count() - 2)
{
paramlist = alist;
variadic = true;
}
}
else if(alist.count() == argcount)
{
paramlist = alist;
variadic = false;
540 CHAPTER 8. JVM/CLOJURE/LANG/

break;
}
}

if(paramlist == null)
throw new IllegalArgumentException(
"Invalid arity - can’t call: " + v + " with " +
argcount + " args");

Class retClass = tagClass(tagOf(paramlist));

ArrayList<Class> paramClasses = new ArrayList();

ArrayList<Type> paramTypes = new ArrayList();

if(variadic)
{
for(int i = 0; i < paramlist.count()-2;i++)
{
Class pc = tagClass(tagOf(paramlist.nth(i)));
paramClasses.add(pc);
paramTypes.add(Type.getType(pc));
}
paramClasses.add(ISeq.class);
paramTypes.add(Type.getType(ISeq.class));
}
else
{
for(int i = 0; i < argcount;i++)
{
Class pc = tagClass(tagOf(paramlist.nth(i)));
paramClasses.add(pc);
paramTypes.add(Type.getType(pc));
}
}

String cname =
v.ns.name.name.replace(’.’, ’/’).replace(’-’,’_’) +
"$" + munge(v.sym.name);
Type target = Type.getObjectType(cname);

PersistentVector argv = PersistentVector.EMPTY;

for(ISeq s = RT.seq(args); s != null; s = s.next())
argv = argv.cons(analyze(C.EXPRESSION, s.first()));

return
new StaticInvokeExpr(target,
retClass,
paramClasses
.toArray(new Class[paramClasses.size()]),
paramTypes
8.24. COMPILER.JAVA 541

.toArray(new Type[paramTypes.size()]),
variadic, argv, tag);
}
}

static class InvokeExpr implements Expr{

public final Expr fexpr;
public final Object tag;
public final IPersistentVector args;
public final int line;
public final String source;
public boolean isProtocol = false;
public boolean isDirect = false;
public int siteIndex = -1;
public Class protocolOn;
public java.lang.reflect.Method onMethod;
static Keyword onKey = Keyword.intern("on");
static Keyword methodMapKey = Keyword.intern("method-map");

public InvokeExpr(String source,

int line,
Symbol tag,
Expr fexpr,
IPersistentVector args) throws Exception{
this.source = source;
this.fexpr = fexpr;
this.args = args;
this.line = line;
if(fexpr instanceof VarExpr)
{
Var fvar = ((VarExpr)fexpr).var;
Var pvar = (Var)RT.get(fvar.meta(), protocolKey);
if(pvar != null && PROTOCOL_CALLSITES.isBound())
{
this.isProtocol = true;
this.siteIndex =
registerProtocolCallsite(((VarExpr)fexpr).var);
Object pon = RT.get(pvar.get(), onKey);
this.protocolOn = HostExpr.maybeClass(pon,false);
if(this.protocolOn != null)
{
IPersistentMap mmap =
(IPersistentMap) RT.get(pvar.get(), methodMapKey);
Keyword mmapVal =
(Keyword) mmap.valAt(Keyword.intern(fvar.sym));
if (mmapVal == null) {
throw new IllegalArgumentException(
"No method of interface: " +
protocolOn.getName() +
" found for function: " +
542 CHAPTER 8. JVM/CLOJURE/LANG/

fvar.sym + " of protocol: " +

pvar.sym +
" (The protocol method may have been defined before and removed.)");
}
String mname = munge(mmapVal.sym.toString());
List methods =
Reflector.getMethods(protocolOn, args.count() - 1,
mname, false);
if(methods.size() != 1)
throw new IllegalArgumentException(
"No single method: " + mname +
" of interface: " +
protocolOn.getName() +
" found for function: " + fvar.sym +
" of protocol: " + pvar.sym);
this.onMethod =
(java.lang.reflect.Method) methods.get(0);
}
}
}
this.tag = tag != null
? tag
: (fexpr instanceof VarExpr
? ((VarExpr) fexpr).tag
: null);
}

public Object eval() throws Exception{

try
{
IFn fn = (IFn) fexpr.eval();
PersistentVector argvs = PersistentVector.EMPTY;
for(int i = 0; i < args.count(); i++)
argvs = argvs.cons(((Expr) args.nth(i)).eval());
return fn.applyTo(RT.seq(argvs));
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(source, line, e);
else
throw (CompilerException) e;
}
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

gen.visitLineNumber(line, gen.mark());
if(isProtocol)
{
emitProto(context,objx,gen);
8.24. COMPILER.JAVA 543

else
{
fexpr.emit(C.EXPRESSION, objx, gen);
gen.checkCast(IFN_TYPE);
emitArgsAndCall(0, context,objx,gen);
}
if(context == C.STATEMENT)
gen.pop();
}

public void emitProto(C context, ObjExpr objx, GeneratorAdapter gen){

Label onLabel = gen.newLabel();
Label callLabel = gen.newLabel();
Label endLabel = gen.newLabel();

Var v = ((VarExpr)fexpr).var;

Expr e = (Expr) args.nth(0);

e.emit(C.EXPRESSION, objx, gen);
gen.dup(); //target, target
gen.invokeStatic(UTIL_TYPE,
Method.getMethod("Class classOf(Object)"));
//target,class
gen.loadThis();
gen.getField(objx.objtype,
objx.cachedClassName(siteIndex),
CLASS_TYPE); //target,class,cached-class
gen.visitJumpInsn(IF_ACMPEQ, callLabel); //target
if(protocolOn != null)
{
gen.dup(); //target, target
gen.instanceOf(Type.getType(protocolOn));
gen.ifZCmp(GeneratorAdapter.NE, onLabel);
}

gen.dup(); //target, target

gen.invokeStatic(UTIL_TYPE,
Method.getMethod("Class classOf(Object)"));
//target,class
gen.loadThis();
gen.swap();
gen.putField(objx.objtype,
objx.cachedClassName(siteIndex),
CLASS_TYPE); //target

gen.mark(callLabel); //target
objx.emitVar(gen, v);
gen.invokeVirtual(VAR_TYPE,
544 CHAPTER 8. JVM/CLOJURE/LANG/

Method.getMethod("Object getRawRoot()"));
//target, proto-fn
gen.swap();
emitArgsAndCall(1, context,objx,gen);
gen.goTo(endLabel);

gen.mark(onLabel); //target
if(protocolOn != null)
{
MethodExpr.emitTypedArgs(objx, gen,
onMethod.getParameterTypes(),
RT.subvec(args,1,args.count()));
if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
method.emitClearLocals(gen);
}
Method m = new Method(onMethod.getName(),
Type.getReturnType(onMethod),
Type.getArgumentTypes(onMethod));
gen.invokeInterface(Type.getType(protocolOn), m);
HostExpr.emitBoxReturn(objx, gen, onMethod.getReturnType());
}
gen.mark(endLabel);
}

void emitArgsAndCall(int firstArgToEmit,

C context,
ObjExpr objx,
GeneratorAdapter gen){
for(int i = firstArgToEmit;
i < Math.min(MAX_POSITIONAL_ARITY, args.count());
i++)
{
Expr e = (Expr) args.nth(i);
e.emit(C.EXPRESSION, objx, gen);
}
if(args.count() > MAX_POSITIONAL_ARITY)
{
PersistentVector restArgs = PersistentVector.EMPTY;
for(int i = MAX_POSITIONAL_ARITY; i < args.count(); i++)
{
restArgs = restArgs.cons(args.nth(i));
}
MethodExpr.emitArgsAsArray(restArgs, objx, gen);
}

if(context == C.RETURN)
{
ObjMethod method = (ObjMethod) METHOD.deref();
8.24. COMPILER.JAVA 545

method.emitClearLocals(gen);
}

gen.invokeInterface(
IFN_TYPE,
new Method("invoke",
OBJECT_TYPE,
ARG_TYPES[Math.min(MAX_POSITIONAL_ARITY + 1,
args.count())]));
}

public boolean hasJavaClass() throws Exception{

return tag != null;
}

public Class getJavaClass() throws Exception{

return HostExpr.tagToClass(tag);
}

static public Expr parse(C context, ISeq form) throws Exception{

if(context != C.EVAL)
context = C.EXPRESSION;
Expr fexpr = analyze(context, form.first());
if(fexpr instanceof VarExpr &&
((VarExpr)fexpr).var.equals(INSTANCE))
{
if(RT.second(form) instanceof Symbol)
{
Class c = HostExpr.maybeClass(RT.second(form),false);
if(c != null)
return
new InstanceOfExpr(c,
analyze(context, RT.third(form)));
}
}

// if(fexpr instanceof VarExpr && context != C.EVAL)

// {
// Var v = ((VarExpr)fexpr).var;
// if(RT.booleanCast(RT.get(RT.meta(v),staticKey)))
// {
// return StaticInvokeExpr.parse(v, RT.next(form),
// tagOf(form));
// }
// }

if(fexpr instanceof VarExpr && context != C.EVAL)

{
Var v = ((VarExpr)fexpr).var;
Object arglists = RT.get(RT.meta(v), arglistsKey);
546 CHAPTER 8. JVM/CLOJURE/LANG/

int arity = RT.count(form.next());

for(ISeq s = RT.seq(arglists); s != null; s = s.next())
{
IPersistentVector args = (IPersistentVector) s.first();
if(args.count() == arity)
{
String primc = FnMethod.primInterface(args);
if(primc != null)
return
analyze(context,
RT.listStar(Symbol.intern(".invokePrim"),
((Symbol) form.first())
.withMeta(
RT.map(
RT.TAG_KEY, Symbol.intern(primc))),
form.next()));
break;
}
}
}

if(fexpr instanceof KeywordExpr &&

RT.count(form) == 2 &&
KEYWORD_CALLSITES.isBound())
{
// fexpr =
// new ConstantExpr(
// new KeywordCallSite(((KeywordExpr)fexpr).k));
Expr target = analyze(context, RT.second(form));
return
new KeywordInvokeExpr((String) SOURCE.deref(),
(Integer) LINE.deref(), tagOf(form),
(KeywordExpr) fexpr, target);
}
PersistentVector args = PersistentVector.EMPTY;
for(ISeq s = RT.seq(form.next()); s != null; s = s.next())
{
args = args.cons(analyze(context, s.first()));
}
// if(args.count() > MAX_POSITIONAL_ARITY)
// throw new IllegalArgumentException(
// String.format(
// "No more than %d args supported", MAX_POSITIONAL_ARITY));

return new InvokeExpr((String) SOURCE.deref(),

(Integer) LINE.deref(),
tagOf(form),
fexpr,
args);
}
8.24. COMPILER.JAVA 547

static class SourceDebugExtensionAttribute extends Attribute{

public SourceDebugExtensionAttribute(){
super("SourceDebugExtension");
}

void writeSMAP(ClassWriter cw, String smap){

ByteVector bv = write(cw, null, -1, -1, -1);
bv.putUTF8(smap);
}
}

static public class FnExpr extends ObjExpr{

final static Type aFnType = Type.getType(AFunction.class);
final static Type restFnType = Type.getType(RestFn.class);
//if there is a variadic overload (there can only be one)
// it is stored here
FnMethod variadicMethod = null;
IPersistentCollection methods;
// String superName = null;

public FnExpr(Object tag){

super(tag);
}

public boolean hasJavaClass() throws Exception{

return true;
}

public Class getJavaClass() throws Exception{

return AFunction.class;
}

protected void emitMethods(ClassVisitor cv){

//override of invoke/doInvoke for each method
for(ISeq s = RT.seq(methods); s != null; s = s.next())
{
ObjMethod method = (ObjMethod) s.first();
method.emit(this, cv);
}

if(isVariadic())
{
GeneratorAdapter gen =
new GeneratorAdapter(
ACC_PUBLIC,
Method.getMethod("int getRequiredArity()"),
null,
null,
548 CHAPTER 8. JVM/CLOJURE/LANG/

cv);
gen.visitCode();
gen.push(variadicMethod.reqParms.count());
gen.returnValue();
gen.endMethod();
}
}

static Expr parse(C context, ISeq form, String name)

throws Exception{
ISeq origForm = form;
FnExpr fn = new FnExpr(tagOf(form));
fn.src = form;
ObjMethod enclosingMethod = (ObjMethod) METHOD.deref();
if(((IMeta) form.first()).meta() != null)
{
fn.onceOnly =
RT.booleanCast(RT.get(RT.meta(form.first()),
Keyword.intern(null, "once")));
// fn.superName = (String) RT.get(RT.meta(form.first()),
// Keyword.intern(null,
// "super-name"));
}
//fn.thisName = name;
String basename = enclosingMethod != null ?
(enclosingMethod.objx.name + "$")
: //"clojure.fns." +
(munge(currentNS().name.name) + "$");
if(RT.second(form) instanceof Symbol)
name = ((Symbol) RT.second(form)).name;
String simpleName = name != null ?
(munge(name).replace(".", "_DOT_")
+ (enclosingMethod != null
? "__" + RT.nextID()
: ""))
: ("fn"
+ "__" + RT.nextID());
fn.name = basename + simpleName;
fn.internalName = fn.name.replace(’.’, ’/’);
fn.objtype = Type.getObjectType(fn.internalName);
ArrayList<String> prims = new ArrayList();
try
{
Var.pushThreadBindings(
RT.map(CONSTANTS, PersistentVector.EMPTY,
CONSTANT_IDS, new IdentityHashMap(),
KEYWORDS, PersistentHashMap.EMPTY,
VARS, PersistentHashMap.EMPTY,
KEYWORD_CALLSITES, PersistentVector.EMPTY,
PROTOCOL_CALLSITES, PersistentVector.EMPTY,
8.24. COMPILER.JAVA 549

VAR_CALLSITES, emptyVarCallSites(),
NO_RECUR, null
));

//arglist might be preceded by symbol naming this fn

if(RT.second(form) instanceof Symbol)
{
Symbol nm = (Symbol) RT.second(form);
fn.thisName = nm.name;
//RT.booleanCast(RT.get(nm.meta(), staticKey));
fn.isStatic = false;
form = RT.cons(FN, RT.next(RT.next(form)));
}

//now (fn [args] body...) or

// (fn ([args] body...) ([args2] body2...) ...)
//turn former into latter
if(RT.second(form) instanceof IPersistentVector)
form = RT.list(FN, RT.next(form));
fn.line = (Integer) LINE.deref();
FnMethod[] methodArray =
new FnMethod[MAX_POSITIONAL_ARITY + 1];
FnMethod variadicMethod = null;
for(ISeq s = RT.next(form); s != null; s = RT.next(s))
{
FnMethod f =
FnMethod.parse(fn, (ISeq) RT.first(s), fn.isStatic);
if(f.isVariadic())
{
if(variadicMethod == null)
variadicMethod = f;
else
throw new Exception(
"Can’t have more than 1 variadic overload");
}
else if(methodArray[f.reqParms.count()] == null)
methodArray[f.reqParms.count()] = f;
else
throw new Exception(
"Can’t have 2 overloads with same arity");
if(f.prim != null)
prims.add(f.prim);
}
if(variadicMethod != null)
{
for(int i = variadicMethod.reqParms.count() + 1;
i <= MAX_POSITIONAL_ARITY;
i++)
if(methodArray[i] != null)
throw new Exception(
550 CHAPTER 8. JVM/CLOJURE/LANG/

"Can’t have fixed arity function with more params "+

"than variadic function");
}

if(fn.isStatic && fn.closes.count() > 0)

throw new IllegalArgumentException(
"static fns can’t be closures");
IPersistentCollection methods = null;
for(int i = 0; i < methodArray.length; i++)
if(methodArray[i] != null)
methods = RT.conj(methods, methodArray[i]);
if(variadicMethod != null)
methods = RT.conj(methods, variadicMethod);

fn.methods = methods;
fn.variadicMethod = variadicMethod;
fn.keywords = (IPersistentMap) KEYWORDS.deref();
fn.vars = (IPersistentMap) VARS.deref();
fn.constants = (PersistentVector) CONSTANTS.deref();
fn.keywordCallsites =
(IPersistentVector) KEYWORD_CALLSITES.deref();
fn.protocolCallsites =
(IPersistentVector) PROTOCOL_CALLSITES.deref();
fn.varCallsites = (IPersistentSet) VAR_CALLSITES.deref();

fn.constantsID = RT.nextID();
// DynamicClassLoader loader =
// (DynamicClassLoader) LOADER.get();
// loader.registerConstants(fn.constantsID,
// fn.constants.toArray());
}
finally
{
Var.popThreadBindings();
}
fn.compile(fn.isVariadic()
? "clojure/lang/RestFn"
: "clojure/lang/AFunction",
(prims.size() == 0)?
null
:prims.toArray(new String[prims.size()]),
fn.onceOnly);
fn.getCompiledClass();

if(origForm instanceof IObj && ((IObj) origForm).meta() != null)

return new MetaExpr(fn, MapExpr
.parse(context == C.EVAL
? context
: C.EXPRESSION, ((IObj) origForm).meta()));
else
8.24. COMPILER.JAVA 551

return fn;
}

public final ObjMethod variadicMethod(){

return variadicMethod;
}

boolean isVariadic(){
return variadicMethod != null;
}

public final IPersistentCollection methods(){

return methods;
}
}

static public class ObjExpr implements Expr{

static final String CONST_PREFIX = "const__";
String name;
//String simpleName;
String internalName;
String thisName;
Type objtype;
public final Object tag;
//localbinding->itself
IPersistentMap closes = PersistentHashMap.EMPTY;
//localbndingexprs
IPersistentVector closesExprs = PersistentVector.EMPTY;
//symbols
IPersistentSet volatiles = PersistentHashSet.EMPTY;

//symbol->lb
IPersistentMap fields = null;

//Keyword->KeywordExpr
IPersistentMap keywords = PersistentHashMap.EMPTY;
IPersistentMap vars = PersistentHashMap.EMPTY;
Class compiledClass;
int line;
PersistentVector constants;
int constantsID;
int altCtorDrops = 0;

IPersistentVector keywordCallsites;
IPersistentVector protocolCallsites;
IPersistentSet varCallsites;
boolean onceOnly = false;

Object src;
552 CHAPTER 8. JVM/CLOJURE/LANG/

final static Method voidctor = Method.getMethod("void <init>()");

protected IPersistentMap classMeta;
protected boolean isStatic;

public final String name(){

return name;
}

// public final String simpleName(){

// return simpleName;
// }

public final String internalName(){

return internalName;
}

public final String thisName(){

return thisName;
}

public final Type objtype(){

return objtype;
}

public final IPersistentMap closes(){

return closes;
}

public final IPersistentMap keywords(){

return keywords;
}

public final IPersistentMap vars(){

return vars;
}

public final Class compiledClass(){

return compiledClass;
}

public final int line(){

return line;
}

public final PersistentVector constants(){

return constants;
}

public final int constantsID(){

return constantsID;
8.24. COMPILER.JAVA 553

final static Method kwintern =

Method.getMethod("clojure.lang.Keyword intern(String, String)");
final static Method symintern =
Method.getMethod("clojure.lang.Symbol intern(String)");
final static Method varintern =
Method.getMethod(
"clojure.lang.Var intern(clojure.lang.Symbol, clojure.lang.Symbol)");

final static Type DYNAMIC_CLASSLOADER_TYPE =

Type.getType(DynamicClassLoader.class);
final static Method getClassMethod =
Method.getMethod("Class getClass()");
final static Method getClassLoaderMethod =
Method.getMethod("ClassLoader getClassLoader()");
final static Method getConstantsMethod =
Method.getMethod("Object[] getConstants(int)");
final static Method readStringMethod =
Method.getMethod("Object readString(String)");

final static Type ILOOKUP_SITE_TYPE =

Type.getType(ILookupSite.class);
final static Type ILOOKUP_THUNK_TYPE =
Type.getType(ILookupThunk.class);
final static Type KEYWORD_LOOKUPSITE_TYPE =
Type.getType(KeywordLookupSite.class);

private DynamicClassLoader loader;

private byte[] bytecode;

public ObjExpr(Object tag){

this.tag = tag;
}

static String trimGenID(String name){

int i = name.lastIndexOf("__");
return i==-1?name:name.substring(0,i);
}

Type[] ctorTypes(){
IPersistentVector tv =
isDeftype()
? PersistentVector.EMPTY
: RT.vector(IPERSISTENTMAP_TYPE);
for(ISeq s = RT.keys(closes); s != null; s = s.next())
{
LocalBinding lb = (LocalBinding) s.first();
554 CHAPTER 8. JVM/CLOJURE/LANG/

if(lb.getPrimitiveType() != null)
tv = tv.cons(Type.getType(lb.getPrimitiveType()));
else
tv = tv.cons(OBJECT_TYPE);
}
Type[] ret = new Type[tv.count()];
for(int i = 0; i < tv.count(); i++)
ret[i] = (Type) tv.nth(i);
return ret;
}

void compile(String superName,

String[] interfaceNames,
boolean oneTimeUse)
throws Exception{
//create bytecode for a class
//with name current_ns.defname[$letname]+
//anonymous fns get names fn__id
//derived from AFn/RestFn
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
// ClassWriter cw = new ClassWriter(0);
ClassVisitor cv = cw;
// ClassVisitor cv =
// new TraceClassVisitor(new CheckClassAdapter(cw),
// new PrintWriter(System.out));
// ClassVisitor cv =
// new TraceClassVisitor(cw, new PrintWriter(System.out));
cv.visit(V1_5, ACC_PUBLIC + ACC_SUPER + ACC_FINAL,
internalName, null,superName,interfaceNames);
// superName != null ? superName :
// (isVariadic()
// ? "clojure/lang/RestFn"
// : "clojure/lang/AFunction"), null);
String source = (String) SOURCE.deref();
int lineBefore = (Integer) LINE_BEFORE.deref();
int lineAfter = (Integer) LINE_AFTER.deref() + 1;

if(source != null && SOURCE_PATH.deref() != null)

{
//cv.visitSource(source, null);
String smap = "SMAP\n" +
((source.lastIndexOf(’.’) > 0) ?
source.substring(0, source.lastIndexOf(’.’))
:source)
// : simpleName)
+ ".java\n" +
"Clojure\n" +
"*S Clojure\n" +
"*F\n" +
"+ 1 " + source + "\n" +
8.24. COMPILER.JAVA 555

(String) SOURCE_PATH.deref() + "\n" +

"*L\n" +
String.format("%d#1,%d:%d\n", lineBefore,
lineAfter - lineBefore, lineBefore) +
"*E";
cv.visitSource(source, smap);
}
addAnnotation(cv, classMeta);
//static fields for constants
for(int i = 0; i < constants.count(); i++)
{
cv.visitField(ACC_PUBLIC + ACC_FINAL
+ ACC_STATIC,
constantName(i),
constantType(i).getDescriptor(),
null, null);
}

// for(int i=0;i<varCallsites.count();i++)
// {
// cv.visitField(ACC_PRIVATE + ACC_STATIC + ACC_FINAL
// , varCallsiteName(i),
// IFN_TYPE.getDescriptor(), null, null);
// }

//static init for constants, keywords and vars

GeneratorAdapter clinitgen =
new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC,
Method.getMethod("void <clinit> ()"),
null,
null,
cv);
clinitgen.visitCode();
clinitgen.visitLineNumber(line, clinitgen.mark());

if(constants.count() > 0)
556 CHAPTER 8. JVM/CLOJURE/LANG/

{
emitConstants(clinitgen);
}

if(keywordCallsites.count() > 0)
emitKeywordCallsites(clinitgen);

/*
for(int i=0;i<varCallsites.count();i++)
{
Label skipLabel = clinitgen.newLabel();
Label endLabel = clinitgen.newLabel();
Var var = (Var) varCallsites.nth(i);
clinitgen.push(var.ns.name.toString());
clinitgen.push(var.sym.toString());
clinitgen.invokeStatic(RT_TYPE,
Method.getMethod("clojure.lang.Var var(String,String)"));
clinitgen.dup();
clinitgen.invokeVirtual(VAR_TYPE,
Method.getMethod("boolean hasRoot()"));
clinitgen.ifZCmp(GeneratorAdapter.EQ,skipLabel);

clinitgen.invokeVirtual(VAR_TYPE,
Method.getMethod("Object getRoot()"));
clinitgen.dup();
clinitgen.instanceOf(AFUNCTION_TYPE);
clinitgen.ifZCmp(GeneratorAdapter.EQ,skipLabel);
clinitgen.checkCast(IFN_TYPE);
clinitgen.putStatic(objtype, varCallsiteName(i), IFN_TYPE);
clinitgen.goTo(endLabel);

clinitgen.mark(skipLabel);
clinitgen.pop();

clinitgen.mark(endLabel);
}
*/
clinitgen.returnValue();

clinitgen.endMethod();
if(!isDeftype())
{
cv.visitField(ACC_FINAL, "__meta",
IPERSISTENTMAP_TYPE.getDescriptor(), null, null);
}
//instance fields for closed-overs
for(ISeq s = RT.keys(closes); s != null; s = s.next())
{
LocalBinding lb = (LocalBinding) s.first();
if(isDeftype())
8.24. COMPILER.JAVA 557

{
int access = isVolatile(lb) ? ACC_VOLATILE :
isMutable(lb) ? 0 :
(ACC_PUBLIC + ACC_FINAL);
FieldVisitor fv;
if(lb.getPrimitiveType() != null)
fv = cv.visitField(access,
lb.name,
Type.getType(lb.getPrimitiveType())
.getDescriptor(),
null, null);
else
//todo - when closed-overs are fields, use more
// specific types here and in ctor and emitLocal?
fv = cv.visitField(access,
lb.name,
OBJECT_TYPE.getDescriptor(), null, null);
addAnnotation(fv, RT.meta(lb.sym));
}
else
{
//todo - only enable this non-private+writability
// for letfns where we need it
if(lb.getPrimitiveType() != null)
cv.visitField(0 + (isVolatile(lb)
? ACC_VOLATILE
: 0),
lb.name,
Type.getType(lb.getPrimitiveType())
.getDescriptor(),
null, null);
else
cv.visitField(0 //+ (oneTimeUse ? 0 : ACC_FINAL),
lb.name,
OBJECT_TYPE.getDescriptor(), null, null);
}
}

//instance fields for callsites and thunks

for(int i=0;i<protocolCallsites.count();i++)
{
cv.visitField(ACC_PRIVATE, cachedClassName(i),
CLASS_TYPE.getDescriptor(), null, null);
cv.visitField(ACC_PRIVATE, cachedProtoFnName(i),
AFUNCTION_TYPE.getDescriptor(), null, null);
cv.visitField(ACC_PRIVATE, cachedProtoImplName(i),
IFN_TYPE.getDescriptor(), null, null);
}

//ctor that takes closed-overs and inits base + fields

558 CHAPTER 8. JVM/CLOJURE/LANG/

Method m = new Method("<init>", Type.VOID_TYPE, ctorTypes());

GeneratorAdapter ctorgen = new GeneratorAdapter(ACC_PUBLIC,
m,
null,
null,
cv);
Label start = ctorgen.newLabel();
Label end = ctorgen.newLabel();
ctorgen.visitCode();
ctorgen.visitLineNumber(line, ctorgen.mark());
ctorgen.visitLabel(start);
ctorgen.loadThis();
// if(superName != null)
ctorgen.invokeConstructor(Type.getObjectType(superName),
voidctor);
// else if(isVariadic()) //RestFn ctor takes reqArity arg
// {
// ctorgen.push(variadicMethod.reqParms.count());
// ctorgen.invokeConstructor(restFnType, restfnctor);
// }
// else
// ctorgen.invokeConstructor(aFnType, voidctor);

// if(vars.count() > 0)
// {
// ctorgen.loadThis();
// ctorgen.getStatic(VAR_TYPE,"rev",Type.INT_TYPE);
// ctorgen.push(-1);
// ctorgen.visitInsn(Opcodes.IADD);
// ctorgen.putField(objtype, "__varrev__", Type.INT_TYPE);
// }

if(!isDeftype())
{
ctorgen.loadThis();
ctorgen.visitVarInsn(IPERSISTENTMAP_TYPE
.getOpcode(Opcodes.ILOAD), 1);
ctorgen.putField(objtype, "__meta", IPERSISTENTMAP_TYPE);
}

int a = isDeftype()?1:2;
for(ISeq s = RT.keys(closes); s != null; s = s.next(), ++a)
{
LocalBinding lb = (LocalBinding) s.first();
ctorgen.loadThis();
Class primc = lb.getPrimitiveType();
if(primc != null)
{
ctorgen.visitVarInsn(
Type.getType(primc).getOpcode(Opcodes.ILOAD), a);
8.24. COMPILER.JAVA 559

ctorgen.putField(objtype, lb.name, Type.getType(primc));

if(primc == Long.TYPE || primc == Double.TYPE)
++a;
}
else
{
ctorgen.visitVarInsn(
OBJECT_TYPE.getOpcode(Opcodes.ILOAD), a);
ctorgen.putField(objtype, lb.name, OBJECT_TYPE);
}
closesExprs =
closesExprs.cons(new LocalBindingExpr(lb, null));
}

ctorgen.visitLabel(end);

ctorgen.returnValue();

ctorgen.endMethod();

if(altCtorDrops > 0)
{
//ctor that takes closed-overs and inits base + fields
Type[] ctorTypes = ctorTypes();
Type[] altCtorTypes =
new Type[ctorTypes.length-altCtorDrops];
for(int i=0;i<altCtorTypes.length;i++)
altCtorTypes[i] = ctorTypes[i];
Method alt =
new Method("<init>", Type.VOID_TYPE, altCtorTypes);
ctorgen = new GeneratorAdapter(ACC_PUBLIC,
alt,
null,
null,
cv);
ctorgen.visitCode();
ctorgen.loadThis();
ctorgen.loadArgs();
for(int i=0;i<altCtorDrops;i++)
ctorgen.visitInsn(Opcodes.ACONST_NULL);

ctorgen.invokeConstructor(objtype,
new Method("<init>",
Type.VOID_TYPE, ctorTypes));

ctorgen.returnValue();
ctorgen.endMethod();
}
560 CHAPTER 8. JVM/CLOJURE/LANG/

if(!isDeftype())
{
//ctor that takes closed-overs but not meta
Type[] ctorTypes = ctorTypes();
Type[] noMetaCtorTypes = new Type[ctorTypes.length-1];
for(int i=1;i<ctorTypes.length;i++)
noMetaCtorTypes[i-1] = ctorTypes[i];
Method alt = new Method("<init>",
Type.VOID_TYPE,
noMetaCtorTypes);
ctorgen = new GeneratorAdapter(ACC_PUBLIC,
alt,
null,
null,
cv);
ctorgen.visitCode();
ctorgen.loadThis();
ctorgen.visitInsn(Opcodes.ACONST_NULL); //null meta
ctorgen.loadArgs();
ctorgen.invokeConstructor(objtype,
new Method("<init>",
Type.VOID_TYPE, ctorTypes));

ctorgen.returnValue();
ctorgen.endMethod();

//meta()
Method meth =
Method.getMethod("clojure.lang.IPersistentMap meta()");

GeneratorAdapter gen = new GeneratorAdapter(ACC_PUBLIC,

meth,
null,
null,
cv);
gen.visitCode();
gen.loadThis();
gen.getField(objtype,"__meta",IPERSISTENTMAP_TYPE);

gen.returnValue();
gen.endMethod();

//withMeta()
meth =
Method.getMethod(
"clojure.lang.IObj withMeta(clojure.lang.IPersistentMap)");

gen = new GeneratorAdapter(ACC_PUBLIC,

meth,
null,
8.24. COMPILER.JAVA 561

null,
cv);
gen.visitCode();
gen.newInstance(objtype);
gen.dup();
gen.loadArg(0);

for(ISeq s = RT.keys(closes); s != null; s = s.next(), ++a)

{
LocalBinding lb = (LocalBinding) s.first();
gen.loadThis();
Class primc = lb.getPrimitiveType();
if(primc != null)
{
gen.getField(objtype, lb.name, Type.getType(primc));
}
else
{
gen.getField(objtype, lb.name, OBJECT_TYPE);
}
}

gen.invokeConstructor(objtype,
new Method("<init>",
Type.VOID_TYPE, ctorTypes));
gen.returnValue();
gen.endMethod();
}

emitMethods(cv);

if(keywordCallsites.count() > 0)
{
Method meth =
Method.getMethod(
"void swapThunk(int,clojure.lang.ILookupThunk)");

GeneratorAdapter gen = new GeneratorAdapter(ACC_PUBLIC,

meth,
null,
null,
cv);
gen.visitCode();
Label endLabel = gen.newLabel();

Label[] labels = new Label[keywordCallsites.count()];

for(int i = 0; i < keywordCallsites.count();i++)
{
labels[i] = gen.newLabel();
}
562 CHAPTER 8. JVM/CLOJURE/LANG/

gen.loadArg(0);
gen.visitTableSwitchInsn(0,keywordCallsites.count()-1,
endLabel,labels);

for(int i = 0; i < keywordCallsites.count();i++)

{
gen.mark(labels[i]);
// gen.loadThis();
gen.loadArg(1);
gen.putStatic(objtype,
thunkNameStatic(i),ILOOKUP_THUNK_TYPE);
gen.goTo(endLabel);
}

gen.mark(endLabel);

gen.returnValue();
gen.endMethod();
}

//end of class
cv.visitEnd();

bytecode = cw.toByteArray();
if(RT.booleanCast(COMPILE_FILES.deref()))
writeClassFile(internalName, bytecode);
// else
// getCompiledClass();
}

private void emitKeywordCallsites(GeneratorAdapter clinitgen){

for(int i=0;i<keywordCallsites.count();i++)
{
Keyword k = (Keyword) keywordCallsites.nth(i);
clinitgen.newInstance(KEYWORD_LOOKUPSITE_TYPE);
clinitgen.dup();
emitValue(k,clinitgen);
clinitgen.invokeConstructor(KEYWORD_LOOKUPSITE_TYPE,
Method.getMethod("void <init>(clojure.lang.Keyword)"));
clinitgen.dup();
clinitgen.putStatic(objtype, siteNameStatic(i),
KEYWORD_LOOKUPSITE_TYPE);
clinitgen.putStatic(objtype, thunkNameStatic(i),
ILOOKUP_THUNK_TYPE);
}
}

protected void emitMethods(ClassVisitor gen){

}
8.24. COMPILER.JAVA 563

void emitListAsObjectArray(Object value, GeneratorAdapter gen){

gen.push(((List) value).size());
gen.newArray(OBJECT_TYPE);
int i = 0;
for(Iterator it = ((List) value).iterator(); it.hasNext(); i++)
{
gen.dup();
gen.push(i);
emitValue(it.next(), gen);
gen.arrayStore(OBJECT_TYPE);
}
}

void emitValue(Object value, GeneratorAdapter gen){

boolean partial = true;
//System.out.println(value.getClass().toString());

if(value instanceof String)

{
gen.push((String) value);
}
else if(value instanceof Integer)
{
gen.push(((Integer) value).intValue());
gen.invokeStatic(Type.getType(Integer.class),
Method.getMethod("Integer valueOf(int)"));
}
else if(value instanceof Long)
{
gen.push(((Long) value).longValue());
gen.invokeStatic(Type.getType(Long.class),
Method.getMethod("Long valueOf(long)"));
}
else if(value instanceof Double)
{
gen.push(((Double) value).doubleValue());
gen.invokeStatic(Type.getType(Double.class),
Method.getMethod("Double valueOf(double)"));
}
else if(value instanceof Character)
{
gen.push(((Character) value).charValue());
gen.invokeStatic(Type.getType(Character.class),
Method.getMethod("Character valueOf(char)"));
}
else if(value instanceof Class)
{
Class cc = (Class)value;
if(cc.isPrimitive())
{
564 CHAPTER 8. JVM/CLOJURE/LANG/

Type bt;
if ( cc == boolean.class )
bt = Type.getType(Boolean.class);
else if ( cc == byte.class )
bt = Type.getType(Byte.class);
else if ( cc == char.class )
bt = Type.getType(Character.class);
else if ( cc == double.class )
bt = Type.getType(Double.class);
else if ( cc == float.class )
bt = Type.getType(Float.class);
else if ( cc == int.class )
bt = Type.getType(Integer.class);
else if ( cc == long.class )
bt = Type.getType(Long.class);
else if ( cc == short.class )
bt = Type.getType(Short.class);
else throw new RuntimeException(
"Can’t embed unknown primitive in code: " + value);
gen.getStatic( bt, "TYPE", Type.getType(Class.class) );
}
else
{
gen.push(destubClassName(cc.getName()));
gen.invokeStatic(Type.getType(Class.class),
Method.getMethod("Class forName(String)"));
}
}
else if(value instanceof Symbol)
{
gen.push(((Symbol) value).ns);
gen.push(((Symbol) value).name);
gen.invokeStatic(Type.getType(Symbol.class),
Method.getMethod(
"clojure.lang.Symbol intern(String,String)"));
}
else if(value instanceof Keyword)
{
emitValue(((Keyword) value).sym, gen);
gen.invokeStatic(Type.getType(Keyword.class),
Method.getMethod(
"clojure.lang.Keyword intern(clojure.lang.Symbol)"));
}
// else if(value instanceof KeywordCallSite)
// {
// emitValue(((KeywordCallSite) value).k.sym, gen);
// gen.invokeStatic(Type.getType(KeywordCallSite.class),
// Method.getMethod(
// "clojure.lang.KeywordCallSite create(clojure.lang.Symbol)"));
// }
8.24. COMPILER.JAVA 565

else if(value instanceof Var)

{
Var var = (Var) value;
gen.push(var.ns.name.toString());
gen.push(var.sym.toString());
gen.invokeStatic(RT_TYPE,
Method.getMethod("clojure.lang.Var var(String,String)"));
}
else if(value instanceof IPersistentMap)
{
List entries = new ArrayList();
for(Map.Entry entry :
(Set<Map.Entry>) ((Map) value).entrySet())
{
entries.add(entry.getKey());
entries.add(entry.getValue());
}
emitListAsObjectArray(entries, gen);
gen.invokeStatic(RT_TYPE,
Method.getMethod(
"clojure.lang.IPersistentMap map(Object[])"));
}
else if(value instanceof IPersistentVector)
{
emitListAsObjectArray(value, gen);
gen.invokeStatic(RT_TYPE, Method.getMethod(
"clojure.lang.IPersistentVector vector(Object[])"));
}
else if(value instanceof ISeq ||
value instanceof IPersistentList)
{
emitListAsObjectArray(value, gen);
gen.invokeStatic(Type.getType(java.util.Arrays.class),
Method.getMethod("java.util.List asList(Object[])"));
gen.invokeStatic(Type.getType(PersistentList.class),
Method.getMethod(
"clojure.lang.IPersistentList create(java.util.List)"));
}
else
{
String cs = null;
try
{
cs = RT.printString(value);
//System.out.println(
// "WARNING SLOW CODE: " + value.getClass() +
// " -> " + cs);
}
catch(Exception e)
{
566 CHAPTER 8. JVM/CLOJURE/LANG/

throw new RuntimeException(

"Can’t embed object in code, maybe print-dup not defined: " +
value);
}
if(cs.length() == 0)
throw new RuntimeException(
"Can’t embed unreadable object in code: " + value);

if(cs.startsWith("#<"))
throw new RuntimeException(
"Can’t embed unreadable object in code: " + cs);

gen.push(cs);
gen.invokeStatic(RT_TYPE, readStringMethod);
partial = false;
}

if(partial)
{
if(value instanceof IObj &&
RT.count(((IObj) value).meta()) > 0)
{
gen.checkCast(IOBJ_TYPE);
emitValue(((IObj) value).meta(), gen);
gen.checkCast(IPERSISTENTMAP_TYPE);
gen.invokeInterface(IOBJ_TYPE,
Method.getMethod(
"clojure.lang.IObj withMeta(clojure.lang.IPersistentMap)"));
}
}
}

void emitConstants(GeneratorAdapter clinitgen){

try
{
Var.pushThreadBindings(RT.map(RT.PRINT_DUP, RT.T));

for(int i = 0; i < constants.count(); i++)

{
emitValue(constants.nth(i), clinitgen);
clinitgen.checkCast(constantType(i));
clinitgen.putStatic(objtype, constantName(i),
constantType(i));
}
}
finally
{
Var.popThreadBindings();
}
8.24. COMPILER.JAVA 567

boolean isMutable(LocalBinding lb){

return isVolatile(lb) ||
RT.booleanCast(RT.contains(fields, lb.sym)) &&
RT.booleanCast(RT.get(lb.sym.meta(),
Keyword.intern("unsynchronized-mutable")));
}

boolean isVolatile(LocalBinding lb){

return RT.booleanCast(RT.contains(fields, lb.sym)) &&
RT.booleanCast(RT.get(lb.sym.meta(),
Keyword.intern("volatile-mutable")));
}

boolean isDeftype(){
return fields != null;
}

void emitClearCloses(GeneratorAdapter gen){

// int a = 1;
// for(ISeq s = RT.keys(closes); s != null; s = s.next(), ++a)
// {
// LocalBinding lb = (LocalBinding) s.first();
// Class primc = lb.getPrimitiveType();
// if(primc == null)
// {
// gen.loadThis();
// gen.visitInsn(Opcodes.ACONST_NULL);
// gen.putField(objtype, lb.name, OBJECT_TYPE);
// }
// }
}

synchronized Class getCompiledClass(){

if(compiledClass == null)
try
{
// if(RT.booleanCast(COMPILE_FILES.deref()))
// compiledClass =
// RT.classForName(name);//loader.defineClass(name, bytecode);
// else
{
loader = (DynamicClassLoader) LOADER.deref();
compiledClass =
loader.defineClass(name, bytecode, src);
}
}
catch(Exception e)
{
568 CHAPTER 8. JVM/CLOJURE/LANG/

throw new RuntimeException(e);

}
return compiledClass;
}

public Object eval() throws Exception{

if(isDeftype())
return null;
return getCompiledClass().newInstance();
}

public void emitLetFnInits(GeneratorAdapter gen,

ObjExpr objx,
IPersistentSet letFnLocals){
//objx arg is enclosing objx, not this
gen.checkCast(objtype);

for(ISeq s = RT.keys(closes); s != null; s = s.next())

{
LocalBinding lb = (LocalBinding) s.first();
if(letFnLocals.contains(lb))
{
Class primc = lb.getPrimitiveType();
gen.dup();
if(primc != null)
{
objx.emitUnboxedLocal(gen, lb);
gen.putField(objtype, lb.name, Type.getType(primc));
}
else
{
objx.emitLocal(gen, lb, false);
gen.putField(objtype, lb.name, OBJECT_TYPE);
}
}
}
gen.pop();

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

//emitting a Fn means constructing an instance, feeding
// closed-overs from enclosing scope, if any
//objx arg is enclosing objx, not this
// getCompiledClass();
if(isDeftype())
{
gen.visitInsn(Opcodes.ACONST_NULL);
}
else
8.24. COMPILER.JAVA 569

{
gen.newInstance(objtype);
gen.dup();
gen.visitInsn(Opcodes.ACONST_NULL);
for(ISeq s = RT.seq(closesExprs); s != null; s = s.next())
{
LocalBindingExpr lbe = (LocalBindingExpr) s.first();
LocalBinding lb = lbe.b;
if(lb.getPrimitiveType() != null)
objx.emitUnboxedLocal(gen, lb);
else
objx.emitLocal(gen, lb, lbe.shouldClear);
}
gen.invokeConstructor(objtype,
new Method("<init>", Type.VOID_TYPE, ctorTypes()));
}
if(context == C.STATEMENT)
gen.pop();
}

public boolean hasJavaClass() throws Exception{

return true;
}

public Class getJavaClass() throws Exception{

return (compiledClass != null) ? compiledClass
: (tag != null) ? HostExpr.tagToClass(tag)
: IFn.class;
}

public void emitAssignLocal(GeneratorAdapter gen,

LocalBinding lb,
Expr val){
if(!isMutable(lb))
throw new IllegalArgumentException(
"Cannot assign to non-mutable: " + lb.name);
Class primc = lb.getPrimitiveType();
gen.loadThis();
if(primc != null)
{
if(!(val instanceof MaybePrimitiveExpr &&
((MaybePrimitiveExpr) val).canEmitPrimitive()))
throw new IllegalArgumentException(
"Must assign primitive to primitive mutable: " +
lb.name);
MaybePrimitiveExpr me = (MaybePrimitiveExpr) val;
me.emitUnboxed(C.EXPRESSION, this, gen);
gen.putField(objtype, lb.name, Type.getType(primc));
}
else
570 CHAPTER 8. JVM/CLOJURE/LANG/

{
val.emit(C.EXPRESSION, this, gen);
gen.putField(objtype, lb.name, OBJECT_TYPE);
}
}

private void emitLocal(GeneratorAdapter gen,

LocalBinding lb,
boolean clear){
if(closes.containsKey(lb))
{
Class primc = lb.getPrimitiveType();
gen.loadThis();
if(primc != null)
{
gen.getField(objtype, lb.name, Type.getType(primc));
HostExpr.emitBoxReturn(this, gen, primc);
}
else
{
gen.getField(objtype, lb.name, OBJECT_TYPE);
if(onceOnly && clear && lb.canBeCleared)
{
gen.loadThis();
gen.visitInsn(Opcodes.ACONST_NULL);
gen.putField(objtype, lb.name, OBJECT_TYPE);
}
}
}
else
{
int argoff = isStatic?0:1;
Class primc = lb.getPrimitiveType();
// String rep =
// lb.sym.name + " " +
// lb.toString().substring(
// lb.toString().lastIndexOf(’@’));
if(lb.isArg)
{
gen.loadArg(lb.idx-argoff);
if(primc != null)
HostExpr.emitBoxReturn(this, gen, primc);
else
{
if(clear && lb.canBeCleared)
{
// System.out.println("clear: " + rep);
gen.visitInsn(Opcodes.ACONST_NULL);
gen.storeArg(lb.idx - argoff);
}
8.24. COMPILER.JAVA 571

else
{
// System.out.println("use: " + rep);
}
}
}
else
{
if(primc != null)
{
gen.visitVarInsn(Type.getType(primc)
.getOpcode(Opcodes.ILOAD),
lb.idx);
HostExpr.emitBoxReturn(this, gen, primc);
}
else
{
gen.visitVarInsn(
OBJECT_TYPE.getOpcode(Opcodes.ILOAD),
lb.idx);
if(clear && lb.canBeCleared)
{
// System.out.println("clear: " + rep);
gen.visitInsn(Opcodes.ACONST_NULL);
gen.visitVarInsn(OBJECT_TYPE
.getOpcode(Opcodes.ISTORE),
lb.idx);
}
else
{
// System.out.println("use: " + rep);
}
}
}
}
}

private void emitUnboxedLocal(GeneratorAdapter gen, LocalBinding lb){

int argoff = isStatic?0:1;
Class primc = lb.getPrimitiveType();
if(closes.containsKey(lb))
{
gen.loadThis();
gen.getField(objtype, lb.name, Type.getType(primc));
}
else if(lb.isArg)
gen.loadArg(lb.idx-argoff);
else
gen.visitVarInsn(
Type.getType(primc).getOpcode(Opcodes.ILOAD), lb.idx);
572 CHAPTER 8. JVM/CLOJURE/LANG/

public void emitVar(GeneratorAdapter gen, Var var){

Integer i = (Integer) vars.valAt(var);
emitConstant(gen, i);
//gen.getStatic(fntype, munge(var.sym.toString()), VAR_TYPE);
}

final static Method varGetMethod =

Method.getMethod("Object get()");
final static Method varGetRawMethod =
Method.getMethod("Object getRawRoot()");

public void emitVarValue(GeneratorAdapter gen, Var v){

Integer i = (Integer) vars.valAt(v);
if(!v.isDynamic())
{
emitConstant(gen, i);
gen.invokeVirtual(VAR_TYPE, varGetRawMethod);
}
else
{
emitConstant(gen, i);
gen.invokeVirtual(VAR_TYPE, varGetMethod);
}
}

public void emitKeyword(GeneratorAdapter gen, Keyword k){

Integer i = (Integer) keywords.valAt(k);
emitConstant(gen, i);
// gen.getStatic(fntype, munge(k.sym.toString()), KEYWORD_TYPE);
}

public void emitConstant(GeneratorAdapter gen, int id){

gen.getStatic(objtype, constantName(id), constantType(id));
}

String constantName(int id){

return CONST_PREFIX + id;
}

String siteName(int n){

return "__site__" + n;
}

String siteNameStatic(int n){

return siteName(n) + "__";
}
8.24. COMPILER.JAVA 573

String thunkName(int n){

return "__thunk__" + n;
}

String cachedClassName(int n){

return "__cached_class__" + n;
}

String cachedVarName(int n){

return "__cached_var__" + n;
}

String cachedProtoFnName(int n){

return "__cached_proto_fn__" + n;
}

String cachedProtoImplName(int n){

return "__cached_proto_impl__" + n;
}

String varCallsiteName(int n){

return "__var__callsite__" + n;
}

String thunkNameStatic(int n){

return thunkName(n) + "__";
}

Type constantType(int id){

Object o = constants.nth(id);
Class c = o.getClass();
if(Modifier.isPublic(c.getModifiers()))
{
//can’t emit derived fn types due to visibility
if(LazySeq.class.isAssignableFrom(c))
return Type.getType(ISeq.class);
else if(c == Keyword.class)
return Type.getType(Keyword.class);
// else if(c == KeywordCallSite.class)
// return Type.getType(KeywordCallSite.class);
else if(RestFn.class.isAssignableFrom(c))
return Type.getType(RestFn.class);
else if(AFn.class.isAssignableFrom(c))
return Type.getType(AFn.class);
else if(c == Var.class)
return Type.getType(Var.class);
else if(c == String.class)
return Type.getType(String.class);

// return Type.getType(c);
574 CHAPTER 8. JVM/CLOJURE/LANG/

}
return OBJECT_TYPE;
}

enum PATHTYPE {
PATH, BRANCH;
}

static class PathNode{

final PATHTYPE type;
final PathNode parent;

PathNode(PATHTYPE type, PathNode parent) {

this.type = type;
this.parent = parent;
}
}

static PathNode clearPathRoot(){

return (PathNode) CLEAR_ROOT.get();
}

enum PSTATE{
REQ, REST, DONE
}

public static class FnMethod extends ObjMethod{

//localbinding->localbinding
PersistentVector reqParms = PersistentVector.EMPTY;
LocalBinding restParm = null;
Type[] argtypes;
Class[] argclasses;
Class retClass;
String prim ;

public FnMethod(ObjExpr objx, ObjMethod parent){

super(objx, parent);
}

static public char classChar(Object x){

Class c = null;
if(x instanceof Class)
c = (Class) x;
else if(x instanceof Symbol)
c = primClass((Symbol) x);
if(c == null || !c.isPrimitive())
return ’O’;
if(c == long.class)
8.24. COMPILER.JAVA 575

return ’L’;
if(c == double.class)
return ’D’;
throw new IllegalArgumentException(
"Only long and double primitives are supported");
}

static public String primInterface(IPersistentVector arglist)

throws Exception{
StringBuilder sb = new StringBuilder();
for(int i=0;i<arglist.count();i++)
sb.append(classChar(tagOf(arglist.nth(i))));
sb.append(classChar(tagOf(arglist)));
String ret = sb.toString();
boolean prim = ret.contains("L") || ret.contains("D");
if(prim && arglist.count() > 4)
throw new IllegalArgumentException(
"fns taking primitives support only 4 or fewer args");
if(prim)
return "clojure.lang.IFn$" + ret;
return null;
}

static FnMethod parse(ObjExpr objx,

ISeq form,
boolean isStatic)
throws Exception{
//([args] body...)
IPersistentVector parms = (IPersistentVector) RT.first(form);
ISeq body = RT.next(form);
try
{
FnMethod method =
new FnMethod(objx, (ObjMethod) METHOD.deref());
method.line = (Integer) LINE.deref();
//register as the current method and set up a new env frame
PathNode pnode = (PathNode) CLEAR_PATH.get();
if(pnode == null)
pnode = new PathNode(PATHTYPE.PATH,null);
Var.pushThreadBindings(
RT.map(
METHOD, method,
LOCAL_ENV, LOCAL_ENV.deref(),
LOOP_LOCALS, null,
NEXT_LOCAL_NUM, 0
,CLEAR_PATH, pnode
,CLEAR_ROOT, pnode
,CLEAR_SITES, PersistentHashMap.EMPTY
));
576 CHAPTER 8. JVM/CLOJURE/LANG/

method.prim = primInterface(parms);
if(method.prim != null)
method.prim = method.prim.replace(’.’, ’/’);

method.retClass = tagClass(tagOf(parms));
if(method.retClass.isPrimitive() &&
!(method.retClass == double.class ||
method.retClass == long.class))
throw new IllegalArgumentException(
"Only long and double primitives are supported");

//register ’this’ as local 0

//registerLocal(THISFN, null, null);
if(!isStatic)
{
if(objx.thisName != null)
registerLocal(Symbol.intern(objx.thisName),
null, null,false);
else
getAndIncLocalNum();
}
PSTATE state = PSTATE.REQ;
PersistentVector argLocals = PersistentVector.EMPTY;
ArrayList<Type> argtypes = new ArrayList();
ArrayList<Class> argclasses = new ArrayList();
for(int i = 0; i < parms.count(); i++)
{
if(!(parms.nth(i) instanceof Symbol))
throw new IllegalArgumentException(
"fn params must be Symbols");
Symbol p = (Symbol) parms.nth(i);
if(p.getNamespace() != null)
throw new Exception(
"Can’t use qualified name as parameter: " + p);
if(p.equals(_AMP_))
{
// if(isStatic)
// throw new Exception(
"Variadic fns cannot be static");
if(state == PSTATE.REQ)
state = PSTATE.REST;
else
throw new Exception("Invalid parameter list");
}

else
{
Class pc = primClass(tagClass(tagOf(p)));
// if(pc.isPrimitive() && !isStatic)
// {
8.24. COMPILER.JAVA 577

// pc = Object.class;
// p = (Symbol)
// ((IObj) p)
// .withMeta(
// (IPersistentMap) RT.assoc(
// RT.meta(p), RT.TAG_KEY, null));
// }
// throw new Exception(
// "Non-static fn can’t have primitive parameter: " + p);
if(pc.isPrimitive() &&
!(pc == double.class || pc == long.class))
throw new IllegalArgumentException(
"Only long and double primitives are supported: " + p);

if(state == PSTATE.REST && tagOf(p) != null)

throw new Exception(
"& arg cannot have type hint");
if(state == PSTATE.REST && method.prim != null)
throw new Exception(
"fns taking primitives cannot be variadic");

if(state == PSTATE.REST)
pc = ISeq.class;
argtypes.add(Type.getType(pc));
argclasses.add(pc);
LocalBinding lb =
pc.isPrimitive()
? registerLocal(p, null,
new MethodParamExpr(pc), true)
: registerLocal(p, state == PSTATE.REST
? ISEQ
: tagOf(p), null, true);
argLocals = argLocals.cons(lb);
switch(state)
{
case REQ:
method.reqParms = method.reqParms.cons(lb);
break;
case REST:
method.restParm = lb;
state = PSTATE.DONE;
break;

default:
throw new Exception("Unexpected parameter");
}
}
}
if(method.reqParms.count() > MAX_POSITIONAL_ARITY)
throw new Exception("Can’t specify more than " +
578 CHAPTER 8. JVM/CLOJURE/LANG/

MAX_POSITIONAL_ARITY + " params");

LOOP_LOCALS.set(argLocals);
method.argLocals = argLocals;
// if(isStatic)
if(method.prim != null)
{
method.argtypes =
argtypes.toArray(new Type[argtypes.size()]);
method.argclasses =
argclasses.toArray(new Class[argtypes.size()]);
for(int i = 0; i < method.argclasses.length; i++)
{
if(method.argclasses[i] == long.class ||
method.argclasses[i] == double.class)
getAndIncLocalNum();
}
}
method.body = (new BodyExpr.Parser()).parse(C.RETURN, body);
return method;
}
finally
{
Var.popThreadBindings();
}
}

public void emit(ObjExpr fn, ClassVisitor cv){

if(prim != null)
doEmitPrim(fn, cv);
else if(fn.isStatic)
doEmitStatic(fn,cv);
else
doEmit(fn,cv);
}

public void doEmitStatic(ObjExpr fn, ClassVisitor cv){

Method ms =
new Method("invokeStatic", getReturnType(), argtypes);

GeneratorAdapter gen =
new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC,
ms,
null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();
Label loopLabel = gen.mark();
gen.visitLineNumber(line, loopLabel);
try
8.24. COMPILER.JAVA 579

{
Var.pushThreadBindings(
RT.map(LOOP_LABEL, loopLabel, METHOD, this));
emitBody(objx, gen, retClass, body);

Label end = gen.mark();

for(ISeq lbs = argLocals.seq();
lbs != null;
lbs = lbs.next())
{
LocalBinding lb = (LocalBinding) lbs.first();
gen.visitLocalVariable(lb.name,
argtypes[lb.idx].getDescriptor(), null,
loopLabel, end, lb.idx);
}
}
catch(Exception e)
{
throw new RuntimeException(e);
}
finally
{
Var.popThreadBindings();
}

gen.returnValue();
//gen.visitMaxs(1, 1);
gen.endMethod();

//generate the regular invoke, calling the static method

Method m =
new Method(getMethodName(), OBJECT_TYPE, getArgTypes());

gen = new GeneratorAdapter(ACC_PUBLIC,

m,
null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();
for(int i = 0; i < argtypes.length; i++)
{
gen.loadArg(i);
HostExpr.emitUnboxArg(fn, gen, argclasses[i]);
}
gen.invokeStatic(objx.objtype, ms);
gen.box(getReturnType());

gen.returnValue();
580 CHAPTER 8. JVM/CLOJURE/LANG/

//gen.visitMaxs(1, 1);
gen.endMethod();

public void doEmitPrim(ObjExpr fn, ClassVisitor cv){

Method ms =
new Method("invokePrim", getReturnType(), argtypes);

GeneratorAdapter gen =
new GeneratorAdapter(ACC_PUBLIC + ACC_FINAL,
ms,
null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();

Label loopLabel = gen.mark();

gen.visitLineNumber(line, loopLabel);
try
{
Var.pushThreadBindings(RT.map(LOOP_LABEL, loopLabel,
METHOD, this));
emitBody(objx, gen, retClass, body);

Label end = gen.mark();

gen.visitLocalVariable("this",
"Ljava/lang/Object;", null,
loopLabel, end, 0);
for(ISeq lbs = argLocals.seq();
lbs != null;
lbs = lbs.next())
{
LocalBinding lb = (LocalBinding) lbs.first();
gen.visitLocalVariable(lb.name,
argtypes[lb.idx-1].getDescriptor(), null,
loopLabel, end, lb.idx);
}
}
catch(Exception e)
{
throw new RuntimeException(e);
}
finally
{
Var.popThreadBindings();
}

gen.returnValue();
8.24. COMPILER.JAVA 581

//gen.visitMaxs(1, 1);
gen.endMethod();

//generate the regular invoke, calling the prim method

Method m =
new Method(getMethodName(), OBJECT_TYPE, getArgTypes());

gen = new GeneratorAdapter(ACC_PUBLIC,

m,
null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();
gen.loadThis();
for(int i = 0; i < argtypes.length; i++)
{
gen.loadArg(i);
HostExpr.emitUnboxArg(fn, gen, argclasses[i]);
}
gen.invokeInterface(Type.getType("L"+prim+";"), ms);
gen.box(getReturnType());

gen.returnValue();
//gen.visitMaxs(1, 1);
gen.endMethod();

}
public void doEmit(ObjExpr fn, ClassVisitor cv){
Method m =
new Method(getMethodName(), getReturnType(), getArgTypes());

GeneratorAdapter gen =
new GeneratorAdapter(ACC_PUBLIC,
m,
null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();

Label loopLabel = gen.mark();

gen.visitLineNumber(line, loopLabel);
try
{
Var.pushThreadBindings(
RT.map(LOOP_LABEL, loopLabel, METHOD, this));

body.emit(C.RETURN, fn, gen);

582 CHAPTER 8. JVM/CLOJURE/LANG/

Label end = gen.mark();

gen.visitLocalVariable("this", "Ljava/lang/Object;",
null, loopLabel, end, 0);
for(ISeq lbs = argLocals.seq();
lbs != null;
lbs = lbs.next())
{
LocalBinding lb = (LocalBinding) lbs.first();
gen.visitLocalVariable(lb.name, "Ljava/lang/Object;",
null, loopLabel, end, lb.idx);
}
}
finally
{
Var.popThreadBindings();
}

gen.returnValue();
//gen.visitMaxs(1, 1);
gen.endMethod();
}

public final PersistentVector reqParms(){

return reqParms;
}

public final LocalBinding restParm(){

return restParm;
}

boolean isVariadic(){
return restParm != null;
}

int numParams(){
return reqParms.count() + (isVariadic() ? 1 : 0);
}

String getMethodName(){
return isVariadic()?"doInvoke":"invoke";
}

Type getReturnType(){
if(prim != null) //objx.isStatic)
return Type.getType(retClass);
return OBJECT_TYPE;
}
8.24. COMPILER.JAVA 583

Type[] getArgTypes(){
if(isVariadic() && reqParms.count() == MAX_POSITIONAL_ARITY)
{
Type[] ret = new Type[MAX_POSITIONAL_ARITY + 1];
for(int i = 0;i<MAX_POSITIONAL_ARITY + 1;i++)
ret[i] = OBJECT_TYPE;
return ret;
}
return ARG_TYPES[numParams()];
}

void emitClearLocals(GeneratorAdapter gen){

// for(int i = 1; i < numParams() + 1; i++)
// {
// if(!localsUsedInCatchFinally.contains(i))
// {
// gen.visitInsn(Opcodes.ACONST_NULL);
// gen.visitVarInsn(
// OBJECT_TYPE.getOpcode(Opcodes.ISTORE), i);
// }
// }
// for(int i = numParams() + 1; i < maxLocal + 1; i++)
// {
// if(!localsUsedInCatchFinally.contains(i))
// {
// LocalBinding b =
// (LocalBinding) RT.get(indexlocals, i);
// if(b == null || maybePrimitiveType(b.init) == null)
// {
// gen.visitInsn(Opcodes.ACONST_NULL);
// gen.visitVarInsn(
// OBJECT_TYPE.getOpcode(Opcodes.ISTORE), i);
// }
// }
// }
// if(((FnExpr)objx).onceOnly)
// {
// objx.emitClearCloses(gen);
// }
}
}

abstract public static class ObjMethod{

//when closures are defined inside other closures, the closed
//over locals need to be propagated to the enclosing objx
public final ObjMethod parent;
//localbinding->localbinding
IPersistentMap locals = null;
//num->localbinding
584 CHAPTER 8. JVM/CLOJURE/LANG/

IPersistentMap indexlocals = null;

Expr body = null;
ObjExpr objx;
PersistentVector argLocals;
int maxLocal = 0;
int line;
PersistentHashSet localsUsedInCatchFinally =
PersistentHashSet.EMPTY;
protected IPersistentMap methodMeta;

public final IPersistentMap locals(){

return locals;
}

public final Expr body(){

return body;
}

public final ObjExpr objx(){

return objx;
}

public final PersistentVector argLocals(){

return argLocals;
}

public final int maxLocal(){

return maxLocal;
}

public final int line(){

return line;
}

public ObjMethod(ObjExpr objx, ObjMethod parent){

this.parent = parent;
this.objx = objx;
}

static void emitBody(ObjExpr objx,

GeneratorAdapter gen,
Class retClass,
Expr body)
throws Exception{
MaybePrimitiveExpr be = (MaybePrimitiveExpr) body;
if(Util.isPrimitive(retClass) && be.canEmitPrimitive())
{
Class bc = maybePrimitiveType(be);
if(bc == retClass)
8.24. COMPILER.JAVA 585

be.emitUnboxed(C.RETURN, objx, gen);

else if(retClass == long.class && bc == int.class)
{
be.emitUnboxed(C.RETURN, objx, gen);
gen.visitInsn(I2L);
}
else if(retClass == double.class && bc == float.class)
{
be.emitUnboxed(C.RETURN, objx, gen);
gen.visitInsn(F2D);
}
else if(retClass == int.class && bc == long.class)
{
be.emitUnboxed(C.RETURN, objx, gen);
gen.invokeStatic(RT_TYPE,
Method.getMethod("int intCast(long)"));
}
else if(retClass == float.class && bc == double.class)
{
be.emitUnboxed(C.RETURN, objx, gen);
gen.visitInsn(D2F);
}
else
throw new IllegalArgumentException(
"Mismatched primitive return, expected: "
+ retClass + ", had: " + be.getJavaClass());
}
else
{
body.emit(C.RETURN, objx, gen);
if(retClass == void.class)
{
gen.pop();
}
else
gen.unbox(Type.getType(retClass));
}
}
abstract int numParams();
abstract String getMethodName();
abstract Type getReturnType();
abstract Type[] getArgTypes();

public void emit(ObjExpr fn, ClassVisitor cv){

Method m =
new Method(getMethodName(), getReturnType(), getArgTypes());

GeneratorAdapter gen =
new GeneratorAdapter(ACC_PUBLIC,
m,
586 CHAPTER 8. JVM/CLOJURE/LANG/

null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();

Label loopLabel = gen.mark();

gen.visitLineNumber(line, loopLabel);
try
{
Var.pushThreadBindings(
RT.map(LOOP_LABEL, loopLabel, METHOD, this));

body.emit(C.RETURN, fn, gen);

Label end = gen.mark();
gen.visitLocalVariable("this", "Ljava/lang/Object;",
null, loopLabel, end, 0);
for(ISeq lbs = argLocals.seq();
lbs != null;
lbs = lbs.next())
{
LocalBinding lb = (LocalBinding) lbs.first();
gen.visitLocalVariable(lb.name, "Ljava/lang/Object;",
null, loopLabel, end, lb.idx);
}
}
finally
{
Var.popThreadBindings();
}

gen.returnValue();
//gen.visitMaxs(1, 1);
gen.endMethod();
}

void emitClearLocals(GeneratorAdapter gen){

}

void emitClearLocalsOld(GeneratorAdapter gen){

for(int i=0;i<argLocals.count();i++)
{
LocalBinding lb = (LocalBinding) argLocals.nth(i);
if(!localsUsedInCatchFinally.contains(lb.idx) &&
lb.getPrimitiveType() == null)
{
gen.visitInsn(Opcodes.ACONST_NULL);
gen.storeArg(lb.idx - 1);
}
8.24. COMPILER.JAVA 587

}
// for(int i = 1; i < numParams() + 1; i++)
// {
// if(!localsUsedInCatchFinally.contains(i))
// {
// gen.visitInsn(Opcodes.ACONST_NULL);
// gen.visitVarInsn(
// OBJECT_TYPE.getOpcode(Opcodes.ISTORE), i);
// }
// }
for(int i = numParams() + 1; i < maxLocal + 1; i++)
{
if(!localsUsedInCatchFinally.contains(i))
{
LocalBinding b = (LocalBinding) RT.get(indexlocals, i);
if(b == null || maybePrimitiveType(b.init) == null)
{
gen.visitInsn(Opcodes.ACONST_NULL);
gen.visitVarInsn(
OBJECT_TYPE.getOpcode(Opcodes.ISTORE), i);
}
}
}
}
}

public static class LocalBinding{

public final Symbol sym;
public final Symbol tag;
public Expr init;
public final int idx;
public final String name;
public final boolean isArg;
public final PathNode clearPathRoot;
public boolean canBeCleared = true;
public boolean recurMistmatch = false;

public LocalBinding(int num, Symbol sym, Symbol tag, Expr init,

boolean isArg,PathNode clearPathRoot)
throws Exception{
if(maybePrimitiveType(init) != null && tag != null)
throw new UnsupportedOperationException(
"Can’t type hint a local with a primitive initializer");
this.idx = num;
this.sym = sym;
this.tag = tag;
this.init = init;
this.isArg = isArg;
this.clearPathRoot = clearPathRoot;
name = munge(sym.name);
588 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean hasJavaClass() throws Exception{

if(init != null && init.hasJavaClass()
&& Util.isPrimitive(init.getJavaClass())
&& !(init instanceof MaybePrimitiveExpr))
return false;
return tag != null
|| (init != null && init.hasJavaClass());
}

public Class getJavaClass() throws Exception{

return tag != null ? HostExpr.tagToClass(tag)
: init.getJavaClass();
}

public Class getPrimitiveType(){

return maybePrimitiveType(init);
}
}

public static class LocalBindingExpr

implements Expr, MaybePrimitiveExpr, AssignableExpr{
public final LocalBinding b;
public final Symbol tag;

public final PathNode clearPath;

public final PathNode clearRoot;
public boolean shouldClear = false;

public LocalBindingExpr(LocalBinding b, Symbol tag)

throws Exception{
if(b.getPrimitiveType() != null && tag != null)
throw new UnsupportedOperationException(
"Can’t type hint a primitive local");
this.b = b;
this.tag = tag;

this.clearPath = (PathNode)CLEAR_PATH.get();
this.clearRoot = (PathNode)CLEAR_ROOT.get();
IPersistentCollection sites =
(IPersistentCollection) RT.get(CLEAR_SITES.get(),b);

if(b.idx > 0)
{
// Object dummy;

if(sites != null)
{
8.24. COMPILER.JAVA 589

for(ISeq s = sites.seq();s!=null;s = s.next())

{
LocalBindingExpr o = (LocalBindingExpr) s.first();
PathNode common = commonPath(clearPath,o.clearPath);
if(common != null && common.type == PATHTYPE.PATH)
o.shouldClear = false;
// else
// dummy = null;
}
}

if(clearRoot == b.clearPathRoot)
{
this.shouldClear = true;
sites = RT.conj(sites,this);
CLEAR_SITES.set(RT.assoc(CLEAR_SITES.get(), b, sites));
}
// else
// dummy = null;
}
}

public Object eval() throws Exception{

throw new UnsupportedOperationException("Can’t eval locals");
}

public boolean canEmitPrimitive(){

return b.getPrimitiveType() != null;
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
objx.emitUnboxedLocal(gen, b);
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

if(context != C.STATEMENT)
objx.emitLocal(gen, b, shouldClear);
}

public Object evalAssign(Expr val) throws Exception{

throw new UnsupportedOperationException("Can’t eval locals");
}

public void emitAssign(C context,

ObjExpr objx,
GeneratorAdapter gen,
Expr val){
objx.emitAssignLocal(gen, b,val);
590 CHAPTER 8. JVM/CLOJURE/LANG/

if(context != C.STATEMENT)
objx.emitLocal(gen, b, false);
}

public boolean hasJavaClass() throws Exception{

return tag != null || b.hasJavaClass();
}

public Class getJavaClass() throws Exception{

if(tag != null)
return HostExpr.tagToClass(tag);
return b.getJavaClass();
}

public static class BodyExpr implements Expr, MaybePrimitiveExpr{

PersistentVector exprs;

public final PersistentVector exprs(){

return exprs;
}

public BodyExpr(PersistentVector exprs){

this.exprs = exprs;
}

static class Parser implements IParser{

public Expr parse(C context, Object frms) throws Exception{
ISeq forms = (ISeq) frms;
if(Util.equals(RT.first(forms), DO))
forms = RT.next(forms);
PersistentVector exprs = PersistentVector.EMPTY;
for(; forms != null; forms = forms.next())
{
Expr e = (context != C.EVAL &&
(context == C.STATEMENT ||
forms.next() != null)) ?
analyze(C.STATEMENT, forms.first())
: analyze(context, forms.first());
exprs = exprs.cons(e);
}
if(exprs.count() == 0)
exprs = exprs.cons(NIL_EXPR);
return new BodyExpr(exprs);
}
}

public Object eval() throws Exception{

8.24. COMPILER.JAVA 591

Object ret = null;

for(Object o : exprs)
{
Expr e = (Expr) o;
ret = e.eval();
}
return ret;
}

public boolean canEmitPrimitive(){

return lastExpr() instanceof MaybePrimitiveExpr &&
((MaybePrimitiveExpr)lastExpr()).canEmitPrimitive();
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
for(int i = 0; i < exprs.count() - 1; i++)
{
Expr e = (Expr) exprs.nth(i);
e.emit(C.STATEMENT, objx, gen);
}
MaybePrimitiveExpr last =
(MaybePrimitiveExpr) exprs.nth(exprs.count() - 1);
last.emitUnboxed(context, objx, gen);
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

for(int i = 0; i < exprs.count() - 1; i++)
{
Expr e = (Expr) exprs.nth(i);
e.emit(C.STATEMENT, objx, gen);
}
Expr last = (Expr) exprs.nth(exprs.count() - 1);
last.emit(context, objx, gen);
}

public boolean hasJavaClass() throws Exception{

return lastExpr().hasJavaClass();
}

public Class getJavaClass() throws Exception{

return lastExpr().getJavaClass();
}

private Expr lastExpr(){

return (Expr) exprs.nth(exprs.count() - 1);
}
}
592 CHAPTER 8. JVM/CLOJURE/LANG/

public static class BindingInit{

LocalBinding binding;
Expr init;

public final LocalBinding binding(){

return binding;
}

public final Expr init(){

return init;
}

public BindingInit(LocalBinding binding, Expr init){

this.binding = binding;
this.init = init;
}
}

public static class LetFnExpr implements Expr{

public final PersistentVector bindingInits;
public final Expr body;

public LetFnExpr(PersistentVector bindingInits, Expr body){

this.bindingInits = bindingInits;
this.body = body;
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
ISeq form = (ISeq) frm;
//(letfns* [var (fn [args] body) ...] body...)
if(!(RT.second(form) instanceof IPersistentVector))
throw new IllegalArgumentException(
"Bad binding form, expected vector");

IPersistentVector bindings =
(IPersistentVector) RT.second(form);
if((bindings.count() % 2) != 0)
throw new IllegalArgumentException(
"Bad binding form, expected matched symbol expression pairs");

ISeq body = RT.next(RT.next(form));

if(context == C.EVAL)
return
analyze(context,
RT.list(
RT.list(FN, PersistentVector.EMPTY,
form)));
8.24. COMPILER.JAVA 593

IPersistentMap dynamicBindings =
RT.map(LOCAL_ENV, LOCAL_ENV.deref(),
NEXT_LOCAL_NUM, NEXT_LOCAL_NUM.deref());

try
{
Var.pushThreadBindings(dynamicBindings);

//pre-seed env (like Lisp labels)

PersistentVector lbs = PersistentVector.EMPTY;
for(int i = 0; i < bindings.count(); i += 2)
{
if(!(bindings.nth(i) instanceof Symbol))
throw new IllegalArgumentException(
"Bad binding form, expected symbol, got: " +
bindings.nth(i));
Symbol sym = (Symbol) bindings.nth(i);
if(sym.getNamespace() != null)
throw new Exception(
"Can’t let qualified name: " + sym);
LocalBinding lb =
registerLocal(sym, tagOf(sym), null,false);
lb.canBeCleared = false;
lbs = lbs.cons(lb);
}
PersistentVector bindingInits = PersistentVector.EMPTY;
for(int i = 0; i < bindings.count(); i += 2)
{
Symbol sym = (Symbol) bindings.nth(i);
Expr init =
analyze(C.EXPRESSION, bindings.nth(i + 1),
sym.name);
LocalBinding lb = (LocalBinding) lbs.nth(i / 2);
lb.init = init;
BindingInit bi = new BindingInit(lb, init);
bindingInits = bindingInits.cons(bi);
}
return
new LetFnExpr(bindingInits,
(new BodyExpr.Parser())
.parse(context, body));
}
finally
{
Var.popThreadBindings();
}
}
}

public Object eval() throws Exception{

594 CHAPTER 8. JVM/CLOJURE/LANG/

throw new UnsupportedOperationException("Can’t eval letfns");

}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

for(int i = 0; i < bindingInits.count(); i++)
{
BindingInit bi = (BindingInit) bindingInits.nth(i);
gen.visitInsn(Opcodes.ACONST_NULL);
gen.visitVarInsn(
OBJECT_TYPE.getOpcode(Opcodes.ISTORE), bi.binding.idx);
}

IPersistentSet lbset = PersistentHashSet.EMPTY;

for(int i = 0; i < bindingInits.count(); i++)

{
BindingInit bi = (BindingInit) bindingInits.nth(i);
lbset = (IPersistentSet) lbset.cons(bi.binding);
bi.init.emit(C.EXPRESSION, objx, gen);
gen.visitVarInsn(
OBJECT_TYPE.getOpcode(Opcodes.ISTORE), bi.binding.idx);
}

for(int i = 0; i < bindingInits.count(); i++)

{
BindingInit bi = (BindingInit) bindingInits.nth(i);
ObjExpr fe = (ObjExpr) bi.init;
gen.visitVarInsn(
OBJECT_TYPE.getOpcode(Opcodes.ILOAD), bi.binding.idx);
fe.emitLetFnInits(gen, objx, lbset);
}

Label loopLabel = gen.mark();

body.emit(context, objx, gen);

Label end = gen.mark();

// gen.visitLocalVariable("this", "Ljava/lang/Object;",
// null, loopLabel, end, 0);
for(ISeq bis = bindingInits.seq(); bis != null; bis = bis.next())
{
BindingInit bi = (BindingInit) bis.first();
String lname = bi.binding.name;
if(lname.endsWith("__auto__"))
lname += RT.nextID();
Class primc = maybePrimitiveType(bi.init);
if(primc != null)
gen.visitLocalVariable(lname,
Type.getDescriptor(primc),
null, loopLabel, end,
8.24. COMPILER.JAVA 595

bi.binding.idx);
else
gen.visitLocalVariable(lname, "Ljava/lang/Object;",
null, loopLabel, end,
bi.binding.idx);
}
}

public boolean hasJavaClass() throws Exception{

return body.hasJavaClass();
}

public Class getJavaClass() throws Exception{

return body.getJavaClass();
}
}

public static class LetExpr implements Expr, MaybePrimitiveExpr{

public final PersistentVector bindingInits;
public final Expr body;
public final boolean isLoop;

public LetExpr(PersistentVector bindingInits,

Expr body,
boolean isLoop){
this.bindingInits = bindingInits;
this.body = body;
this.isLoop = isLoop;
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
ISeq form = (ISeq) frm;
//(let [var val var2 val2 ...] body...)
boolean isLoop = RT.first(form).equals(LOOP);
if(!(RT.second(form) instanceof IPersistentVector))
throw new IllegalArgumentException(
"Bad binding form, expected vector");

IPersistentVector bindings =
(IPersistentVector) RT.second(form);
if((bindings.count() % 2) != 0)
throw new IllegalArgumentException(
"Bad binding form, expected matched symbol expression pairs");

ISeq body = RT.next(RT.next(form));

if(context == C.EVAL
|| (context == C.EXPRESSION && isLoop))
return
596 CHAPTER 8. JVM/CLOJURE/LANG/

analyze(context,
RT.list(RT.list(FN, PersistentVector.EMPTY,
form)));

ObjMethod method = (ObjMethod) METHOD.deref();

IPersistentMap backupMethodLocals = method.locals;
IPersistentMap backupMethodIndexLocals =
method.indexlocals;
PersistentVector recurMismatches = null;

// we might repeat once if a loop with a recurMistmatch,

// return breaks
while(true){
IPersistentMap dynamicBindings =
RT.map(LOCAL_ENV, LOCAL_ENV.deref(),
NEXT_LOCAL_NUM, NEXT_LOCAL_NUM.deref());
method.locals = backupMethodLocals;
method.indexlocals = backupMethodIndexLocals;

if(isLoop)
dynamicBindings =
dynamicBindings.assoc(LOOP_LOCALS, null);

try
{
Var.pushThreadBindings(dynamicBindings);

PersistentVector bindingInits =
PersistentVector.EMPTY;
PersistentVector loopLocals =
PersistentVector.EMPTY;
for(int i = 0; i < bindings.count(); i += 2)
{
if(!(bindings.nth(i) instanceof Symbol))
throw new IllegalArgumentException(
"Bad binding form, expected symbol, got: "
+ bindings.nth(i));
Symbol sym = (Symbol) bindings.nth(i);
if(sym.getNamespace() != null)
throw new Exception(
"Can’t let qualified name: " + sym);
Expr init =
analyze(C.EXPRESSION, bindings.nth(i + 1),
sym.name);
if(isLoop)
{
if(recurMismatches != null &&
((LocalBinding)recurMismatches
.nth(i/2)).recurMistmatch)
{
8.24. COMPILER.JAVA 597

init =
new StaticMethodExpr("", 0, null,
RT.class, "box",
RT.vector(init));
if(RT.booleanCast(
RT.WARN_ON_REFLECTION.deref()))
RT.errPrintWriter().println(
"Auto-boxing loop arg: " + sym);
}
else if(maybePrimitiveType(init)==int.class)
init =
new StaticMethodExpr("", 0, null,
RT.class,
"longCast",
RT.vector(init));
else if(maybePrimitiveType(init) ==
float.class)
init =
new StaticMethodExpr("", 0, null,
RT.class,
"doubleCast",
RT.vector(init));
}
//sequential enhancement of env (like Lisp let*)
LocalBinding lb =
registerLocal(sym, tagOf(sym), init,false);
BindingInit bi = new BindingInit(lb, init);
bindingInits = bindingInits.cons(bi);

if(isLoop)
loopLocals = loopLocals.cons(lb);
}
if(isLoop)
LOOP_LOCALS.set(loopLocals);
Expr bodyExpr;
try {
if(isLoop)
{
PathNode root =
new PathNode(PATHTYPE.PATH,
(PathNode) CLEAR_PATH.get());
Var.pushThreadBindings(
RT.map(CLEAR_PATH,
new PathNode(PATHTYPE.PATH,root),
CLEAR_ROOT,
new PathNode(PATHTYPE.PATH,root),
NO_RECUR, null));

}
bodyExpr =
598 CHAPTER 8. JVM/CLOJURE/LANG/

(new BodyExpr.Parser())
.parse(isLoop
? C.RETURN
: context, body);
}
finally{
if(isLoop)
{
Var.popThreadBindings();
recurMismatches = null;
for(int i = 0;i< loopLocals.count();i++)
{
LocalBinding lb =
(LocalBinding) loopLocals.nth(i);
if(lb.recurMistmatch)
recurMismatches = loopLocals;
}
}
}
if(recurMismatches == null)
return
new LetExpr(bindingInits, bodyExpr, isLoop);
}
finally
{
Var.popThreadBindings();
}
}
}
}

public Object eval() throws Exception{

throw new UnsupportedOperationException(
"Can’t eval let/loop");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

doEmit(context, objx, gen, false);
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
doEmit(context, objx, gen, true);
}

public void doEmit(C context,

ObjExpr objx,
GeneratorAdapter gen,
8.24. COMPILER.JAVA 599

boolean emitUnboxed){
for(int i = 0; i < bindingInits.count(); i++)
{
BindingInit bi = (BindingInit) bindingInits.nth(i);
Class primc = maybePrimitiveType(bi.init);
if(primc != null)
{
((MaybePrimitiveExpr) bi.init)
.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitVarInsn(
Type.getType(primc)
.getOpcode(Opcodes.ISTORE),
bi.binding.idx);
}
else
{
bi.init.emit(C.EXPRESSION, objx, gen);
gen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ISTORE),
bi.binding.idx);
}
}
Label loopLabel = gen.mark();
if(isLoop)
{
try
{
Var.pushThreadBindings(RT.map(LOOP_LABEL, loopLabel));
if(emitUnboxed)
((MaybePrimitiveExpr)body)
.emitUnboxed(context, objx, gen);
else
body.emit(context, objx, gen);
}
finally
{
Var.popThreadBindings();
}
}
else
{
if(emitUnboxed)
((MaybePrimitiveExpr)body)
.emitUnboxed(context, objx, gen);
else
body.emit(context, objx, gen);
}
Label end = gen.mark();
// gen.visitLocalVariable("this", "Ljava/lang/Object;",
// null, loopLabel, end, 0);
for(ISeq bis = bindingInits.seq();
600 CHAPTER 8. JVM/CLOJURE/LANG/

bis != null;
bis = bis.next())
{
BindingInit bi = (BindingInit) bis.first();
String lname = bi.binding.name;
if(lname.endsWith("__auto__"))
lname += RT.nextID();
Class primc = maybePrimitiveType(bi.init);
if(primc != null)
gen.visitLocalVariable(lname,
Type.getDescriptor(primc),
null, loopLabel, end,
bi.binding.idx);
else
gen.visitLocalVariable(lname, "Ljava/lang/Object;",
null, loopLabel, end,
bi.binding.idx);
}
}

public boolean hasJavaClass() throws Exception{

return body.hasJavaClass();
}

public Class getJavaClass() throws Exception{

return body.getJavaClass();
}

public boolean canEmitPrimitive(){

return body instanceof MaybePrimitiveExpr &&
((MaybePrimitiveExpr)body).canEmitPrimitive();
}

public static class RecurExpr implements Expr{

public final IPersistentVector args;
public final IPersistentVector loopLocals;
final int line;
final String source;

public RecurExpr(IPersistentVector loopLocals,

IPersistentVector args, int line, String source){
this.loopLocals = loopLocals;
this.args = args;
this.line = line;
this.source = source;
}
8.24. COMPILER.JAVA 601

public Object eval() throws Exception{

throw new UnsupportedOperationException("Can’t eval recur");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

Label loopLabel = (Label) LOOP_LABEL.deref();
if(loopLabel == null)
throw new IllegalStateException();
for(int i = 0; i < loopLocals.count(); i++)
{
LocalBinding lb = (LocalBinding) loopLocals.nth(i);
Expr arg = (Expr) args.nth(i);
if(lb.getPrimitiveType() != null)
{
Class primc = lb.getPrimitiveType();
try
{
final Class pc = maybePrimitiveType(arg);
if(pc == primc)
((MaybePrimitiveExpr) arg)
.emitUnboxed(C.EXPRESSION, objx, gen);
else if(primc == long.class && pc == int.class)
{
((MaybePrimitiveExpr) arg)
.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitInsn(I2L);
}
else if(primc == double.class && pc == float.class)
{
((MaybePrimitiveExpr) arg)
.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitInsn(F2D);
}
else if(primc == int.class && pc == long.class)
{
((MaybePrimitiveExpr) arg)
.emitUnboxed(C.EXPRESSION, objx, gen);
gen.invokeStatic(RT_TYPE,
Method.getMethod("int intCast(long)"));
}
else if(primc == float.class && pc == double.class)
{
((MaybePrimitiveExpr) arg)
.emitUnboxed(C.EXPRESSION, objx, gen);
gen.visitInsn(D2F);
}
else
{
//RT.booleanCast(RT.WARN_ON_REFLECTION.deref()))
// if(true)
602 CHAPTER 8. JVM/CLOJURE/LANG/

throw new IllegalArgumentException

// RT.errPrintWriter().println
(//source + ":" + line +
" recur arg for primitive local: " +
lb.name +
" is not matching primitive, had: " +
(arg.hasJavaClass()
? arg.getJavaClass().getName()
:"Object") +
", needed: " +
primc.getName());
// arg.emit(C.EXPRESSION, objx, gen);
// HostExpr.emitUnboxArg(objx,gen,primc);
}
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}
else
{
arg.emit(C.EXPRESSION, objx, gen);
}
}

for(int i = loopLocals.count() - 1; i >= 0; i--)

{
LocalBinding lb = (LocalBinding) loopLocals.nth(i);
Class primc = lb.getPrimitiveType();
if(lb.isArg)
gen.storeArg(lb.idx-(objx.isStatic?0:1));
else
{
if(primc != null)
gen.visitVarInsn(
Type.getType(primc)
.getOpcode(Opcodes.ISTORE), lb.idx);
else
gen.visitVarInsn(
OBJECT_TYPE
.getOpcode(Opcodes.ISTORE), lb.idx);
}
}

gen.goTo(loopLabel);
}

public boolean hasJavaClass() throws Exception{

return true;
8.24. COMPILER.JAVA 603

public Class getJavaClass() throws Exception{

return null;
}

static class Parser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
int line = (Integer) LINE.deref();
String source = (String) SOURCE.deref();

ISeq form = (ISeq) frm;

IPersistentVector loopLocals =
(IPersistentVector) LOOP_LOCALS.deref();
if(context != C.RETURN || loopLocals == null)
throw new UnsupportedOperationException(
"Can only recur from tail position");
if(IN_CATCH_FINALLY.deref() != null)
throw new UnsupportedOperationException(
"Cannot recur from catch/finally");
if(NO_RECUR.deref() != null)
throw new UnsupportedOperationException(
"Cannot recur across try");
PersistentVector args = PersistentVector.EMPTY;
for(ISeq s = RT.seq(form.next()); s != null; s = s.next())
{
args = args.cons(analyze(C.EXPRESSION, s.first()));
}
if(args.count() != loopLocals.count())
throw new IllegalArgumentException(
String.format(
"Mismatched argument count to recur, expected: %d args, got: %d",
loopLocals.count(), args.count()));
for(int i = 0;i< loopLocals.count();i++)
{
LocalBinding lb = (LocalBinding) loopLocals.nth(i);
Class primc = lb.getPrimitiveType();
if(primc != null)
{
boolean mismatch = false;
final Class pc =
maybePrimitiveType((Expr) args.nth(i));
if(primc == long.class)
{
if(!(pc == long.class
|| pc == int.class
|| pc == short.class
|| pc == char.class
|| pc == byte.class))
mismatch = true;
604 CHAPTER 8. JVM/CLOJURE/LANG/

}
else if(primc == double.class)
{
if(!(pc == double.class
|| pc == float.class))
mismatch = true;
}
if(mismatch)
{
lb.recurMistmatch = true;
if(RT.booleanCast(RT.WARN_ON_REFLECTION.deref()))
RT.errPrintWriter().println
(source + ":" + line +
" recur arg for primitive local: " +
lb.name +
" is not matching primitive, had: " +
(pc != null ? pc.getName():"Object") +
", needed: " +
primc.getName());
}
}
}
return new RecurExpr(loopLocals, args, line, source);
}
}
}

private static LocalBinding registerLocal(Symbol sym,

Symbol tag,
Expr init,
boolean isArg)
throws Exception{
int num = getAndIncLocalNum();
LocalBinding b =
new LocalBinding(num, sym, tag, init, isArg, clearPathRoot());
IPersistentMap localsMap = (IPersistentMap) LOCAL_ENV.deref();
LOCAL_ENV.set(RT.assoc(localsMap, b.sym, b));
ObjMethod method = (ObjMethod) METHOD.deref();
method.locals = (IPersistentMap) RT.assoc(method.locals, b, b);
method.indexlocals =
(IPersistentMap) RT.assoc(method.indexlocals, num, b);
return b;
}

private static int getAndIncLocalNum(){

int num = ((Number) NEXT_LOCAL_NUM.deref()).intValue();
ObjMethod m = (ObjMethod) METHOD.deref();
if(num > m.maxLocal)
m.maxLocal = num;
NEXT_LOCAL_NUM.set(num + 1);
8.24. COMPILER.JAVA 605

return num;
}

public static Expr analyze(C context, Object form) throws Exception{

return analyze(context, form, null);
}

private static Expr analyze(C context,

Object form,
String name)
throws Exception{
//todo symbol macro expansion?
try
{
if(form instanceof LazySeq)
{
form = RT.seq(form);
if(form == null)
form = PersistentList.EMPTY;
}
if(form == null)
return NIL_EXPR;
else if(form == Boolean.TRUE)
return TRUE_EXPR;
else if(form == Boolean.FALSE)
return FALSE_EXPR;
Class fclass = form.getClass();
if(fclass == Symbol.class)
return analyzeSymbol((Symbol) form);
else if(fclass == Keyword.class)
return registerKeyword((Keyword) form);
else if(form instanceof Number)
return NumberExpr.parse((Number) form);
else if(fclass == String.class)
return new StringExpr(((String) form).intern());
// else if(fclass == Character.class)
// return new CharExpr((Character) form);
else if(form instanceof IPersistentCollection &&
((IPersistentCollection) form).count() == 0)
{
Expr ret = new EmptyExpr(form);
if(RT.meta(form) != null)
ret = new MetaExpr(ret, MapExpr
.parse(context == C.EVAL
? context
: C.EXPRESSION,
((IObj) form).meta()));
return ret;
}
else if(form instanceof ISeq)
606 CHAPTER 8. JVM/CLOJURE/LANG/

return analyzeSeq(context, (ISeq) form, name);

else if(form instanceof IPersistentVector)
return VectorExpr.parse(context,
(IPersistentVector) form);
else if(form instanceof IPersistentMap)
return MapExpr.parse(context, (IPersistentMap) form);
else if(form instanceof IPersistentSet)
return SetExpr.parse(context, (IPersistentSet) form);

// else
//throw new UnsupportedOperationException();
return new ConstantExpr(form);
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(
(String) SOURCE_PATH.deref(), (Integer) LINE.deref(), e);
else
throw (CompilerException) e;
}
}

static public class CompilerException extends Exception{

final public String source;

public CompilerException(String source, int line, Throwable cause){

super(errorMsg(source, line, cause.toString()), cause);
this.source = source;
}

public String toString(){

return getMessage();
}
}

static public Var isMacro(Object op) throws Exception{

//no local macros for now
if(op instanceof Symbol && referenceLocal((Symbol) op) != null)
return null;
if(op instanceof Symbol || op instanceof Var)
{
Var v = (op instanceof Var)
? (Var) op
: lookupVar((Symbol) op, false);
if(v != null && v.isMacro())
{
if(v.ns != currentNS() && !v.isPublic())
throw new IllegalStateException(
"var: " + v + " is not public");
8.24. COMPILER.JAVA 607

return v;
}
}
return null;
}

static public IFn isInline(Object op, int arity) throws Exception{

//no local inlines for now
if(op instanceof Symbol && referenceLocal((Symbol) op) != null)
return null;
if(op instanceof Symbol || op instanceof Var)
{
Var v = (op instanceof Var)
? (Var) op
: lookupVar((Symbol) op, false);
if(v != null)
{
if(v.ns != currentNS() && !v.isPublic())
throw new IllegalStateException(
"var: " + v + " is not public");
IFn ret = (IFn) RT.get(v.meta(), inlineKey);
if(ret != null)
{
IFn arityPred = (IFn) RT.get(v.meta(), inlineAritiesKey);
if(arityPred == null ||
RT.booleanCast(arityPred.invoke(arity)))
return ret;
}
}
}
return null;
}

public static boolean namesStaticMember(Symbol sym){

return sym.ns != null && namespaceFor(sym) == null;
}

public static Object preserveTag(ISeq src, Object dst) {

Symbol tag = tagOf(src);
if (tag != null && dst instanceof IObj) {
IPersistentMap meta = RT.meta(dst);
return ((IObj) dst)
.withMeta(
(IPersistentMap) RT.assoc(meta, RT.TAG_KEY, tag));
}
return dst;
}

public static Object macroexpand1(Object x) throws Exception{

if(x instanceof ISeq)
608 CHAPTER 8. JVM/CLOJURE/LANG/

{
ISeq form = (ISeq) x;
Object op = RT.first(form);
if(isSpecial(op))
return x;
//macro expansion
Var v = isMacro(op);
if(v != null)
{
try
{
return
v.applyTo(
RT.cons(
form,
RT.cons(LOCAL_ENV.get(),form.next())));
}
catch(ArityException e)
{
// hide the 2 extra params for a macro
throw new ArityException(e.actual - 2, e.name);
}
}
else
{
if(op instanceof Symbol)
{
Symbol sym = (Symbol) op;
String sname = sym.name;
//(.substring s 2 5) => (. s substring 2 5)
if(sym.name.charAt(0) == ’.’)
{
if(RT.length(form) < 2)
throw new IllegalArgumentException(
"Malformed member expression, expecting (.member target ...)");
Symbol meth = Symbol.intern(sname.substring(1));
Object target = RT.second(form);
if(HostExpr.maybeClass(target, false) != null)
{
target =
((IObj)RT.list(IDENTITY, target))
.withMeta(RT.map(RT.TAG_KEY,CLASS));
}
return
preserveTag(form,
RT.listStar(DOT,
target,
meth,
form.next().next()));
}
8.24. COMPILER.JAVA 609

else if(namesStaticMember(sym))
{
Symbol target = Symbol.intern(sym.ns);
Class c = HostExpr.maybeClass(target, false);
if(c != null)
{
Symbol meth = Symbol.intern(sym.name);
return
preserveTag(form,
RT.listStar(DOT,
target,
meth,
form.next()));
}
}
else
{
//(s.substring 2 5) => (. s substring 2 5)
//also (package.class.name ...) (. package.class name ...)
int idx = sname.lastIndexOf(’.’);
// if(idx > 0 && idx < sname.length() - 1)
// {
// Symbol target = Symbol.intern(sname.substring(0, idx));
// Symbol meth = Symbol.intern(sname.substring(idx + 1));
// return RT.listStar(DOT, target, meth, form.rest());
// }
//(StringBuilder. "foo") => (new StringBuilder "foo")
//else
if(idx == sname.length() - 1)
return
RT.listStar(NEW,
Symbol.intern(sname.substring(0, idx)),
form.next());
}
}
}
}
return x;
}

static Object macroexpand(Object form) throws Exception{

Object exf = macroexpand1(form);
if(exf != form)
return macroexpand(exf);
return form;
}

private static Expr analyzeSeq(C context,

ISeq form,
String name)
610 CHAPTER 8. JVM/CLOJURE/LANG/

throws Exception{
Integer line = (Integer) LINE.deref();
if(RT.meta(form) != null && RT.meta(form).containsKey(RT.LINE_KEY))
line = (Integer) RT.meta(form).valAt(RT.LINE_KEY);
Var.pushThreadBindings(
RT.map(LINE, line));
try
{
Object me = macroexpand1(form);
if(me != form)
return analyze(context, me, name);

Object op = RT.first(form);
if(op == null)
throw new IllegalArgumentException("Can’t call nil");
IFn inline = isInline(op, RT.count(RT.next(form)));
if(inline != null)
return
analyze(context,
preserveTag(form, inline.applyTo(RT.next(form))));
IParser p;
if(op.equals(FN))
return FnExpr.parse(context, form, name);
else if((p = (IParser) specials.valAt(op)) != null)
return p.parse(context, form);
else
return InvokeExpr.parse(context, form);
}
catch(Throwable e)
{
if(!(e instanceof CompilerException))
throw new CompilerException(
(String) SOURCE_PATH.deref(), (Integer) LINE.deref(), e);
else
throw (CompilerException) e;
}
finally
{
Var.popThreadBindings();
}
}

static String errorMsg(String source, int line, String s){

return String.format("%s, compiling:(%s:%d)", s, source, line);
}

public static Object eval(Object form) throws Exception{

return eval(form, true);
}
8.24. COMPILER.JAVA 611

public static Object eval(Object form, boolean freshLoader)

throws Exception{
boolean createdLoader = false;
if(true)//!LOADER.isBound())
{
Var.pushThreadBindings(RT.map(LOADER, RT.makeClassLoader()));
createdLoader = true;
}
try
{
Integer line = (Integer) LINE.deref();
if(RT.meta(form) != null &&
RT.meta(form).containsKey(RT.LINE_KEY))
line = (Integer) RT.meta(form).valAt(RT.LINE_KEY);
Var.pushThreadBindings(RT.map(LINE, line));
try
{
form = macroexpand(form);
if(form instanceof IPersistentCollection &&
Util.equals(RT.first(form), DO))
{
ISeq s = RT.next(form);
for(; RT.next(s) != null; s = RT.next(s))
eval(RT.first(s), false);
return eval(RT.first(s), false);
}
else if(form instanceof IPersistentCollection
&& !(RT.first(form) instanceof Symbol
&& ((Symbol) RT.first(form)).name
.startsWith("def")))
{
ObjExpr fexpr =
(ObjExpr) analyze(C.EXPRESSION,
RT.list(FN, PersistentVector.EMPTY, form),
"eval" + RT.nextID());
IFn fn = (IFn) fexpr.eval();
return fn.invoke();
}
else
{
Expr expr = analyze(C.EVAL, form);
return expr.eval();
}
}
catch(Throwable e)
{
if(!(e instanceof Exception))
throw new RuntimeException(e);
throw (Exception)e;
}
612 CHAPTER 8. JVM/CLOJURE/LANG/

finally
{
Var.popThreadBindings();
}
}

finally
{
if(createdLoader)
Var.popThreadBindings();
}
}

private static int registerConstant(Object o){

if(!CONSTANTS.isBound())
return -1;
PersistentVector v = (PersistentVector) CONSTANTS.deref();
IdentityHashMap<Object,Integer> ids =
(IdentityHashMap<Object,Integer>) CONSTANT_IDS.deref();
Integer i = ids.get(o);
if(i != null)
return i;
CONSTANTS.set(RT.conj(v, o));
ids.put(o, v.count());
return v.count();
}

private static KeywordExpr registerKeyword(Keyword keyword){

if(!KEYWORDS.isBound())
return new KeywordExpr(keyword);

IPersistentMap keywordsMap = (IPersistentMap) KEYWORDS.deref();

Object id = RT.get(keywordsMap, keyword);
if(id == null)
{
KEYWORDS.set(RT.assoc(keywordsMap,
keyword,
registerConstant(keyword)));
}
return new KeywordExpr(keyword);
// KeywordExpr ke = (KeywordExpr) RT.get(keywordsMap, keyword);
// if(ke == null)
// KEYWORDS.set(
// RT.assoc(keywordsMap, keyword,
// ke = new KeywordExpr(keyword)));
// return ke;
}

private static int registerKeywordCallsite(Keyword keyword){

if(!KEYWORD_CALLSITES.isBound())
8.24. COMPILER.JAVA 613

throw new IllegalAccessError("KEYWORD_CALLSITES is not bound");

IPersistentVector keywordCallsites =
(IPersistentVector) KEYWORD_CALLSITES.deref();

keywordCallsites = keywordCallsites.cons(keyword);
KEYWORD_CALLSITES.set(keywordCallsites);
return keywordCallsites.count()-1;
}

private static int registerProtocolCallsite(Var v){

if(!PROTOCOL_CALLSITES.isBound())
throw new IllegalAccessError("PROTOCOL_CALLSITES is not bound");

IPersistentVector protocolCallsites =
(IPersistentVector) PROTOCOL_CALLSITES.deref();

protocolCallsites = protocolCallsites.cons(v);
PROTOCOL_CALLSITES.set(protocolCallsites);
return protocolCallsites.count()-1;
}

private static void registerVarCallsite(Var v){

if(!VAR_CALLSITES.isBound())
throw new IllegalAccessError("VAR_CALLSITES is not bound");

IPersistentCollection varCallsites =
(IPersistentCollection) VAR_CALLSITES.deref();

varCallsites = varCallsites.cons(v);
VAR_CALLSITES.set(varCallsites);
// return varCallsites.count()-1;
}

static ISeq fwdPath(PathNode p1){

ISeq ret = null;
for(;p1 != null;p1 = p1.parent)
ret = RT.cons(p1,ret);
return ret;
}

static PathNode commonPath(PathNode n1, PathNode n2){

ISeq xp = fwdPath(n1);
ISeq yp = fwdPath(n2);
if(RT.first(xp) != RT.first(yp))
return null;
while(RT.second(xp) != null && RT.second(xp) == RT.second(yp))
{
xp = xp.next();
yp = yp.next();
614 CHAPTER 8. JVM/CLOJURE/LANG/

}
return (PathNode) RT.first(xp);
}

static void addAnnotation(Object visitor, IPersistentMap meta){

try{
if(meta != null && ADD_ANNOTATIONS.isBound())
ADD_ANNOTATIONS.invoke(visitor, meta);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}

static void addParameterAnnotation(Object visitor,

IPersistentMap meta,
int i){
try{
if(meta != null && ADD_ANNOTATIONS.isBound())
ADD_ANNOTATIONS.invoke(visitor, meta, i);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}

private static Expr analyzeSymbol(Symbol sym) throws Exception{

Symbol tag = tagOf(sym);
if(sym.ns == null) //ns-qualified syms are always Vars
{
LocalBinding b = referenceLocal(sym);
if(b != null)
{
return new LocalBindingExpr(b, tag);
}
}
else
{
if(namespaceFor(sym) == null)
{
Symbol nsSym = Symbol.intern(sym.ns);
Class c = HostExpr.maybeClass(nsSym, false);
if(c != null)
{
if(Reflector.getField(c, sym.name, true) != null)
return new StaticFieldExpr(
(Integer) LINE.deref(), c, sym.name, tag);
throw new Exception(
8.24. COMPILER.JAVA 615

"Unable to find static field: " + sym.name + " in " + c);

}
}
}
//Var v = lookupVar(sym, false);
// Var v = lookupVar(sym, false);
// if(v != null)
// return new VarExpr(v, tag);
Object o = resolve(sym);
if(o instanceof Var)
{
Var v = (Var) o;
if(isMacro(v) != null)
throw new Exception("Can’t take value of a macro: " + v);
registerVar(v);
return new VarExpr(v, tag);
}
else if(o instanceof Class)
return new ConstantExpr(o);
else if(o instanceof Symbol)
return new UnresolvedVarExpr((Symbol) o);

throw new Exception(

"Unable to resolve symbol: " + sym + " in this context");

static String destubClassName(String className){

//skip over prefix + ’.’ or ’/’
if(className.startsWith(COMPILE_STUB_PREFIX))
return className.substring(COMPILE_STUB_PREFIX.length()+1);
return className;
}

static Type getType(Class c){

String descriptor = Type.getType(c).getDescriptor();
if(descriptor.startsWith("L"))
descriptor = "L" + destubClassName(descriptor.substring(1));
return Type.getType(descriptor);
}

static Object resolve(Symbol sym, boolean allowPrivate)

throws Exception{
return resolveIn(currentNS(), sym, allowPrivate);
}

static Object resolve(Symbol sym) throws Exception{

return resolveIn(currentNS(), sym, false);
}
616 CHAPTER 8. JVM/CLOJURE/LANG/

static Namespace namespaceFor(Symbol sym){

return namespaceFor(currentNS(), sym);
}

static Namespace namespaceFor(Namespace inns, Symbol sym){

//note, presumes non-nil sym.ns
// first check against currentNS’ aliases...
Symbol nsSym = Symbol.intern(sym.ns);
Namespace ns = inns.lookupAlias(nsSym);
if(ns == null)
{
// ...otherwise check the Namespaces map.
ns = Namespace.find(nsSym);
}
return ns;
}

static public Object resolveIn(Namespace n,

Symbol sym,
boolean allowPrivate)
throws Exception{
//note - ns-qualified vars must already exist
if(sym.ns != null)
{
Namespace ns = namespaceFor(n, sym);
if(ns == null)
throw new Exception("No such namespace: " + sym.ns);

Var v = ns.findInternedVar(Symbol.intern(sym.name));
if(v == null)
throw new Exception("No such var: " + sym);
else if(v.ns != currentNS() && !v.isPublic() && !allowPrivate)
throw new IllegalStateException(
"var: " + sym + " is not public");
return v;
}
else if(sym.name.indexOf(’.’) > 0 || sym.name.charAt(0) == ’[’)
{
return RT.classForName(sym.name);
}
else if(sym.equals(NS))
return RT.NS_VAR;
else if(sym.equals(IN_NS))
return RT.IN_NS_VAR;
else
{
if(Util.equals(sym, COMPILE_STUB_SYM.get()))
return COMPILE_STUB_CLASS.get();
Object o = n.getMapping(sym);
if(o == null)
8.24. COMPILER.JAVA 617

{
if(RT.booleanCast(RT.ALLOW_UNRESOLVED_VARS.deref()))
{
return sym;
}
else
{
throw new Exception(
"Unable to resolve symbol: " + sym +
" in this context");
}
}
return o;
}
}

static public Object maybeResolveIn(Namespace n, Symbol sym)

throws Exception{
//note - ns-qualified vars must already exist
if(sym.ns != null)
{
Namespace ns = namespaceFor(n, sym);
if(ns == null)
return null;
Var v = ns.findInternedVar(Symbol.intern(sym.name));
if(v == null)
return null;
return v;
}
else if(sym.name.indexOf(’.’) > 0 && !sym.name.endsWith(".")
|| sym.name.charAt(0) == ’[’)
{
return RT.classForName(sym.name);
}
else if(sym.equals(NS))
return RT.NS_VAR;
else if(sym.equals(IN_NS))
return RT.IN_NS_VAR;
else
{
Object o = n.getMapping(sym);
return o;
}
}

static Var lookupVar(Symbol sym, boolean internNew) throws Exception{

Var var = null;
618 CHAPTER 8. JVM/CLOJURE/LANG/

//note - ns-qualified vars in other namespaces must already exist

if(sym.ns != null)
{
Namespace ns = namespaceFor(sym);
if(ns == null)
return null;
//throw new Exception("No such namespace: " + sym.ns);
Symbol name = Symbol.intern(sym.name);
if(internNew && ns == currentNS())
var = currentNS().intern(name);
else
var = ns.findInternedVar(name);
}
else if(sym.equals(NS))
var = RT.NS_VAR;
else if(sym.equals(IN_NS))
var = RT.IN_NS_VAR;
else
{
//is it mapped?
Object o = currentNS().getMapping(sym);
if(o == null)
{
//introduce a new var in the current ns
if(internNew)
var = currentNS().intern(Symbol.intern(sym.name));
}
else if(o instanceof Var)
{
var = (Var) o;
}
else
{
throw new Exception(
"Expecting var, but " + sym + " is mapped to " + o);
}
}
if(var != null)
registerVar(var);
return var;
}

private static void registerVar(Var var) throws Exception{

if(!VARS.isBound())
return;
IPersistentMap varsMap = (IPersistentMap) VARS.deref();
Object id = RT.get(varsMap, var);
if(id == null)
{
VARS.set(RT.assoc(varsMap, var, registerConstant(var)));
8.24. COMPILER.JAVA 619

}
// if(varsMap != null && RT.get(varsMap, var) == null)
// VARS.set(RT.assoc(varsMap, var, var));
}

static Namespace currentNS(){

return (Namespace) RT.CURRENT_NS.deref();
}

static void closeOver(LocalBinding b, ObjMethod method){

if(b != null && method != null)
{
if(RT.get(method.locals, b) == null)
{
method.objx.closes =
(IPersistentMap) RT.assoc(method.objx.closes, b, b);
closeOver(b, method.parent);
}
else if(IN_CATCH_FINALLY.deref() != null)
{
method.localsUsedInCatchFinally =
(PersistentHashSet)
method.localsUsedInCatchFinally.cons(b.idx);
}
}
}

static LocalBinding referenceLocal(Symbol sym) throws Exception{

if(!LOCAL_ENV.isBound())
return null;
LocalBinding b = (LocalBinding) RT.get(LOCAL_ENV.deref(), sym);
if(b != null)
{
ObjMethod method = (ObjMethod) METHOD.deref();
closeOver(b, method);
}
return b;
}

private static Symbol tagOf(Object o){

Object tag = RT.get(RT.meta(o), RT.TAG_KEY);
if(tag instanceof Symbol)
return (Symbol) tag;
else if(tag instanceof String)
return Symbol.intern(null, (String) tag);
return null;
}

public static Object loadFile(String file) throws Exception{

620 CHAPTER 8. JVM/CLOJURE/LANG/

// File fo = new File(file);

// if(!fo.exists())
// return null;

FileInputStream f = new FileInputStream(file);

try
{
return load(new InputStreamReader(f, RT.UTF8),
new File(file).getAbsolutePath(),
(new File(file)).getName());
}
finally
{
f.close();
}
}

public static Object load(Reader rdr) throws Exception{

return load(rdr, null, "NO_SOURCE_FILE");
}

public static Object load(Reader rdr,

String sourcePath,
String sourceName)
throws Exception{
Object EOF = new Object();
Object ret = null;
LineNumberingPushbackReader pushbackReader =
(rdr instanceof LineNumberingPushbackReader)
? (LineNumberingPushbackReader) rdr
: new LineNumberingPushbackReader(rdr);
Var.pushThreadBindings(
RT.map(LOADER, RT.makeClassLoader(),
SOURCE_PATH, sourcePath,
SOURCE, sourceName,
METHOD, null,
LOCAL_ENV, null,
LOOP_LOCALS, null,
NEXT_LOCAL_NUM, 0,
RT.CURRENT_NS, RT.CURRENT_NS.deref(),
LINE_BEFORE, pushbackReader.getLineNumber(),
LINE_AFTER, pushbackReader.getLineNumber()
,UNCHECKED_MATH, UNCHECKED_MATH.deref()
,RT.WARN_ON_REFLECTION, RT.WARN_ON_REFLECTION.deref()
));

try
{
for(Object r =
LispReader.read(pushbackReader, false, EOF, false); r != EOF;
8.24. COMPILER.JAVA 621

r = LispReader.read(pushbackReader, false, EOF, false))

{
LINE_AFTER.set(pushbackReader.getLineNumber());
ret = eval(r,false);
LINE_BEFORE.set(pushbackReader.getLineNumber());
}
}
catch(LispReader.ReaderException e)
{
throw new CompilerException(sourcePath, e.line, e.getCause());
}
finally
{
Var.popThreadBindings();
}
return ret;
}

static public void writeClassFile(String internalName,

byte[] bytecode)
throws Exception{
String genPath = (String) COMPILE_PATH.deref();
if(genPath == null)
throw new Exception("*compile-path* not set");
String[] dirs = internalName.split("/");
String p = genPath;
for(int i = 0; i < dirs.length - 1; i++)
{
p += File.separator + dirs[i];
(new File(p)).mkdir();
}
String path = genPath + File.separator + internalName + ".class";
File cf = new File(path);
cf.createNewFile();
FileOutputStream cfs = new FileOutputStream(cf);
try
{
cfs.write(bytecode);
cfs.flush();
cfs.getFD().sync();
}
finally
{
cfs.close();
}
}

public static void pushNS(){

Var.pushThreadBindings(
PersistentHashMap.create(
622 CHAPTER 8. JVM/CLOJURE/LANG/

Var.intern(
Symbol.intern("clojure.core"),
Symbol.intern("*ns*")).setDynamic(), null));
}

public static ILookupThunk getLookupThunk(Object target, Keyword k){

//To change body of created methods use File | Settings | File Templates.
return null;
}

static void compile1(GeneratorAdapter gen,

ObjExpr objx,
Object form)
throws Exception{
Integer line = (Integer) LINE.deref();
if(RT.meta(form) != null && RT.meta(form).containsKey(RT.LINE_KEY))
line = (Integer) RT.meta(form).valAt(RT.LINE_KEY);
Var.pushThreadBindings(
RT.map(LINE, line
,LOADER, RT.makeClassLoader()
));
try
{
form = macroexpand(form);
if(form instanceof IPersistentCollection &&
Util.equals(RT.first(form), DO))
{
for(ISeq s = RT.next(form); s != null; s = RT.next(s))
{
compile1(gen, objx, RT.first(s));
}
}
else
{
Expr expr = analyze(C.EVAL, form);
objx.keywords = (IPersistentMap) KEYWORDS.deref();
objx.vars = (IPersistentMap) VARS.deref();
objx.constants = (PersistentVector) CONSTANTS.deref();
expr.emit(C.EXPRESSION, objx, gen);
expr.eval();
}
}
finally
{
Var.popThreadBindings();
}
}

public static Object compile(Reader rdr,

String sourcePath,
8.24. COMPILER.JAVA 623

String sourceName)
throws Exception{
if(COMPILE_PATH.deref() == null)
throw new Exception("*compile-path* not set");

Object EOF = new Object();

Object ret = null;
LineNumberingPushbackReader pushbackReader =
(rdr instanceof LineNumberingPushbackReader)
? (LineNumberingPushbackReader) rdr
: new LineNumberingPushbackReader(rdr);
Var.pushThreadBindings(
RT.map(SOURCE_PATH, sourcePath,
SOURCE, sourceName,
METHOD, null,
LOCAL_ENV, null,
LOOP_LOCALS, null,
NEXT_LOCAL_NUM, 0,
RT.CURRENT_NS, RT.CURRENT_NS.deref(),
LINE_BEFORE, pushbackReader.getLineNumber(),
LINE_AFTER, pushbackReader.getLineNumber(),
CONSTANTS, PersistentVector.EMPTY,
CONSTANT_IDS, new IdentityHashMap(),
KEYWORDS, PersistentHashMap.EMPTY,
VARS, PersistentHashMap.EMPTY
,UNCHECKED_MATH, UNCHECKED_MATH.deref()
,RT.WARN_ON_REFLECTION, RT.WARN_ON_REFLECTION.deref()
// ,LOADER, RT.makeClassLoader()
));

try
{
//generate loader class
ObjExpr objx = new ObjExpr(null);
objx.internalName =
sourcePath.replace(File.separator, "/")
.substring(0, sourcePath.lastIndexOf(’.’))
+ RT.LOADER_SUFFIX;

objx.objtype = Type.getObjectType(objx.internalName);
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisitor cv = cw;
cv.visit(V1_5, ACC_PUBLIC + ACC_SUPER,
objx.internalName, null,
"java/lang/Object", null);

//static load method

GeneratorAdapter gen =
new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC,
Method.getMethod("void load ()"),
624 CHAPTER 8. JVM/CLOJURE/LANG/

null,
null,
cv);
gen.visitCode();

for(Object r =
LispReader.read(pushbackReader, false, EOF, false);
r != EOF;
r = LispReader.read(pushbackReader, false, EOF, false))
{
LINE_AFTER.set(pushbackReader.getLineNumber());
compile1(gen, objx, r);
LINE_BEFORE.set(pushbackReader.getLineNumber());
}
//end of load
gen.returnValue();
gen.endMethod();

//static fields for constants

for(int i = 0; i < objx.constants.count(); i++)
{
cv.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC,
objx.constantName(i),
objx.constantType(i).getDescriptor(),
null, null);
}

final int INITS_PER = 100;

int numInits = objx.constants.count() / INITS_PER;
if(objx.constants.count() % INITS_PER != 0)
++numInits;

for(int n = 0;n<numInits;n++)
{
GeneratorAdapter clinitgen =
new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC,
Method.getMethod("void __init" + n + "()"),
null,
null,
cv);
clinitgen.visitCode();
try
{
Var.pushThreadBindings(RT.map(RT.PRINT_DUP, RT.T));

for(int i = n*INITS_PER;
i < objx.constants.count() &&
i < (n+1)*INITS_PER;
i++)
{
8.24. COMPILER.JAVA 625

objx.emitValue(objx.constants.nth(i), clinitgen);
clinitgen.checkCast(objx.constantType(i));
clinitgen.putStatic(
objx.objtype,
objx.constantName(i),
objx.constantType(i));
}
}
finally
{
Var.popThreadBindings();
}
clinitgen.returnValue();
clinitgen.endMethod();
}

//static init for constants, keywords and vars

GeneratorAdapter clinitgen =
new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC,
Method.getMethod("void <clinit> ()"),
null,
null,
cv);
clinitgen.visitCode();
Label startTry = clinitgen.newLabel();
Label endTry = clinitgen.newLabel();
Label end = clinitgen.newLabel();
Label finallyLabel = clinitgen.newLabel();

// if(objx.constants.count() > 0)
// {
// objx.emitConstants(clinitgen);
// }
for(int n = 0;n<numInits;n++)
clinitgen.invokeStatic(
objx.objtype,
Method.getMethod("void __init" + n + "()"));

clinitgen.invokeStatic(Type.getType(Compiler.class),
Method.getMethod("void pushNS()"));
clinitgen.mark(startTry);
clinitgen.invokeStatic(objx.objtype,
Method.getMethod("void load()"));
clinitgen.mark(endTry);
clinitgen.invokeStatic(VAR_TYPE,
Method.getMethod("void popThreadBindings()"));
clinitgen.goTo(end);

clinitgen.mark(finallyLabel);
//exception should be on stack
626 CHAPTER 8. JVM/CLOJURE/LANG/

clinitgen.invokeStatic(VAR_TYPE,
Method.getMethod("void popThreadBindings()"));
clinitgen.throwException();
clinitgen.mark(end);
clinitgen.visitTryCatchBlock(startTry, endTry,
finallyLabel, null);

//end of static init

clinitgen.returnValue();
clinitgen.endMethod();

//end of class
cv.visitEnd();

writeClassFile(objx.internalName, cw.toByteArray());
}
catch(LispReader.ReaderException e)
{
throw new CompilerException(sourcePath, e.line, e.getCause());
}
finally
{
Var.popThreadBindings();
}
return ret;
}

static public class NewInstanceExpr extends ObjExpr{

//IPersistentMap optionsMap = PersistentArrayMap.EMPTY;
IPersistentCollection methods;

Map<IPersistentVector,java.lang.reflect.Method> mmap;
Map<IPersistentVector,Set<Class>> covariants;

public NewInstanceExpr(Object tag){

super(tag);
}

static class DeftypeParser implements IParser{

public Expr parse(C context, final Object frm) throws Exception{
ISeq rform = (ISeq) frm;
//(deftype* tagname classname [fields]
// :implements [interfaces] :tag tagname methods*)
rform = RT.next(rform);
String tagname = ((Symbol) rform.first()).toString();
rform = rform.next();
Symbol classname = (Symbol) rform.first();
rform = rform.next();
IPersistentVector fields = (IPersistentVector) rform.first();
8.24. COMPILER.JAVA 627

rform = rform.next();
IPersistentMap opts = PersistentHashMap.EMPTY;
while(rform != null && rform.first() instanceof Keyword)
{
opts = opts.assoc(rform.first(), RT.second(rform));
rform = rform.next().next();
}

ObjExpr ret =
build((IPersistentVector)RT.get(opts,implementsKey,
PersistentVector.EMPTY),fields,null,tagname,
classname, (Symbol) RT.get(opts,RT.TAG_KEY),
rform, frm);
return ret;
}
}

static class ReifyParser implements IParser{

public Expr parse(C context, Object frm) throws Exception{
//(reify this-name? [interfaces] (method-name [args] body)*)
ISeq form = (ISeq) frm;
ObjMethod enclosingMethod = (ObjMethod) METHOD.deref();
String basename = enclosingMethod != null ?
(trimGenID(enclosingMethod.objx.name) + "$")
: (munge(currentNS().name.name) + "$");
String simpleName = "reify__" + RT.nextID();
String classname = basename + simpleName;

ISeq rform = RT.next(form);

IPersistentVector interfaces =
((IPersistentVector) RT.first(rform))
.cons(Symbol.intern("clojure.lang.IObj"));

rform = RT.next(rform);

ObjExpr ret =
build(interfaces, null, null, classname,
Symbol.intern(classname), null, rform, frm);
if(frm instanceof IObj && ((IObj) frm).meta() != null)
return new MetaExpr(ret, MapExpr
.parse(context == C.EVAL
? context
: C.EXPRESSION, ((IObj) frm).meta()));
else
return ret;
}
}
628 CHAPTER 8. JVM/CLOJURE/LANG/

static ObjExpr build(IPersistentVector interfaceSyms,

IPersistentVector fieldSyms,
Symbol thisSym,
String tagName, Symbol className,
Symbol typeTag, ISeq methodForms, Object frm)
throws Exception{
NewInstanceExpr ret = new NewInstanceExpr(null);

ret.src = frm;
ret.name = className.toString();
ret.classMeta = RT.meta(className);
ret.internalName = ret.name.replace(’.’, ’/’);
ret.objtype = Type.getObjectType(ret.internalName);

if(thisSym != null)
ret.thisName = thisSym.name;

if(fieldSyms != null)
{
IPersistentMap fmap = PersistentHashMap.EMPTY;
Object[] closesvec = new Object[2 * fieldSyms.count()];
for(int i=0;i<fieldSyms.count();i++)
{
Symbol sym = (Symbol) fieldSyms.nth(i);
LocalBinding lb = new LocalBinding(-1, sym, null,
new MethodParamExpr(tagClass(tagOf(sym))),
false,null);
fmap = fmap.assoc(sym, lb);
closesvec[i*2] = lb;
closesvec[i*2 + 1] = lb;
}

//todo - inject __meta et al into closes - when?

//use array map to preserve ctor order
ret.closes = new PersistentArrayMap(closesvec);
ret.fields = fmap;
for(int i=fieldSyms.count()-1;i >= 0 &&
((Symbol)fieldSyms.nth(i)).name.startsWith("__");--i)
ret.altCtorDrops++;
}
//todo - set up volatiles
// ret.volatiles =
// PersistentHashSet.create(
// RT.seq(RT.get(ret.optionsMap, volatileKey)));

PersistentVector interfaces = PersistentVector.EMPTY;

for(ISeq s = RT.seq(interfaceSyms);s!=null;s = s.next())
{
Class c = (Class) resolve((Symbol) s.first());
8.24. COMPILER.JAVA 629

if(!c.isInterface())
throw new IllegalArgumentException(
"only interfaces are supported, had: " + c.getName());
interfaces = interfaces.cons(c);
}
Class superClass = Object.class;
Map[] mc = gatherMethods(superClass,RT.seq(interfaces));
Map overrideables = mc[0];
Map covariants = mc[1];
ret.mmap = overrideables;
ret.covariants = covariants;

String[] inames = interfaceNames(interfaces);

Class stub = compileStub(slashname(superClass),ret, inames, frm);

Symbol thistag = Symbol.intern(null,stub.getName());

try
{
Var.pushThreadBindings(
RT.map(CONSTANTS, PersistentVector.EMPTY,
CONSTANT_IDS, new IdentityHashMap(),
KEYWORDS, PersistentHashMap.EMPTY,
VARS, PersistentHashMap.EMPTY,
KEYWORD_CALLSITES, PersistentVector.EMPTY,
PROTOCOL_CALLSITES, PersistentVector.EMPTY,
VAR_CALLSITES, emptyVarCallSites(),
NO_RECUR, null));
if(ret.isDeftype())
{
Var.pushThreadBindings(RT.map(METHOD, null,
LOCAL_ENV, ret.fields
, COMPILE_STUB_SYM, Symbol.intern(null, tagName)
, COMPILE_STUB_CLASS, stub));
}

//now (methodname [args] body)*

ret.line = (Integer) LINE.deref();
IPersistentCollection methods = null;
for(ISeq s = methodForms; s != null; s = RT.next(s))
{
NewInstanceMethod m =
NewInstanceMethod.parse(ret, (ISeq) RT.first(s),
thistag, overrideables);
methods = RT.conj(methods, m);
}

ret.methods = methods;
ret.keywords = (IPersistentMap) KEYWORDS.deref();
630 CHAPTER 8. JVM/CLOJURE/LANG/

ret.vars = (IPersistentMap) VARS.deref();

ret.constants = (PersistentVector) CONSTANTS.deref();
ret.constantsID = RT.nextID();
ret.keywordCallsites =
(IPersistentVector) KEYWORD_CALLSITES.deref();
ret.protocolCallsites =
(IPersistentVector) PROTOCOL_CALLSITES.deref();
ret.varCallsites = (IPersistentSet) VAR_CALLSITES.deref();
}
finally
{
if(ret.isDeftype())
Var.popThreadBindings();
Var.popThreadBindings();
}

ret.compile(slashname(superClass),inames,false);
ret.getCompiledClass();
return ret;
}

/***
* Current host interop uses reflection, which requires
* pre-existing classes. Work around this by:
* Generate a stub class that has the same interfaces and fields
* as the class we are generating.
* Use it as a type hint for this, and bind the simple name of
* the class to this stub (in resolve etc)
* Unmunge the name (using a magic prefix) on any code gen
* for classes
*/
static Class compileStub(String superName,
NewInstanceExpr ret,
String[] interfaceNames,
Object frm){
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisitor cv = cw;
cv.visit(V1_5, ACC_PUBLIC + ACC_SUPER,
COMPILE_STUB_PREFIX + "/" + ret.internalName,
null,superName,interfaceNames);

//instance fields for closed-overs

for(ISeq s = RT.keys(ret.closes); s != null; s = s.next())
{
LocalBinding lb = (LocalBinding) s.first();
int access =
ACC_PUBLIC + (ret.isVolatile(lb) ? ACC_VOLATILE :
ret.isMutable(lb) ? 0 :
ACC_FINAL);
if(lb.getPrimitiveType() != null)
8.24. COMPILER.JAVA 631

cv.visitField(access,
lb.name,
Type.getType(lb.getPrimitiveType())
.getDescriptor(),
null, null);
else
//todo - when closed-overs are fields, use more specific
// types here and in ctor and emitLocal?
cv.visitField(access,
lb.name, OBJECT_TYPE.getDescriptor(), null, null);
}

//ctor that takes closed-overs and does nothing

Method m = new Method("<init>",
Type.VOID_TYPE, ret.ctorTypes());
GeneratorAdapter ctorgen =
new GeneratorAdapter(ACC_PUBLIC,
m,
null,
null,
cv);
ctorgen.visitCode();
ctorgen.loadThis();
ctorgen.invokeConstructor(Type.getObjectType(superName),
voidctor);
ctorgen.returnValue();
ctorgen.endMethod();

if(ret.altCtorDrops > 0)
{
Type[] ctorTypes = ret.ctorTypes();
Type[] altCtorTypes =
new Type[ctorTypes.length-ret.altCtorDrops];
for(int i=0;i<altCtorTypes.length;i++)
altCtorTypes[i] = ctorTypes[i];
Method alt = new Method("<init>",
Type.VOID_TYPE, altCtorTypes);
ctorgen = new GeneratorAdapter(ACC_PUBLIC,
alt,
null,
null,
cv);
ctorgen.visitCode();
ctorgen.loadThis();
ctorgen.loadArgs();
for(int i=0;i<ret.altCtorDrops;i++)
ctorgen.visitInsn(Opcodes.ACONST_NULL);

ctorgen.invokeConstructor(
Type.getObjectType(
632 CHAPTER 8. JVM/CLOJURE/LANG/

COMPILE_STUB_PREFIX + "/" + ret.internalName),

new Method("<init>", Type.VOID_TYPE, ctorTypes));

ctorgen.returnValue();
ctorgen.endMethod();
}
//end of class
cv.visitEnd();

byte[] bytecode = cw.toByteArray();

DynamicClassLoader loader = (DynamicClassLoader) LOADER.deref();
return loader.defineClass(
COMPILE_STUB_PREFIX + "." + ret.name,
bytecode, frm);
}

static String[] interfaceNames(IPersistentVector interfaces){

int icnt = interfaces.count();
String[] inames = icnt > 0 ? new String[icnt] : null;
for(int i=0;i<icnt;i++)
inames[i] = slashname((Class) interfaces.nth(i));
return inames;
}

static String slashname(Class c){

return c.getName().replace(’.’, ’/’);
}

protected void emitMethods(ClassVisitor cv){

for(ISeq s = RT.seq(methods); s != null; s = s.next())
{
ObjMethod method = (ObjMethod) s.first();
method.emit(this, cv);
}
//emit bridge methods
for(Map.Entry<IPersistentVector,Set<Class>> e
: covariants.entrySet())
{
java.lang.reflect.Method m = mmap.get(e.getKey());
Class[] params = m.getParameterTypes();
Type[] argTypes = new Type[params.length];

for(int i = 0; i < params.length; i++)

{
argTypes[i] = Type.getType(params[i]);
}

Method target =
8.24. COMPILER.JAVA 633

new Method(m.getName(),
Type.getType(m.getReturnType()),
argTypes);

for(Class retType : e.getValue())

{
Method meth =
new Method(m.getName(),
Type.getType(retType),
argTypes);

GeneratorAdapter gen =
new GeneratorAdapter(ACC_PUBLIC + ACC_BRIDGE,
meth,
null,
//todo don’t hardwire this
EXCEPTION_TYPES,
cv);
gen.visitCode();
gen.loadThis();
gen.loadArgs();
gen.invokeInterface(
Type.getType(m.getDeclaringClass()),target);
gen.returnValue();
gen.endMethod();
}
}
}

static public IPersistentVector msig(java.lang.reflect.Method m){

return
RT.vector(m.getName(),
RT.seq(m.getParameterTypes()),
m.getReturnType());
}

static void considerMethod(java.lang.reflect.Method m, Map mm){

IPersistentVector mk = msig(m);
int mods = m.getModifiers();

if(!(mm.containsKey(mk)
|| !(Modifier.isPublic(mods) || Modifier.isProtected(mods))
|| Modifier.isStatic(mods)
|| Modifier.isFinal(mods)))
{
mm.put(mk, m);
}
}

static void gatherMethods(Class c, Map mm){

634 CHAPTER 8. JVM/CLOJURE/LANG/

for(; c != null; c = c.getSuperclass())

{
for(java.lang.reflect.Method m : c.getDeclaredMethods())
considerMethod(m, mm);
for(java.lang.reflect.Method m : c.getMethods())
considerMethod(m, mm);
}
}

static public Map[] gatherMethods(Class sc, ISeq interfaces){

Map allm = new HashMap();
gatherMethods(sc, allm);
for(; interfaces != null; interfaces = interfaces.next())
gatherMethods((Class) interfaces.first(), allm);

Map<IPersistentVector,java.lang.reflect.Method> mm =
new HashMap<IPersistentVector,java.lang.reflect.Method>();
Map<IPersistentVector,Set<Class>> covariants =
new HashMap<IPersistentVector,Set<Class>>();
for(Object o : allm.entrySet())
{
Map.Entry e = (Map.Entry) o;
IPersistentVector mk = (IPersistentVector) e.getKey();
mk = (IPersistentVector) mk.pop();
java.lang.reflect.Method m =
(java.lang.reflect.Method) e.getValue();
if(mm.containsKey(mk)) //covariant return
{
Set<Class> cvs = covariants.get(mk);
if(cvs == null)
{
cvs = new HashSet<Class>();
covariants.put(mk,cvs);
}
java.lang.reflect.Method om = mm.get(mk);
if(om.getReturnType()
.isAssignableFrom(m.getReturnType()))
{
cvs.add(om.getReturnType());
mm.put(mk, m);
}
else
cvs.add(m.getReturnType());
}
else
mm.put(mk, m);
}
return new Map[]{mm,covariants};
}
}
8.24. COMPILER.JAVA 635

public static class NewInstanceMethod extends ObjMethod{

String name;
Type[] argTypes;
Type retType;
Class retClass;
Class[] exclasses;

static Symbol dummyThis =

Symbol.intern(null,"dummy_this_dlskjsdfower");
private IPersistentVector parms;

public NewInstanceMethod(ObjExpr objx, ObjMethod parent){

super(objx, parent);
}

int numParams(){
return argLocals.count();
}

String getMethodName(){
return name;
}

Type getReturnType(){
return retType;
}

Type[] getArgTypes(){
return argTypes;
}

static public IPersistentVector msig(String name,

Class[] paramTypes){
return RT.vector(name,RT.seq(paramTypes));
}

static NewInstanceMethod parse(ObjExpr objx, ISeq form,

Symbol thistag,
Map overrideables)
throws Exception{
//(methodname [this-name args*] body...)
//this-name might be nil
NewInstanceMethod method =
new NewInstanceMethod(objx, (ObjMethod) METHOD.deref());
Symbol dotname = (Symbol)RT.first(form);
Symbol name =
(Symbol) Symbol.intern(null,
636 CHAPTER 8. JVM/CLOJURE/LANG/

munge(dotname.name))
.withMeta(RT.meta(dotname));
IPersistentVector parms = (IPersistentVector) RT.second(form);
if(parms.count() == 0)
{
throw new IllegalArgumentException(
"Must supply at least one argument for ’this’ in: " + dotname);
}
Symbol thisName = (Symbol) parms.nth(0);
parms = RT.subvec(parms,1,parms.count());
ISeq body = RT.next(RT.next(form));
try
{
method.line = (Integer) LINE.deref();
//register as the current method and set up a new env frame
PathNode pnode =
new PathNode(PATHTYPE.PATH, (PathNode) CLEAR_PATH.get());
Var.pushThreadBindings(
RT.map(
METHOD, method,
LOCAL_ENV, LOCAL_ENV.deref(),
LOOP_LOCALS, null,
NEXT_LOCAL_NUM, 0
,CLEAR_PATH, pnode
,CLEAR_ROOT, pnode
,CLEAR_SITES, PersistentHashMap.EMPTY
));

//register ’this’ as local 0

if(thisName != null)
registerLocal((thisName == null)
? dummyThis
: thisName,thistag, null,false);
else
getAndIncLocalNum();

PersistentVector argLocals = PersistentVector.EMPTY;

method.retClass = tagClass(tagOf(name));
method.argTypes = new Type[parms.count()];
boolean hinted = tagOf(name) != null;
Class[] pclasses = new Class[parms.count()];
Symbol[] psyms = new Symbol[parms.count()];

for(int i = 0; i < parms.count(); i++)

{
if(!(parms.nth(i) instanceof Symbol))
throw new IllegalArgumentException(
"params must be Symbols");
Symbol p = (Symbol) parms.nth(i);
Object tag = tagOf(p);
8.24. COMPILER.JAVA 637

if(tag != null)
hinted = true;
if(p.getNamespace() != null)
p = Symbol.intern(p.name);
Class pclass = tagClass(tag);
pclasses[i] = pclass;
psyms[i] = p;
}
Map matches =
findMethodsWithNameAndArity(name.name,
parms.count(),
overrideables);
Object mk = msig(name.name, pclasses);
java.lang.reflect.Method m = null;
if(matches.size() > 0)
{
//multiple methods
if(matches.size() > 1)
{
//must be hinted and match one method
if(!hinted)
throw new IllegalArgumentException(
"Must hint overloaded method: " + name.name);
m = (java.lang.reflect.Method) matches.get(mk);
if(m == null)
throw new IllegalArgumentException(
"Can’t find matching overloaded method: " + name.name);
if(m.getReturnType() != method.retClass)
throw new IllegalArgumentException(
"Mismatched return type: " + name.name +
", expected: " + m.getReturnType().getName() +
", had: " + method.retClass.getName());
}
else //one match
{
//if hinted, validate match,
if(hinted)
{
m = (java.lang.reflect.Method) matches.get(mk);
if(m == null)
throw new IllegalArgumentException(
"Can’t find matching method: " + name.name +
", leave off hints for auto match.");
if(m.getReturnType() != method.retClass)
throw new IllegalArgumentException(
"Mismatched return type: " + name.name +
", expected: " +
m.getReturnType().getName() +
", had: " + method.retClass.getName());
}
638 CHAPTER 8. JVM/CLOJURE/LANG/

else //adopt found method sig

{
m = (java.lang.reflect.Method)
matches.values().iterator().next();
method.retClass = m.getReturnType();
pclasses = m.getParameterTypes();
}
}
}
// else if(findMethodsWithName(name.name,allmethods).size()>0)
// throw new IllegalArgumentException(
// "Can’t override/overload method: " + name.name);
else
throw new IllegalArgumentException(
"Can’t define method not in interfaces: " + name.name);

//else
//validate unque name+arity among additional methods

method.retType = Type.getType(method.retClass);
method.exclasses = m.getExceptionTypes();

for(int i = 0; i < parms.count(); i++)

{
LocalBinding lb =
registerLocal(psyms[i],
null,
new MethodParamExpr(pclasses[i]),true);
argLocals = argLocals.assocN(i,lb);
method.argTypes[i] = Type.getType(pclasses[i]);
}
for(int i = 0; i < parms.count(); i++)
{
if(pclasses[i] == long.class ||
pclasses[i] == double.class)
getAndIncLocalNum();
}
LOOP_LOCALS.set(argLocals);
method.name = name.name;
method.methodMeta = RT.meta(name);
method.parms = parms;
method.argLocals = argLocals;
method.body = (new BodyExpr.Parser()).parse(C.RETURN, body);
return method;
}
finally
{
Var.popThreadBindings();
}
}
8.24. COMPILER.JAVA 639

private static Map findMethodsWithNameAndArity(String name,

int arity,
Map mm){
Map ret = new HashMap();
for(Object o : mm.entrySet())
{
Map.Entry e = (Map.Entry) o;
java.lang.reflect.Method m =
(java.lang.reflect.Method) e.getValue();
if(name.equals(m.getName()) &&
m.getParameterTypes().length == arity)
ret.put(e.getKey(), e.getValue());
}
return ret;
}

private static Map findMethodsWithName(String name, Map mm){

Map ret = new HashMap();
for(Object o : mm.entrySet())
{
Map.Entry e = (Map.Entry) o;
java.lang.reflect.Method m =
(java.lang.reflect.Method) e.getValue();
if(name.equals(m.getName()))
ret.put(e.getKey(), e.getValue());
}
return ret;
}

public void emit(ObjExpr obj, ClassVisitor cv){

Method m =
new Method(getMethodName(), getReturnType(), getArgTypes());

Type[] extypes = null;

if(exclasses.length > 0)
{
extypes = new Type[exclasses.length];
for(int i=0;i<exclasses.length;i++)
extypes[i] = Type.getType(exclasses[i]);
}
GeneratorAdapter gen = new GeneratorAdapter(ACC_PUBLIC,
m,
null,
extypes,
cv);
addAnnotation(gen,methodMeta);
for(int i = 0; i < parms.count(); i++)
{
IPersistentMap meta = RT.meta(parms.nth(i));
640 CHAPTER 8. JVM/CLOJURE/LANG/

addParameterAnnotation(gen, meta, i);

}
gen.visitCode();

Label loopLabel = gen.mark();

gen.visitLineNumber(line, loopLabel);
try
{
Var.pushThreadBindings(
RT.map(LOOP_LABEL, loopLabel, METHOD, this));

emitBody(objx, gen, retClass, body);

Label end = gen.mark();
gen.visitLocalVariable("this",
obj.objtype.getDescriptor(),
null, loopLabel, end, 0);
for(ISeq lbs = argLocals.seq();
lbs != null;
lbs = lbs.next())
{
LocalBinding lb = (LocalBinding) lbs.first();
gen.visitLocalVariable(lb.name,
argTypes[lb.idx-1]
.getDescriptor(),
null,
loopLabel, end, lb.idx);
}
}
catch(Exception e)
{
throw new RuntimeException(e);
}
finally
{
Var.popThreadBindings();
}

gen.returnValue();
//gen.visitMaxs(1, 1);
gen.endMethod();
}
}

static Class primClass(Symbol sym){

if(sym == null)
return null;
Class c = null;
if(sym.name.equals("int"))
c = int.class;
8.24. COMPILER.JAVA 641

else if(sym.name.equals("long"))
c = long.class;
else if(sym.name.equals("float"))
c = float.class;
else if(sym.name.equals("double"))
c = double.class;
else if(sym.name.equals("char"))
c = char.class;
else if(sym.name.equals("short"))
c = short.class;
else if(sym.name.equals("byte"))
c = byte.class;
else if(sym.name.equals("boolean"))
c = boolean.class;
else if(sym.name.equals("void"))
c = void.class;
return c;
}

static Class primClass(Class c){

return c.isPrimitive()?c:Object.class;
}

static public class MethodParamExpr

implements Expr, MaybePrimitiveExpr{
final Class c;

public MethodParamExpr(Class c){

this.c = c;
}

public Object eval() throws Exception{

throw new Exception("Can’t eval");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

throw new RuntimeException("Can’t emit");
}
642 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean hasJavaClass() throws Exception{

return c != null;
}

public Class getJavaClass() throws Exception{

return c;
}

public boolean canEmitPrimitive(){

return Util.isPrimitive(c);
}

public void emitUnboxed(C context,

ObjExpr objx,
GeneratorAdapter gen){
throw new RuntimeException("Can’t emit");
}
}

public static class CaseExpr extends UntypedExpr{

public final LocalBindingExpr expr;
public final int shift, mask, low, high;
public final Expr defaultExpr;
public final HashMap<Integer,Expr> tests;
public final HashMap<Integer,Expr> thens;
public final boolean allKeywords;

public final int line;

final static Method hashMethod =

Method.getMethod("int hash(Object)");
final static Method hashCodeMethod =
Method.getMethod("int hashCode()");
final static Method equalsMethod =
Method.getMethod("boolean equals(Object, Object)");

public CaseExpr(int line, LocalBindingExpr expr, int shift,

int mask, int low, int high, Expr defaultExpr,
HashMap<Integer,Expr> tests,
HashMap<Integer,Expr> thens,
boolean allKeywords){
this.expr = expr;
this.shift = shift;
this.mask = mask;
this.low = low;
this.high = high;
this.defaultExpr = defaultExpr;
this.tests = tests;
this.thens = thens;
8.24. COMPILER.JAVA 643

this.line = line;
this.allKeywords = allKeywords;
}

public Object eval() throws Exception{

throw new UnsupportedOperationException("Can’t eval case");
}

public void emit(C context, ObjExpr objx, GeneratorAdapter gen){

Label defaultLabel = gen.newLabel();
Label endLabel = gen.newLabel();
HashMap<Integer,Label> labels = new HashMap();

for(Integer i : tests.keySet())
{
labels.put(i, gen.newLabel());
}

Label[] la = new Label[(high-low)+1];

for(int i=low;i<=high;i++)
{
la[i-low] = labels.containsKey(i)
? labels.get(i)
: defaultLabel;
}

gen.visitLineNumber(line, gen.mark());
expr.emit(C.EXPRESSION, objx, gen);
gen.invokeStatic(UTIL_TYPE,hashMethod);
gen.push(shift);
gen.visitInsn(ISHR);
gen.push(mask);
gen.visitInsn(IAND);
gen.visitTableSwitchInsn(low, high, defaultLabel, la);

for(Integer i : labels.keySet())
{
gen.mark(labels.get(i));
expr.emit(C.EXPRESSION, objx, gen);
tests.get(i).emit(C.EXPRESSION, objx, gen);
if(allKeywords)
{
gen.visitJumpInsn(IF_ACMPNE, defaultLabel);
}
else
{
gen.invokeStatic(UTIL_TYPE, equalsMethod);
gen.ifZCmp(GeneratorAdapter.EQ, defaultLabel);
}
644 CHAPTER 8. JVM/CLOJURE/LANG/

thens.get(i).emit(C.EXPRESSION,objx,gen);
gen.goTo(endLabel);
}

gen.mark(defaultLabel);
defaultExpr.emit(C.EXPRESSION, objx, gen);
gen.mark(endLabel);
if(context == C.STATEMENT)
gen.pop();
}

static class Parser implements IParser{

//(case* expr shift mask low high default
// map<minhash, [test then]> identity?)
//prepared by case macro and presumed correct
//case macro binds actual expr in let so expr is always a local,
//no need to worry about multiple evaluation
public Expr parse(C context, Object frm) throws Exception{
ISeq form = (ISeq) frm;
if(context == C.EVAL)
return
analyze(context,
RT.list(
RT.list(FN, PersistentVector.EMPTY, form)));
PersistentVector args = PersistentVector.create(form.next());
HashMap<Integer,Expr> tests = new HashMap();
HashMap<Integer,Expr> thens = new HashMap();

LocalBindingExpr testexpr =
(LocalBindingExpr) analyze(C.EXPRESSION, args.nth(0));
testexpr.shouldClear = false;

PathNode branch =
new PathNode(PATHTYPE.BRANCH, (PathNode) CLEAR_PATH.get());
for(Object o : ((Map)args.nth(6)).entrySet())
{
Map.Entry e = (Map.Entry) o;
Integer minhash = ((Number)e.getKey()).intValue();
MapEntry me = (MapEntry) e.getValue();
Expr testExpr = new ConstantExpr(me.getKey());
tests.put(minhash, testExpr);
Expr thenExpr;
try {
Var.pushThreadBindings(
RT.map(CLEAR_PATH,
new PathNode(PATHTYPE.PATH,branch)));
thenExpr = analyze(context, me.getValue());
}
finally{
Var.popThreadBindings();
8.25. CONS.JAVA 645

}
thens.put(minhash, thenExpr);
}

Expr defaultExpr;
try {
Var.pushThreadBindings(
RT.map(CLEAR_PATH,
new PathNode(PATHTYPE.PATH,branch)));
defaultExpr = analyze(context, args.nth(5));
}
finally{
Var.popThreadBindings();
}

return new CaseExpr(((Number)LINE.deref()).intValue(),

testexpr,
((Number)args.nth(1)).intValue(),
((Number)args.nth(2)).intValue(),
((Number)args.nth(3)).intValue(),
((Number)args.nth(4)).intValue(),
defaultExpr,
tests,thens,args.nth(7) != RT.F);

}
}
}

static IPersistentCollection emptyVarCallSites(){

return PersistentHashSet.EMPTY;}

———-

8.25 Cons.java

— Cons.java —

\getchunk{Clojure Copyright}
/* rich Mar 25, 2006 11:01:29 AM */

package clojure.lang;

import java.io.Serializable;

final public class Cons extends ASeq implements Serializable {

646 CHAPTER 8. JVM/CLOJURE/LANG/

private final Object _first;

private final ISeq _more;

public Cons(Object first, ISeq _more){

this._first = first;
this._more = _more;
}

public Cons(IPersistentMap meta, Object _first, ISeq _more){

super(meta);
this._first = _first;
this._more = _more;
}

public Object first(){

return _first;
}

public ISeq next(){

return more().seq();
}

public ISeq more(){

if(_more == null)
return PersistentList.EMPTY;
return _more;
}

public int count(){

return 1 + RT.count(_more);
}

public Cons withMeta(IPersistentMap meta){

return new Cons(meta, _first, _more);
}
}

———-

8.26 Counted.java

— Counted.java —

\getchunk{Clojure Copyright}
package clojure.lang;
8.27. DELAY.JAVA 647

/* A class that implements Counted promises that it is a collection

* that implement a constant-time count() */

public interface Counted {

int count();
}

———-

8.27 Delay.java

— Delay.java —

\getchunk{Clojure Copyright}
/* rich Jun 28, 2007 */

package clojure.lang;

public class Delay implements IDeref{

Object val;
IFn fn;

public Delay(IFn fn){

this.fn = fn;
this.val = null;
}

static public Object force(Object x) throws Exception{

return (x instanceof Delay) ?
((Delay) x).deref()
: x;
}

synchronized public Object deref() throws Exception{

if(fn != null)
{
val = fn.invoke();
fn = null;
}
return val;
}
}

———-
648 CHAPTER 8. JVM/CLOJURE/LANG/

8.28 DynamicClassLoader.java

— DynamicClassLoader.java —

\getchunk{Clojure Copyright}
/* rich Aug 21, 2007 */

package clojure.lang;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.net.URLClassLoader;
import java.net.URL;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;

public class DynamicClassLoader extends URLClassLoader{

HashMap<Integer, Object[]> constantVals =
new HashMap<Integer, Object[]>();
static ConcurrentHashMap<String, SoftReference<Class>>classCache =
new ConcurrentHashMap<String, SoftReference<Class> >();

static final URL[] EMPTY_URLS = new URL[]{};

static final ReferenceQueue rq = new ReferenceQueue();

public DynamicClassLoader(){
//pseudo test in lieu of hasContextClassLoader()
super(EMPTY_URLS,
(Thread.currentThread().getContextClassLoader() == null ||
Thread.currentThread().getContextClassLoader() ==
ClassLoader.getSystemClassLoader())
? Compiler.class.getClassLoader()
: Thread.currentThread().getContextClassLoader());
}

public DynamicClassLoader(ClassLoader parent){

super(EMPTY_URLS,parent);
}

public Class defineClass(String name, byte[] bytes, Object srcForm){

Util.clearCache(rq, classCache);
Class c = defineClass(name, bytes, 0, bytes.length);
classCache.put(name, new SoftReference(c,rq));
return c;
}
8.29. ENUMERATIONSEQ.JAVA 649

protected Class<?> findClass(String name)

throws ClassNotFoundException{
SoftReference<Class> cr = classCache.get(name);
if(cr != null)
{
Class c = cr.get();
if(c != null)
return c;
else
classCache.remove(name, cr);
}
return super.findClass(name);
}

public void registerConstants(int id, Object[] val){

constantVals.put(id, val);
}

public Object[] getConstants(int id){

return constantVals.get(id);
}

public void addURL(URL url){

super.addURL(url);
}

———-

8.29 EnumerationSeq.java

— EnumerationSeq.java —

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

import java.io.IOException;
import java.io.NotSerializableException;
import java.util.Enumeration;

public class EnumerationSeq extends ASeq{

final Enumeration iter;
final State state;
650 CHAPTER 8. JVM/CLOJURE/LANG/

static class State{

volatile Object val;
volatile Object _rest;
}

public static EnumerationSeq create(Enumeration iter){

if(iter.hasMoreElements())
return new EnumerationSeq(iter);
return null;
}

EnumerationSeq(Enumeration iter){
this.iter = iter;
state = new State();
this.state.val = state;
this.state._rest = state;
}

EnumerationSeq(IPersistentMap meta, Enumeration iter, State state){

super(meta);
this.iter = iter;
this.state = state;
}

public Object first(){

if(state.val == state)
synchronized(state)
{
if(state.val == state)
state.val = iter.nextElement();
}
return state.val;
}

public ISeq next(){

if(state._rest == state)
synchronized(state)
{
if(state._rest == state)
{
first();
state._rest = create(iter);
}
}
return (ISeq) state._rest;
}

public EnumerationSeq withMeta(IPersistentMap meta){

return new EnumerationSeq(meta, iter, state);
}
8.30. FN.JAVA 651

private void writeObject (java.io.ObjectOutputStream out)

throws IOException {
throw new NotSerializableException(getClass().getName());
}

———-

8.30 Fn.java

— Fn.java —

\getchunk{Clojure Copyright}
/* rich Nov 25, 2008 */

package clojure.lang;

public interface Fn{

}

———-

8.31 IChunk.java

— IChunk.java —

\getchunk{Clojure Copyright}
/* rich Jun 18, 2009 */

package clojure.lang;

public interface IChunk extends Indexed{

IChunk dropFirst();

Object reduce(IFn f, Object start) throws Exception;

}

———-
652 CHAPTER 8. JVM/CLOJURE/LANG/

8.32 IChunkedSeq.java

— IChunkedSeq.java —

\getchunk{Clojure Copyright}
/* rich May 24, 2009 */

package clojure.lang;

public interface IChunkedSeq extends ISeq{

IChunk chunkedFirst() throws Exception;

import java.util.concurrent.Callable;

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
656 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg16, Object arg17, Object arg18,

Object arg19, Object arg20, Object... args)
throws Exception;

public Object applyTo(ISeq arglist) throws Exception;

static public interface

OLLOD{double invokePrim(Object arg0, long arg1, long arg2,

Object arg3);}
static public interface
OLLLO{Object invokePrim(Object arg0, long arg1, long arg2,
long arg3);}
static public interface
OLLLL{long invokePrim(Object arg0, long arg1, long arg2,
long arg3);}
static public interface
OLLLD{double invokePrim(Object arg0, long arg1, long arg2,
long arg3);}
static public interface
OLLDO{Object invokePrim(Object arg0, long arg1, long arg2,
double arg3);}
static public interface
OLLDL{long invokePrim(Object arg0, long arg1, long arg2,
double arg3);}
static public interface
OLLDD{double invokePrim(Object arg0, long arg1, long arg2,
double arg3);}
static public interface
OLDOO{Object invokePrim(Object arg0, long arg1, double arg2,
Object arg3);}
static public interface
OLDOL{long invokePrim(Object arg0, long arg1, double arg2,
Object arg3);}
static public interface
OLDOD{double invokePrim(Object arg0, long arg1, double arg2,
Object arg3);}
static public interface
OLDLO{Object invokePrim(Object arg0, long arg1, double arg2,
long arg3);}
static public interface
OLDLL{long invokePrim(Object arg0, long arg1, double arg2,
long arg3);}
static public interface
OLDLD{double invokePrim(Object arg0, long arg1, double arg2,
long arg3);}
static public interface
OLDDO{Object invokePrim(Object arg0, long arg1, double arg2,
double arg3);}
static public interface
OLDDL{long invokePrim(Object arg0, long arg1, double arg2,
double arg3);}
static public interface
OLDDD{double invokePrim(Object arg0, long arg1, double arg2,
double arg3);}
static public interface
ODOOO{Object invokePrim(Object arg0, double arg1, Object arg2,
Object arg3);}
664 CHAPTER 8. JVM/CLOJURE/LANG/

static public interface

ODOOL{long invokePrim(Object arg0, double arg1, Object arg2,
Object arg3);}
static public interface
ODOOD{double invokePrim(Object arg0, double arg1, Object arg2,
Object arg3);}
static public interface
ODOLO{Object invokePrim(Object arg0, double arg1, Object arg2,
long arg3);}
static public interface
ODOLL{long invokePrim(Object arg0, double arg1, Object arg2,
long arg3);}
static public interface
ODOLD{double invokePrim(Object arg0, double arg1, Object arg2,
long arg3);}
static public interface
ODODO{Object invokePrim(Object arg0, double arg1, Object arg2,
double arg3);}
static public interface
ODODL{long invokePrim(Object arg0, double arg1, Object arg2,
double arg3);}
static public interface
ODODD{double invokePrim(Object arg0, double arg1, Object arg2,
double arg3);}
static public interface
ODLOO{Object invokePrim(Object arg0, double arg1, long arg2,
Object arg3);}
static public interface
ODLOL{long invokePrim(Object arg0, double arg1, long arg2,
Object arg3);}
static public interface
ODLOD{double invokePrim(Object arg0, double arg1, long arg2,
Object arg3);}
static public interface
ODLLO{Object invokePrim(Object arg0, double arg1, long arg2,
long arg3);}
static public interface
ODLLL{long invokePrim(Object arg0, double arg1, long arg2,
long arg3);}
static public interface
ODLLD{double invokePrim(Object arg0, double arg1, long arg2,
long arg3);}
static public interface
ODLDO{Object invokePrim(Object arg0, double arg1, long arg2,
double arg3);}
static public interface
ODLDL{long invokePrim(Object arg0, double arg1, long arg2,
double arg3);}
static public interface
ODLDD{double invokePrim(Object arg0, double arg1, long arg2,
8.35. IFN.JAVA 665

double arg3);}
static public interface
ODDOO{Object invokePrim(Object arg0, double arg1, double arg2,
Object arg3);}
static public interface
ODDOL{long invokePrim(Object arg0, double arg1, double arg2,
Object arg3);}
static public interface
ODDOD{double invokePrim(Object arg0, double arg1, double arg2,
Object arg3);}
static public interface
ODDLO{Object invokePrim(Object arg0, double arg1, double arg2,
long arg3);}
static public interface
ODDLL{long invokePrim(Object arg0, double arg1, double arg2,
long arg3);}
static public interface
ODDLD{double invokePrim(Object arg0, double arg1, double arg2,
long arg3);}
static public interface
ODDDO{Object invokePrim(Object arg0, double arg1, double arg2,
double arg3);}
static public interface
ODDDL{long invokePrim(Object arg0, double arg1, double arg2,
double arg3);}
static public interface
ODDDD{double invokePrim(Object arg0, double arg1, double arg2,
double arg3);}
static public interface
LOOOO{Object invokePrim(long arg0, Object arg1, Object arg2,
Object arg3);}
static public interface
LOOOL{long invokePrim(long arg0, Object arg1, Object arg2,
Object arg3);}
static public interface
LOOOD{double invokePrim(long arg0, Object arg1, Object arg2,
Object arg3);}
static public interface
LOOLO{Object invokePrim(long arg0, Object arg1, Object arg2,
long arg3);}
static public interface
LOOLL{long invokePrim(long arg0, Object arg1, Object arg2,
long arg3);}
static public interface
LOOLD{double invokePrim(long arg0, Object arg1, Object arg2,
long arg3);}
static public interface
LOODO{Object invokePrim(long arg0, Object arg1, Object arg2,
double arg3);}
static public interface
666 CHAPTER 8. JVM/CLOJURE/LANG/

LOODL{long invokePrim(long arg0, Object arg1, Object arg2,

double arg3);}
static public interface
LOODD{double invokePrim(long arg0, Object arg1, Object arg2,
double arg3);}
static public interface
LOLOO{Object invokePrim(long arg0, Object arg1, long arg2,
Object arg3);}
static public interface
LOLOL{long invokePrim(long arg0, Object arg1, long arg2,
Object arg3);}
static public interface
LOLOD{double invokePrim(long arg0, Object arg1, long arg2,
Object arg3);}
static public interface
LOLLO{Object invokePrim(long arg0, Object arg1, long arg2,
long arg3);}
static public interface
LOLLL{long invokePrim(long arg0, Object arg1, long arg2,
long arg3);}
static public interface
LOLLD{double invokePrim(long arg0, Object arg1, long arg2,
long arg3);}
static public interface
LOLDO{Object invokePrim(long arg0, Object arg1, long arg2,
double arg3);}
static public interface
LOLDL{long invokePrim(long arg0, Object arg1, long arg2,
double arg3);}
static public interface
LOLDD{double invokePrim(long arg0, Object arg1, long arg2,
double arg3);}
static public interface
LODOO{Object invokePrim(long arg0, Object arg1, double arg2,
Object arg3);}
static public interface
LODOL{long invokePrim(long arg0, Object arg1, double arg2,
Object arg3);}
static public interface
LODOD{double invokePrim(long arg0, Object arg1, double arg2,
Object arg3);}
static public interface
LODLO{Object invokePrim(long arg0, Object arg1, double arg2,
long arg3);}
static public interface
LODLL{long invokePrim(long arg0, Object arg1, double arg2,
long arg3);}
static public interface
LODLD{double invokePrim(long arg0, Object arg1, double arg2,
long arg3);}
8.35. IFN.JAVA 667

static public interface

LODDO{Object invokePrim(long arg0, Object arg1, double arg2,
double arg3);}
static public interface
LODDL{long invokePrim(long arg0, Object arg1, double arg2,
double arg3);}
static public interface
LODDD{double invokePrim(long arg0, Object arg1, double arg2,
double arg3);}
static public interface
LLOOO{Object invokePrim(long arg0, long arg1, Object arg2,
Object arg3);}
static public interface
LLOOL{long invokePrim(long arg0, long arg1, Object arg2,
Object arg3);}
static public interface
LLOOD{double invokePrim(long arg0, long arg1, Object arg2,
Object arg3);}
static public interface
LLOLO{Object invokePrim(long arg0, long arg1, Object arg2,
long arg3);}
static public interface
LLOLL{long invokePrim(long arg0, long arg1, Object arg2,
long arg3);}
static public interface
LLOLD{double invokePrim(long arg0, long arg1, Object arg2,
long arg3);}
static public interface
LLODO{Object invokePrim(long arg0, long arg1, Object arg2,
double arg3);}
static public interface
LLODL{long invokePrim(long arg0, long arg1, Object arg2,
double arg3);}
static public interface
LLODD{double invokePrim(long arg0, long arg1, Object arg2,
double arg3);}
static public interface
LLLOO{Object invokePrim(long arg0, long arg1, long arg2,
Object arg3);}
static public interface
LLLOL{long invokePrim(long arg0, long arg1, long arg2,
Object arg3);}
static public interface
LLLOD{double invokePrim(long arg0, long arg1, long arg2,
Object arg3);}
static public interface
LLLLO{Object invokePrim(long arg0, long arg1, long arg2,
long arg3);}
static public interface
LLLLL{long invokePrim(long arg0, long arg1, long arg2,
668 CHAPTER 8. JVM/CLOJURE/LANG/

long arg3);}
static public interface
LLLLD{double invokePrim(long arg0, long arg1, long arg2,
long arg3);}
static public interface
LLLDO{Object invokePrim(long arg0, long arg1, long arg2,
double arg3);}
static public interface
LLLDL{long invokePrim(long arg0, long arg1, long arg2,
double arg3);}
static public interface
LLLDD{double invokePrim(long arg0, long arg1, long arg2,
double arg3);}
static public interface
LLDOO{Object invokePrim(long arg0, long arg1, double arg2,
Object arg3);}
static public interface
LLDOL{long invokePrim(long arg0, long arg1, double arg2,
Object arg3);}
static public interface
LLDOD{double invokePrim(long arg0, long arg1, double arg2,
Object arg3);}
static public interface
LLDLO{Object invokePrim(long arg0, long arg1, double arg2,
long arg3);}
static public interface
LLDLL{long invokePrim(long arg0, long arg1, double arg2,
long arg3);}
static public interface
LLDLD{double invokePrim(long arg0, long arg1, double arg2,
long arg3);}
static public interface
LLDDO{Object invokePrim(long arg0, long arg1, double arg2,
double arg3);}
static public interface
LLDDL{long invokePrim(long arg0, long arg1, double arg2,
double arg3);}
static public interface
LLDDD{double invokePrim(long arg0, long arg1, double arg2,
double arg3);}
static public interface
LDOOO{Object invokePrim(long arg0, double arg1, Object arg2,
Object arg3);}
static public interface
LDOOL{long invokePrim(long arg0, double arg1, Object arg2,
Object arg3);}
static public interface
LDOOD{double invokePrim(long arg0, double arg1, Object arg2,
Object arg3);}
static public interface
8.35. IFN.JAVA 669

LDOLO{Object invokePrim(long arg0, double arg1, Object arg2,

long arg3);}
static public interface
LDOLL{long invokePrim(long arg0, double arg1, Object arg2,
long arg3);}
static public interface
LDOLD{double invokePrim(long arg0, double arg1, Object arg2,
long arg3);}
static public interface
LDODO{Object invokePrim(long arg0, double arg1, Object arg2,
double arg3);}
static public interface
LDODL{long invokePrim(long arg0, double arg1, Object arg2,
double arg3);}
static public interface
LDODD{double invokePrim(long arg0, double arg1, Object arg2,
double arg3);}
static public interface
LDLOO{Object invokePrim(long arg0, double arg1, long arg2,
Object arg3);}
static public interface
LDLOL{long invokePrim(long arg0, double arg1, long arg2,
Object arg3);}
static public interface
LDLOD{double invokePrim(long arg0, double arg1, long arg2,
Object arg3);}
static public interface
LDLLO{Object invokePrim(long arg0, double arg1, long arg2,
long arg3);}
static public interface
LDLLL{long invokePrim(long arg0, double arg1, long arg2,
long arg3);}
static public interface
LDLLD{double invokePrim(long arg0, double arg1, long arg2,
long arg3);}
static public interface
LDLDO{Object invokePrim(long arg0, double arg1, long arg2,
double arg3);}
static public interface
LDLDL{long invokePrim(long arg0, double arg1, long arg2,
double arg3);}
static public interface
LDLDD{double invokePrim(long arg0, double arg1, long arg2,
double arg3);}
static public interface
LDDOO{Object invokePrim(long arg0, double arg1, double arg2,
Object arg3);}
static public interface
LDDOL{long invokePrim(long arg0, double arg1, double arg2,
Object arg3);}
670 CHAPTER 8. JVM/CLOJURE/LANG/

static public interface

LDDOD{double invokePrim(long arg0, double arg1, double arg2,
Object arg3);}
static public interface
LDDLO{Object invokePrim(long arg0, double arg1, double arg2,
long arg3);}
static public interface
LDDLL{long invokePrim(long arg0, double arg1, double arg2,
long arg3);}
static public interface
LDDLD{double invokePrim(long arg0, double arg1, double arg2,
long arg3);}
static public interface
LDDDO{Object invokePrim(long arg0, double arg1, double arg2,
double arg3);}
static public interface
LDDDL{long invokePrim(long arg0, double arg1, double arg2,
double arg3);}
static public interface
LDDDD{double invokePrim(long arg0, double arg1, double arg2,
double arg3);}
static public interface
DOOOO{Object invokePrim(double arg0, Object arg1, Object arg2,
Object arg3);}
static public interface
DOOOL{long invokePrim(double arg0, Object arg1, Object arg2,
Object arg3);}
static public interface
DOOOD{double invokePrim(double arg0, Object arg1, Object arg2,
Object arg3);}
static public interface
DOOLO{Object invokePrim(double arg0, Object arg1, Object arg2,
long arg3);}
static public interface
DOOLL{long invokePrim(double arg0, Object arg1, Object arg2,
long arg3);}
static public interface
DOOLD{double invokePrim(double arg0, Object arg1, Object arg2,
long arg3);}
static public interface
DOODO{Object invokePrim(double arg0, Object arg1, Object arg2,
double arg3);}
static public interface
DOODL{long invokePrim(double arg0, Object arg1, Object arg2,
double arg3);}
static public interface
DOODD{double invokePrim(double arg0, Object arg1, Object arg2,
double arg3);}
static public interface
DOLOO{Object invokePrim(double arg0, Object arg1, long arg2,
8.35. IFN.JAVA 671

Object arg3);}
static public interface
DOLOL{long invokePrim(double arg0, Object arg1, long arg2,
Object arg3);}
static public interface
DOLOD{double invokePrim(double arg0, Object arg1, long arg2,
Object arg3);}
static public interface
DOLLO{Object invokePrim(double arg0, Object arg1, long arg2,
long arg3);}
static public interface
DOLLL{long invokePrim(double arg0, Object arg1, long arg2,
long arg3);}
static public interface
DOLLD{double invokePrim(double arg0, Object arg1, long arg2,
long arg3);}
static public interface
DOLDO{Object invokePrim(double arg0, Object arg1, long arg2,
double arg3);}
static public interface
DOLDL{long invokePrim(double arg0, Object arg1, long arg2,
double arg3);}
static public interface
DOLDD{double invokePrim(double arg0, Object arg1, long arg2,
double arg3);}
static public interface
DODOO{Object invokePrim(double arg0, Object arg1, double arg2,
Object arg3);}
static public interface
DODOL{long invokePrim(double arg0, Object arg1, double arg2,
Object arg3);}
static public interface
DODOD{double invokePrim(double arg0, Object arg1, double arg2,
Object arg3);}
static public interface
DODLO{Object invokePrim(double arg0, Object arg1, double arg2,
long arg3);}
static public interface
DODLL{long invokePrim(double arg0, Object arg1, double arg2,
long arg3);}
static public interface
DODLD{double invokePrim(double arg0, Object arg1, double arg2,
long arg3);}
static public interface
DODDO{Object invokePrim(double arg0, Object arg1, double arg2,
double arg3);}
static public interface
DODDL{long invokePrim(double arg0, Object arg1, double arg2,
double arg3);}
static public interface
672 CHAPTER 8. JVM/CLOJURE/LANG/

DODDD{double invokePrim(double arg0, Object arg1, double arg2,

double arg3);}
static public interface
DLOOO{Object invokePrim(double arg0, long arg1, Object arg2,
Object arg3);}
static public interface
DLOOL{long invokePrim(double arg0, long arg1, Object arg2,
Object arg3);}
static public interface
DLOOD{double invokePrim(double arg0, long arg1, Object arg2,
Object arg3);}
static public interface
DLOLO{Object invokePrim(double arg0, long arg1, Object arg2,
long arg3);}
static public interface
DLOLL{long invokePrim(double arg0, long arg1, Object arg2,
long arg3);}
static public interface
DLOLD{double invokePrim(double arg0, long arg1, Object arg2,
long arg3);}
static public interface
DLODO{Object invokePrim(double arg0, long arg1, Object arg2,
double arg3);}
static public interface
DLODL{long invokePrim(double arg0, long arg1, Object arg2,
double arg3);}
static public interface
DLODD{double invokePrim(double arg0, long arg1, Object arg2,
double arg3);}
static public interface
DLLOO{Object invokePrim(double arg0, long arg1, long arg2,
Object arg3);}
static public interface
DLLOL{long invokePrim(double arg0, long arg1, long arg2,
Object arg3);}
static public interface
DLLOD{double invokePrim(double arg0, long arg1, long arg2,
Object arg3);}
static public interface
DLLLO{Object invokePrim(double arg0, long arg1, long arg2,
long arg3);}
static public interface
DLLLL{long invokePrim(double arg0, long arg1, long arg2,
long arg3);}
static public interface
DLLLD{double invokePrim(double arg0, long arg1, long arg2,
long arg3);}
static public interface
DLLDO{Object invokePrim(double arg0, long arg1, long arg2,
double arg3);}
8.35. IFN.JAVA 673

static public interface

DLLDL{long invokePrim(double arg0, long arg1, long arg2,
double arg3);}
static public interface
DLLDD{double invokePrim(double arg0, long arg1, long arg2,
double arg3);}
static public interface
DLDOO{Object invokePrim(double arg0, long arg1, double arg2,
Object arg3);}
static public interface
DLDOL{long invokePrim(double arg0, long arg1, double arg2,
Object arg3);}
static public interface
DLDOD{double invokePrim(double arg0, long arg1, double arg2,
Object arg3);}
static public interface
DLDLO{Object invokePrim(double arg0, long arg1, double arg2,
long arg3);}
static public interface
DLDLL{long invokePrim(double arg0, long arg1, double arg2,
long arg3);}
static public interface
DLDLD{double invokePrim(double arg0, long arg1, double arg2,
long arg3);}
static public interface
DLDDO{Object invokePrim(double arg0, long arg1, double arg2,
double arg3);}
static public interface
DLDDL{long invokePrim(double arg0, long arg1, double arg2,
double arg3);}
static public interface
DLDDD{double invokePrim(double arg0, long arg1, double arg2,
double arg3);}
static public interface
DDOOO{Object invokePrim(double arg0, double arg1, Object arg2,
Object arg3);}
static public interface
DDOOL{long invokePrim(double arg0, double arg1, Object arg2,
Object arg3);}
static public interface
DDOOD{double invokePrim(double arg0, double arg1, Object arg2,
Object arg3);}
static public interface
DDOLO{Object invokePrim(double arg0, double arg1, Object arg2,
long arg3);}
static public interface
DDOLL{long invokePrim(double arg0, double arg1, Object arg2,
long arg3);}
static public interface
DDOLD{double invokePrim(double arg0, double arg1, Object arg2,
674 CHAPTER 8. JVM/CLOJURE/LANG/

long arg3);}
static public interface
DDODO{Object invokePrim(double arg0, double arg1, Object arg2,
double arg3);}
static public interface
DDODL{long invokePrim(double arg0, double arg1, Object arg2,
double arg3);}
static public interface
DDODD{double invokePrim(double arg0, double arg1, Object arg2,
double arg3);}
static public interface
DDLOO{Object invokePrim(double arg0, double arg1, long arg2,
Object arg3);}
static public interface
DDLOL{long invokePrim(double arg0, double arg1, long arg2,
Object arg3);}
static public interface
DDLOD{double invokePrim(double arg0, double arg1, long arg2,
Object arg3);}
static public interface
DDLLO{Object invokePrim(double arg0, double arg1, long arg2,
long arg3);}
static public interface
DDLLL{long invokePrim(double arg0, double arg1, long arg2,
long arg3);}
static public interface
DDLLD{double invokePrim(double arg0, double arg1, long arg2,
long arg3);}
static public interface
DDLDO{Object invokePrim(double arg0, double arg1, long arg2,
double arg3);}
static public interface
DDLDL{long invokePrim(double arg0, double arg1, long arg2,
double arg3);}
static public interface
DDLDD{double invokePrim(double arg0, double arg1, long arg2,
double arg3);}
static public interface
DDDOO{Object invokePrim(double arg0, double arg1, double arg2,
Object arg3);}
static public interface
DDDOL{long invokePrim(double arg0, double arg1, double arg2,
Object arg3);}
static public interface
DDDOD{double invokePrim(double arg0, double arg1, double arg2,
Object arg3);}
static public interface
DDDLO{Object invokePrim(double arg0, double arg1, double arg2,
long arg3);}
static public interface
8.36. IKEYWORDLOOKUP.JAVA 675

DDDLL{long invokePrim(double arg0, double arg1, double arg2,

long arg3);}
static public interface
DDDLD{double invokePrim(double arg0, double arg1, double arg2,
long arg3);}
static public interface
DDDDO{Object invokePrim(double arg0, double arg1, double arg2,
double arg3);}
static public interface
DDDDL{long invokePrim(double arg0, double arg1, double arg2,
double arg3);}
static public interface
DDDDD{double invokePrim(double arg0, double arg1, double arg2,
double arg3);}
}

———-

8.36 IKeywordLookup.java

— IKeywordLookup.java —

getchunk{Clojure Copyright}
/* rich Oct 31, 2009 */

package clojure.lang;

public interface IKeywordLookup{

ILookupThunk getLookupThunk(Keyword k);
}

———-

8.37 ILookup.java

— ILookup.java —

\getchunk{Clojure Copyright}
/* rich Aug 2, 2009 */

package clojure.lang;

public interface ILookup{

Object valAt(Object key);
676 CHAPTER 8. JVM/CLOJURE/LANG/

Object valAt(Object key, Object notFound);

}

Object nth(int i);

Object nth(int i, Object notFound);

}
678 CHAPTER 8. JVM/CLOJURE/LANG/

———-

8.43 IndexedSeq.java

— IndexedSeq.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IndexedSeq extends ISeq, Counted{

public int index();

}

———-

8.44 IObj.java

— IObj.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IObj extends IMeta {

public IObj withMeta(IPersistentMap meta);

———-

8.45 IPersistentCollection.java

— IPersistentCollection.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IPersistentCollection extends Seqable {

8.46. IPERSISTENTLIST.JAVA 679

int count();

IPersistentCollection cons(Object o);

IPersistentCollection empty();

boolean equiv(Object o);

}

———-

8.46 IPersistentList.java

— IPersistentList.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IPersistentList extends Sequential, IPersistentStack{

———-

8.47 IPersistentMap.java

— IPersistentMap.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IPersistentMap extends Iterable, Associative, Counted{

IPersistentMap assoc(Object key, Object val);

IPersistentMap assocEx(Object key, Object val) throws Exception;

IPersistentMap without(Object key) throws Exception;

———-
680 CHAPTER 8. JVM/CLOJURE/LANG/

8.48 IPersistentSet.java

— IPersistentSet.java —

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

public interface IPersistentSet extends IPersistentCollection, Counted{

public IPersistentSet disjoin(Object key) throws Exception;
public boolean contains(Object key);
public Object get(Object key);
}

———-

8.49 IPersistentStack.java

— IPersistentStack.java —

\getchunk{Clojure Copyright}
/* rich Sep 19, 2007 */

package clojure.lang;

public interface IPersistentStack extends IPersistentCollection{

Object peek();

IPersistentStack pop();
}

———-

8.50 IPersistentVector.java

— IPersistentVector.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IPersistentVector

8.51. IPROMISEIMPL.JAVA 681

extends Associative, Sequential, IPersistentStack,

Reversible, Indexed{
int length();

IPersistentVector assocN(int i, Object val);

IPersistentVector cons(Object o);

———-

8.51 IPromiseImpl.java

— IPromiseImpl.java —

\getchunk{Clojure Copyright}
package clojure.lang;

public interface IPromiseImpl {

boolean hasValue();
}

———-

8.52 IProxy.java

— IProxy.java —

\getchunk{Clojure Copyright}
/* rich Feb 27, 2008 */

package clojure.lang;

public interface IProxy{

public void __initClojureFnMappings(IPersistentMap m);

public void __updateClojureFnMappings(IPersistentMap m);
public IPersistentMap __getClojureFnMappings();

———-
682 CHAPTER 8. JVM/CLOJURE/LANG/

8.53 IReduce.java

— IReduce.java —

\getchunk{Clojure Copyright}
/* rich Jun 11, 2008 */

package clojure.lang;

public interface IReduce{

Object reduce(IFn f) throws Exception;

Object reduce(IFn f, Object start) throws Exception;

}

———-

8.54 IReference.java

— IReference.java —

\getchunk{Clojure Copyright}
/* rich Dec 31, 2008 */

package clojure.lang;

public interface IReference extends IMeta {

IPersistentMap alterMeta(IFn alter, ISeq args) throws Exception;
IPersistentMap resetMeta(IPersistentMap m);
}

———-

8.55 IRef.java

— IRef.java —

\getchunk{Clojure Copyright}
/* rich Nov 18, 2007 */

package clojure.lang;
8.56. ISEQ.JAVA 683

public interface IRef extends IDeref{

void setValidator(IFn vf);

IFn getValidator();

IPersistentMap getWatches();

IRef addWatch(Object key, IFn callback);

IRef removeWatch(Object key);

———-

8.56 ISeq.java

— ISeq.java —
\getchunk{Clojure Copyright}
package clojure.lang;

/**
* A persistent, functional, sequence interface
* 
* ISeqs are immutable values, i.e. neither first(), nor rest() changes
* or invalidates the ISeq
*/
public interface ISeq extends IPersistentCollection, Sequential{

Object first();

ISeq next();

ISeq more();

ISeq cons(Object o);

———-

8.57 IteratorSeq.java
684 CHAPTER 8. JVM/CLOJURE/LANG/

— IteratorSeq.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.IOException;
import java.io.NotSerializableException;
import java.util.Iterator;

public class IteratorSeq extends ASeq{

final Iterator iter;
final State state;

static class State{

volatile Object val;
volatile Object _rest;
}

public static IteratorSeq create(Iterator iter){

if(iter.hasNext())
return new IteratorSeq(iter);
return null;
}

IteratorSeq(Iterator iter){
this.iter = iter;
state = new State();
this.state.val = state;
this.state._rest = state;
}

IteratorSeq(IPersistentMap meta, Iterator iter, State state){

super(meta);
this.iter = iter;
this.state = state;
}

public Object first(){

if(state.val == state)
synchronized(state)
{
if(state.val == state)
state.val = iter.next();
}
return state.val;
}

public ISeq next(){

if(state._rest == state)
synchronized(state)
8.58. ITRANSIENTASSOCIATIVE.JAVA 685

{
if(state._rest == state)
{
first();
state._rest = create(iter);
}
}
return (ISeq) state._rest;
}

public IteratorSeq withMeta(IPersistentMap meta){

return new IteratorSeq(meta, iter, state);
}

private void writeObject (java.io.ObjectOutputStream out)

throws IOException {
throw new NotSerializableException(getClass().getName());
}
}

———-

8.58 ITransientAssociative.java

— ITransientAssociative.java —

\getchunk{Clojure Copyright}
/* rich Jul 17, 2009 */

package clojure.lang;

public interface ITransientAssociative

extends ITransientCollection, ILookup{

ITransientAssociative assoc(Object key, Object val);

}

———-

8.59 ITransientCollection.java

— ITransientCollection.java —

\getchunk{Clojure Copyright}
686 CHAPTER 8. JVM/CLOJURE/LANG/

/* rich Jul 17, 2009 */

package clojure.lang;

implements IFn, Comparable, Named, Serializable {

private static ConcurrentHashMap<Symbol, SoftReference<Keyword>> table =

688 CHAPTER 8. JVM/CLOJURE/LANG/

new ConcurrentHashMap();
static final ReferenceQueue rq = new ReferenceQueue();
public final Symbol sym;
final int hash;

public static Keyword intern(Symbol sym){

if(sym.meta() != null)
sym = (Symbol) sym.withMeta(null);
Util.clearCache(rq, table);
Keyword k = new Keyword(sym);
SoftReference<Keyword> existingRef =
table.putIfAbsent(sym, new SoftReference<Keyword>(k,rq));
if(existingRef == null)
return k;
Keyword existingk = existingRef.get();
if(existingk != null)
return existingk;
//entry died in the interim, do over
table.remove(sym, existingRef);
return intern(sym);
}

public static Keyword intern(String ns, String name){

return intern(Symbol.intern(ns, name));
}

public static Keyword intern(String nsname){

return intern(Symbol.intern(nsname));
}

private Keyword(Symbol sym){

this.sym = sym;
hash = sym.hashCode() + 0x9e3779b9;
}

public static Keyword find(Symbol sym){

SoftReference<Keyword> ref = table.get(sym);
if (ref != null)
return ref.get();
else
return null;
}

public static Keyword find(String ns, String name){

return find(Symbol.intern(ns, name));
}

public static Keyword find(String nsname){

return find(Symbol.intern(nsname));
}
8.63. KEYWORD.JAVA 689

public final int hashCode(){

return hash;
}

public String toString(){

return ":" + sym;
}

public Object throwArity(){

throw new IllegalArgumentException(
"Wrong number of args passed to keyword: " + toString());
}

public Object call() throws Exception{

return throwArity();
}

public void run(){

throw new UnsupportedOperationException();
}

public Object invoke() throws Exception{

return throwArity();
}

public int compareTo(Object o){

return sym.compareTo(((Keyword) o).sym);
}

public String getNamespace(){

return sym.getNamespace();
}

public String getName(){

return sym.getName();
}

private Object readResolve() throws ObjectStreamException{

return intern(sym);
}

/**
* Indexer implements IFn for attr access
*
* @param obj - must be IPersistentMap
* @return the value at the key or nil if not found
* @throws Exception
*/
690 CHAPTER 8. JVM/CLOJURE/LANG/

final public Object invoke(Object obj) throws Exception{

if(obj instanceof ILookup)
return ((ILookup)obj).valAt(this);
return RT.get(obj, this);
}

final public Object invoke(Object obj, Object notFound)

throws Exception{
if(obj instanceof ILookup)
return ((ILookup)obj).valAt(this,notFound);
return RT.get(obj, this, notFound);
}

public Object invoke(Object arg1, Object arg2, Object arg3)

throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8)
throws Exception{
return throwArity();
}
8.63. KEYWORD.JAVA 691

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

692 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg4, Object arg5, Object arg6,

Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

8.64. KEYWORDLOOKUPSITE.JAVA 693

Object arg4, Object arg5, Object arg6,

Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19, Object arg20)
throws Exception{
return throwArity();
}

public Object invoke(Object arg1, Object arg2, Object arg3,

public Object applyTo(ISeq arglist) throws Exception{

return AFn.applyToHelper(this, arglist);
}

———-

8.64 KeywordLookupSite.java

— KeywordLookupSite.java —

\getchunk{Clojure Copyright}
/* rich Nov 2, 2009 */

package clojure.lang;

public final class KeywordLookupSite

implements ILookupSite, ILookupThunk{

final Keyword k;

public KeywordLookupSite(Keyword k){

this.k = k;
694 CHAPTER 8. JVM/CLOJURE/LANG/

public ILookupThunk fault(Object target){

if(target instanceof IKeywordLookup)
{
return install(target);
}
else if(target instanceof ILookup)
{
return ilookupThunk(target.getClass());
}
return this;
}

public Object get(Object target){

if(target instanceof IKeywordLookup || target instanceof ILookup)
return this;
return RT.get(target,k);
}

private ILookupThunk ilookupThunk(final Class c){

return new ILookupThunk(){
public Object get(Object target){
if(target != null && target.getClass() == c)
return ((ILookup) target).valAt(k);
return this;
}
};
}

private ILookupThunk install(Object target){

ILookupThunk t = ((IKeywordLookup)target).getLookupThunk(k);
if(t != null)
return t;
return ilookupThunk(target.getClass());
}
}

———-

8.65 LazilyPersistentVector.java

— LazilyPersistentVector.java —

\getchunk{Clojure Copyright}
/* rich May 14, 2008 */
8.66. LAZYSEQ.JAVA 695

package clojure.lang;

import java.util.Collection;

public class LazilyPersistentVector{

static public IPersistentVector createOwning(Object... items){

if(items.length == 0)
return PersistentVector.EMPTY;
else if(items.length <= 32)
return
new PersistentVector(items.length, 5,
PersistentVector.EMPTY_NODE,items);
return PersistentVector.create(items);
}

static public IPersistentVector create(Collection coll){

if(!(coll instanceof ISeq) && coll.size() <= 32)
return createOwning(coll.toArray());
return PersistentVector.create(RT.seq(coll));
}

———-

8.66 LazySeq.java

— LazySeq.java —

\getchunk{Clojure Copyright}
/* rich Jan 31, 2009 */

package clojure.lang;

import java.util.*;

public final class LazySeq extends Obj implements ISeq, List{

private IFn fn;

private Object sv;
private ISeq s;

public LazySeq(IFn fn){

this.fn = fn;
}
696 CHAPTER 8. JVM/CLOJURE/LANG/

private LazySeq(IPersistentMap meta, ISeq s){

super(meta);
this.fn = null;
this.s = s;
}

public Obj withMeta(IPersistentMap meta){

return new LazySeq(meta, seq());
}

final synchronized Object sval(){

if(fn != null)
{
try
{
sv = fn.invoke();
fn = null;
}
catch(RuntimeException e)
{
throw e;
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}
if(sv != null)
return sv;
return s;
}

final synchronized public ISeq seq(){

sval();
if(sv != null)
{
Object ls = sv;
sv = null;
while(ls instanceof LazySeq)
{
ls = ((LazySeq)ls).sval();
}
s = RT.seq(ls);
}
return s;
}

public int count(){

int c = 0;
8.66. LAZYSEQ.JAVA 697

for(ISeq s = seq(); s != null; s = s.next())

++c;
return c;
}

public Object first(){

seq();
if(s == null)
return null;
return s.first();
}

public ISeq next(){

seq();
if(s == null)
return null;
return s.next();
}

public ISeq more(){

seq();
if(s == null)
return PersistentList.EMPTY;
return s.more();
}

public ISeq cons(Object o){

return RT.cons(o, seq());
}

public IPersistentCollection empty(){

return PersistentList.EMPTY;
}

public boolean equiv(Object o){

return equals(o);
}

public int hashCode(){

ISeq s = seq();
if(s == null)
return 1;
return Util.hash(seq());
}

public boolean equals(Object o){

ISeq s = seq();
if(s != null)
return s.equiv(o);
else
698 CHAPTER 8. JVM/CLOJURE/LANG/

return (o instanceof Sequential ||

o instanceof List) &&
RT.seq(o) == null;
}

// java.util.Collection implementation

public Object[] toArray(){

return RT.seqToArray(seq());
}

public boolean add(Object o){

throw new UnsupportedOperationException();
}

public boolean remove(Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(Collection c){

throw new UnsupportedOperationException();
}

public void clear(){

throw new UnsupportedOperationException();
}

public boolean retainAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean removeAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean containsAll(Collection c){

for(Object o : c)
{
if(!contains(o))
return false;
}
return true;
}

public Object[] toArray(Object[] a){

if(a.length >= count())
{
ISeq s = seq();
for(int i = 0; s != null; ++i, s = s.next())
8.66. LAZYSEQ.JAVA 699

{
a[i] = s.first();
}
if(a.length > count())
a[count()] = null;
return a;
}
else
return toArray();
}

public int size(){

return count();
}

public boolean isEmpty(){

return seq() == null;
}

public boolean contains(Object o){

for(ISeq s = seq(); s != null; s = s.next())
{
if(Util.equiv(s.first(), o))
return true;
}
return false;
}

public Iterator iterator(){

return new SeqIterator(seq());
}

//////////// List stuff /////////////////

private List reify(){
return new ArrayList(this);
}

public List subList(int fromIndex, int toIndex){

return reify().subList(fromIndex, toIndex);
}

public Object set(int index, Object element){

throw new UnsupportedOperationException();
}

public Object remove(int index){

throw new UnsupportedOperationException();
}

public int indexOf(Object o){

700 CHAPTER 8. JVM/CLOJURE/LANG/

ISeq s = seq();
for(int i = 0; s != null; s = s.next(), i++)
{
if(Util.equiv(s.first(), o))
return i;
}
return -1;
}

public int lastIndexOf(Object o){

return reify().lastIndexOf(o);
}

public ListIterator listIterator(){

return reify().listIterator();
}

public ListIterator listIterator(int index){

return reify().listIterator(index);
}

public Object get(int index){

return RT.nth(this, index);
}

public void add(int index, Object element){

throw new UnsupportedOperationException();
}

public boolean addAll(int index, Collection c){

throw new UnsupportedOperationException();
}

———-

8.67 LineNumberingPushbackReader.java

— LineNumberingPushbackReader.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.PushbackReader;
import java.io.Reader;
8.67. LINENUMBERINGPUSHBACKREADER.JAVA 701

import java.io.LineNumberReader;
import java.io.IOException;

public class LineNumberingPushbackReader extends PushbackReader{

// This class is a PushbackReader that wraps a LineNumberReader. The code

// here to handle line terminators only mentions ’\n’ because
// LineNumberReader collapses all occurrences of CR, LF, and CRLF into a
// single ’\n’.

private static final int newline = (int) ’\n’;

private boolean _atLineStart = true;

private boolean _prev;

public LineNumberingPushbackReader(Reader r){

super(new LineNumberReader(r));
}

public int getLineNumber(){

return ((LineNumberReader) in).getLineNumber() + 1;
}

public int read() throws IOException{

int c = super.read();
_prev = _atLineStart;
_atLineStart = (c == newline) || (c == -1);
return c;
}

public void unread(int c) throws IOException{

super.unread(c);
_atLineStart = _prev;
}

public String readLine() throws IOException{

int c = read();
String line;
switch (c) {
case -1:
line = null;
break;
case newline:
line = "";
break;
default:
String first = String.valueOf((char) c);
String rest = ((LineNumberReader)in).readLine();
line = (rest == null) ? first : first + rest;
702 CHAPTER 8. JVM/CLOJURE/LANG/

_prev = false;
_atLineStart = true;
break;
}
return line;
}

public boolean atLineStart(){

return _atLineStart;
}
}

———-

8.68 LispReader.java

— LispReader.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.math.BigInteger;
import java.math.BigDecimal;
import java.lang.*;

public class LispReader{

static final Symbol QUOTE = Symbol.intern("quote");

static final Symbol THE_VAR = Symbol.intern("var");
//static Symbol SYNTAX_QUOTE = Symbol.intern(null, "syntax-quote");
static Symbol UNQUOTE = Symbol.intern("clojure.core", "unquote");
static Symbol UNQUOTE_SPLICING =
Symbol.intern("clojure.core", "unquote-splicing");
static Symbol CONCAT = Symbol.intern("clojure.core", "concat");
static Symbol SEQ = Symbol.intern("clojure.core", "seq");
static Symbol LIST = Symbol.intern("clojure.core", "list");
static Symbol APPLY = Symbol.intern("clojure.core", "apply");
static Symbol HASHMAP = Symbol.intern("clojure.core", "hash-map");
static Symbol HASHSET = Symbol.intern("clojure.core", "hash-set");
static Symbol VECTOR = Symbol.intern("clojure.core", "vector");
static Symbol WITH_META = Symbol.intern("clojure.core", "with-meta");
8.68. LISPREADER.JAVA 703

static Symbol META = Symbol.intern("clojure.core", "meta");

static Symbol DEREF = Symbol.intern("clojure.core", "deref");
//static Symbol DEREF_BANG = Symbol.intern("clojure.core", "deref!");

static IFn[] macros = new IFn[256];

static IFn[] dispatchMacros = new IFn[256];
//static Pattern symbolPat =
Pattern.compile("[:]?([\\D&&[^:/]][^:/]*/)?[\\D&&[^:/]][^:/]*");
static Pattern symbolPat =
Pattern.compile("[:]?([\\D&&[^/]].*/)?([\\D&&[^/]][^/]*)");
//static Pattern varPat =
Pattern.compile("([\\D&&[^:\\.]][^:\\.]*):([\\D&&[^:\\.]][^:\\.]*)");
//static Pattern intPat = Pattern.compile("[-+]?[0-9]+\\.?");
static Pattern intPat =
Pattern.compile(
"([-+]?)(?:(0)|([1-9][0-9]*)|0[xX]([0-9A-Fa-f]+)|0([0-7]+)"+"
"|([1-9][0-9]?)[rR]([0-9A-Za-z]+)|0[0-9]+)(N)?");
static Pattern ratioPat = Pattern.compile("([-+]?[0-9]+)/([0-9]+)");
static Pattern floatPat =
Pattern.compile("([-+]?[0-9]+(\\.[0-9]*)?([eE][-+]?[0-9]+)?)(M)?");
static final Symbol SLASH = Symbol.intern("/");
static final Symbol CLOJURE_SLASH = Symbol.intern("clojure.core","/");
//static Pattern accessorPat = Pattern.compile("\\.[a-zA-Z_]\\w*");
//static Pattern instanceMemberPat =
Pattern.compile("\\.([a-zA-Z_][\\w\\.]*)\\.([a-zA-Z_]\\w*)");
//static Pattern staticMemberPat =
Pattern.compile("([a-zA-Z_][\\w\\.]*)\\.([a-zA-Z_]\\w*)");
//static Pattern classNamePat =
// Pattern.compile("([a-zA-Z_][\\w\\.]*)\\.");

//symbol->gensymbol
static Var GENSYM_ENV = Var.create(null).setDynamic();
//sorted-map num->gensymbol
static Var ARG_ENV = Var.create(null).setDynamic();

static
{
macros[’"’] = new StringReader();
macros[’;’] = new CommentReader();
macros[’\’’] = new WrappingReader(QUOTE);
macros[’@’] = new WrappingReader(DEREF);//new DerefReader();
macros[’^’] = new MetaReader();
macros[’‘’] = new SyntaxQuoteReader();
macros[’~’] = new UnquoteReader();
macros[’(’] = new ListReader();
macros[’)’] = new UnmatchedDelimiterReader();
macros[’[’] = new VectorReader();
macros[’]’] = new UnmatchedDelimiterReader();
macros[’{’] = new MapReader();
macros[’}’] = new UnmatchedDelimiterReader();
704 CHAPTER 8. JVM/CLOJURE/LANG/

// macros[’|’] = new ArgVectorReader();

macros[’\\’] = new CharacterReader();
macros[’%’] = new ArgReader();
macros[’#’] = new DispatchReader();

dispatchMacros[’^’] = new MetaReader();

dispatchMacros[’\’’] = new VarReader();
dispatchMacros[’"’] = new RegexReader();
dispatchMacros[’(’] = new FnReader();
dispatchMacros[’{’] = new SetReader();
dispatchMacros[’=’] = new EvalReader();
dispatchMacros[’!’] = new CommentReader();
dispatchMacros[’<’] = new UnreadableReader();
dispatchMacros[’_’] = new DiscardReader();
}

static boolean isWhitespace(int ch){

return Character.isWhitespace(ch) || ch == ’,’;
}

static void unread(PushbackReader r, int ch) throws IOException{

if(ch != -1)
r.unread(ch);
}

public static class ReaderException extends Exception{

final int line;

public ReaderException(int line, Throwable cause){

super(cause);
this.line = line;
}
}

static public Object read(PushbackReader r,

boolean eofIsError,
Object eofValue,
boolean isRecursive)
throws Exception{

try
{
for(; ;)
{
int ch = r.read();

while(isWhitespace(ch))
ch = r.read();
8.68. LISPREADER.JAVA 705

if(ch == -1)
{
if(eofIsError)
throw new Exception("EOF while reading");
return eofValue;
}

if(Character.isDigit(ch))
{
Object n = readNumber(r, (char) ch);
if(RT.suppressRead())
return null;
return n;
}

IFn macroFn = getMacro(ch);

if(macroFn != null)
{
Object ret = macroFn.invoke(r, (char) ch);
if(RT.suppressRead())
return null;
//no op macros return the reader
if(ret == r)
continue;
return ret;
}

if(ch == ’+’ || ch == ’-’)

{
int ch2 = r.read();
if(Character.isDigit(ch2))
{
unread(r, ch2);
Object n = readNumber(r, (char) ch);
if(RT.suppressRead())
return null;
return n;
}
unread(r, ch2);
}

String token = readToken(r, (char) ch);

if(RT.suppressRead())
return null;
return interpretToken(token);
}
}
catch(Exception e)
{
if(isRecursive || !(r instanceof LineNumberingPushbackReader))
706 CHAPTER 8. JVM/CLOJURE/LANG/

throw e;
LineNumberingPushbackReader rdr =
(LineNumberingPushbackReader) r;
//throw new Exception(String.format("ReaderError:(%d,1) %s",
// rdr.getLineNumber(), e.getMessage()), e);
throw new ReaderException(rdr.getLineNumber(), e);
}
}

static private String readToken(PushbackReader r, char initch)

throws Exception{
StringBuilder sb = new StringBuilder();
sb.append(initch);

for(; ;)
{
int ch = r.read();
if(ch == -1 || isWhitespace(ch) || isTerminatingMacro(ch))
{
unread(r, ch);
return sb.toString();
}
sb.append((char) ch);
}
}

static private Object readNumber(PushbackReader r, char initch)

throws Exception{
StringBuilder sb = new StringBuilder();
sb.append(initch);

for(; ;)
{
int ch = r.read();
if(ch == -1 || isWhitespace(ch) || isMacro(ch))
{
unread(r, ch);
break;
}
sb.append((char) ch);
}

String s = sb.toString();
Object n = matchNumber(s);
if(n == null)
throw new NumberFormatException("Invalid number: " + s);
return n;
}

static private int readUnicodeChar(String token,

8.68. LISPREADER.JAVA 707

int offset,
int length,
int base)
throws Exception{
if(token.length() != offset + length)
throw new IllegalArgumentException(
"Invalid unicode character: \\" + token);
int uc = 0;
for(int i = offset; i < offset + length; ++i)
{
int d = Character.digit(token.charAt(i), base);
if(d == -1)
throw new IllegalArgumentException(
"Invalid digit: " + (char) d);
uc = uc * base + d;
}
return (char) uc;
}

static private int readUnicodeChar(PushbackReader r,

int initch,
int base,
int length,
boolean exact)
throws Exception{
int uc = Character.digit(initch, base);
if(uc == -1)
throw new IllegalArgumentException("Invalid digit: " + initch);
int i = 1;
for(; i < length; ++i)
{
int ch = r.read();
if(ch == -1 || isWhitespace(ch) || isMacro(ch))
{
unread(r, ch);
break;
}
int d = Character.digit(ch, base);
if(d == -1)
throw new IllegalArgumentException(
"Invalid digit: " + (char) ch);
uc = uc * base + d;
}
if(i != length && exact)
throw new IllegalArgumentException(
"Invalid character length: " + i + ", should be: " + length);
return uc;
}

static private Object interpretToken(String s) throws Exception{

708 CHAPTER 8. JVM/CLOJURE/LANG/

if(s.equals("nil"))
{
return null;
}
else if(s.equals("true"))
{
return RT.T;
}
else if(s.equals("false"))
{
return RT.F;
}
else if(s.equals("/"))
{
return SLASH;
}
else if(s.equals("clojure.core//"))
{
return CLOJURE_SLASH;
}
Object ret = null;

ret = matchSymbol(s);
if(ret != null)
return ret;

throw new Exception("Invalid token: " + s);

}

private static Object matchSymbol(String s){

Matcher m = symbolPat.matcher(s);
if(m.matches())
{
int gc = m.groupCount();
String ns = m.group(1);
String name = m.group(2);
if(ns != null && ns.endsWith(":/")
|| name.endsWith(":")
|| s.indexOf("::", 1) != -1)
return null;
if(s.startsWith("::"))
{
Symbol ks = Symbol.intern(s.substring(2));
Namespace kns;
if(ks.ns != null)
kns = Compiler.namespaceFor(ks);
else
kns = Compiler.currentNS();
//auto-resolving keyword
8.68. LISPREADER.JAVA 709

if (kns != null)
return Keyword.intern(kns.name.name,ks.name);
else
return null;
}
boolean isKeyword = s.charAt(0) == ’:’;
Symbol sym = Symbol.intern(s.substring(isKeyword ? 1 : 0));
if(isKeyword)
return Keyword.intern(sym);
return sym;
}
return null;
}

private static Object matchNumber(String s){

Matcher m = intPat.matcher(s);
if(m.matches())
{
if(m.group(2) != null)
{
if(m.group(8) != null)
return BigInt.ZERO;
return Numbers.num(0);
}
boolean negate = (m.group(1).equals("-"));
String n;
int radix = 10;
if((n = m.group(3)) != null)
radix = 10;
else if((n = m.group(4)) != null)
radix = 16;
else if((n = m.group(5)) != null)
radix = 8;
else if((n = m.group(7)) != null)
radix = Integer.parseInt(m.group(6));
if(n == null)
return null;
BigInteger bn = new BigInteger(n, radix);
if(negate)
bn = bn.negate();
if(m.group(8) != null)
return BigInt.fromBigInteger(bn);
return bn.bitLength() < 64 ?
Numbers.num(bn.longValue())
: BigInt.fromBigInteger(bn);
}
m = floatPat.matcher(s);
if(m.matches())
{
710 CHAPTER 8. JVM/CLOJURE/LANG/

if(m.group(4) != null)
return new BigDecimal(m.group(1));
return Double.parseDouble(s);
}
m = ratioPat.matcher(s);
if(m.matches())
{
return
Numbers.divide(
Numbers.reduceBigInt(
BigInt.fromBigInteger(new BigInteger(m.group(1)))),
Numbers.reduceBigInt(
BigInt.fromBigInteger(new BigInteger(m.group(2)))));
}
return null;
}

static private IFn getMacro(int ch){

if(ch < macros.length)
return macros[ch];
return null;
}

static private boolean isMacro(int ch){

return (ch < macros.length && macros[ch] != null);
}

static private boolean isTerminatingMacro(int ch){

return (ch != ’#’ && ch != ’\’’ && isMacro(ch));
}

public static class RegexReader extends AFn{

static StringReader stringrdr = new StringReader();

public Object invoke(Object reader, Object doublequote)

throws Exception{
StringBuilder sb = new StringBuilder();
Reader r = (Reader) reader;
for(int ch = r.read(); ch != ’"’; ch = r.read())
{
if(ch == -1)
throw new Exception("EOF while reading regex");
sb.append( (char) ch );
if(ch == ’\\’) //escape
{
ch = r.read();
if(ch == -1)
throw new Exception("EOF while reading regex");
sb.append( (char) ch ) ;
}
8.68. LISPREADER.JAVA 711

}
return Pattern.compile(sb.toString());
}
}

public static class StringReader extends AFn{

public Object invoke(Object reader, Object doublequote)
throws Exception{
StringBuilder sb = new StringBuilder();
Reader r = (Reader) reader;

for(int ch = r.read(); ch != ’"’; ch = r.read())

{
if(ch == -1)
throw new Exception("EOF while reading string");
if(ch == ’\\’) //escape
{
ch = r.read();
if(ch == -1)
throw new Exception("EOF while reading string");
switch(ch)
{
case ’t’:
ch = ’\t’;
break;
case ’r’:
ch = ’\r’;
break;
case ’n’:
ch = ’\n’;
break;
case ’\\’:
break;
case ’"’:
break;
case ’b’:
ch = ’\b’;
break;
case ’f’:
ch = ’\f’;
break;
case ’u’:
{
ch = r.read();
if (Character.digit(ch, 16) == -1)
throw new Exception(
"Invalid unicode escape: \\u" + (char) ch);
ch =
readUnicodeChar((PushbackReader) r,ch,16,4,true);
break;
712 CHAPTER 8. JVM/CLOJURE/LANG/

}
default:
{
if(Character.isDigit(ch))
{
ch =
readUnicodeChar(
(PushbackReader) r,ch,8,3,false);
if(ch > 0377)
throw new Exception(
"Octal escape sequence must be in range [0, 377].");
}
else
throw new Exception(
"Unsupported escape character: \\" + (char) ch);
}
}
}
sb.append((char) ch);
}
return sb.toString();
}
}

public static class CommentReader extends AFn{

public Object invoke(Object reader, Object semicolon)
throws Exception{
Reader r = (Reader) reader;
int ch;
do
{
ch = r.read();
} while(ch != -1 && ch != ’\n’ && ch != ’\r’);
return r;
}

public static class DiscardReader extends AFn{

public Object invoke(Object reader, Object underscore)
throws Exception{
PushbackReader r = (PushbackReader) reader;
read(r, true, null, true);
return r;
}
}

public static class WrappingReader extends AFn{

final Symbol sym;
8.68. LISPREADER.JAVA 713

public WrappingReader(Symbol sym){

this.sym = sym;
}

public Object invoke(Object reader, Object quote)

throws Exception{
PushbackReader r = (PushbackReader) reader;
Object o = read(r, true, null, true);
return RT.list(sym, o);
}

public static class DeprecatedWrappingReader extends AFn{

final Symbol sym;
final String macro;

public DeprecatedWrappingReader(Symbol sym, String macro){

this.sym = sym;
this.macro = macro;
}

public Object invoke(Object reader, Object quote)

throws Exception{
System.out.println("WARNING: reader macro " + macro +
" is deprecated; use " + sym.getName() +
" instead");
PushbackReader r = (PushbackReader) reader;
Object o = read(r, true, null, true);
return RT.list(sym, o);
}

public static class VarReader extends AFn{

public Object invoke(Object reader, Object quote)
throws Exception{
PushbackReader r = (PushbackReader) reader;
Object o = read(r, true, null, true);
// if(o instanceof Symbol)
// {
// Object v =
// Compiler.maybeResolveIn(Compiler.currentNS(),
// (Symbol) o);
// if(v instanceof Var)
// return v;
// }
return RT.list(THE_VAR, o);
}
}
714 CHAPTER 8. JVM/CLOJURE/LANG/

/*
static class DerefReader extends AFn{

public Object invoke(Object reader, Object quote)

throws Exception{
PushbackReader r = (PushbackReader) reader;
int ch = r.read();
if(ch == -1)
throw new Exception("EOF while reading character");
if(ch == ’!’)
{
Object o = read(r, true, null, true);
return RT.list(DEREF_BANG, o);
}
else
{
r.unread(ch);
Object o = read(r, true, null, true);
return RT.list(DEREF, o);
}
}

}
*/

public static class DispatchReader extends AFn{

public Object invoke(Object reader, Object hash)
throws Exception{
int ch = ((Reader) reader).read();
if(ch == -1)
throw new Exception("EOF while reading character");
IFn fn = dispatchMacros[ch];
if(fn == null)
throw new Exception(
String.format("No dispatch macro for: %c", (char) ch));
return fn.invoke(reader, ch);
}
}

static Symbol garg(int n){

return Symbol.intern(null,
(n == -1 ? "rest" : ("p" + n)) + "__" + RT.nextID() + "#");
}

public static class FnReader extends AFn{

public Object invoke(Object reader, Object lparen)
throws Exception{
PushbackReader r = (PushbackReader) reader;
if(ARG_ENV.deref() != null)
8.68. LISPREADER.JAVA 715

throw new IllegalStateException(

"Nested #()s are not allowed");
try
{
Var.pushThreadBindings(
RT.map(ARG_ENV, PersistentTreeMap.EMPTY));
r.unread(’(’);
Object form = read(r, true, null, true);

PersistentVector args = PersistentVector.EMPTY;

PersistentTreeMap argsyms =
(PersistentTreeMap) ARG_ENV.deref();
ISeq rargs = argsyms.rseq();
if(rargs != null)
{
int higharg =
(Integer) ((Map.Entry) rargs.first()).getKey();
if(higharg > 0)
{
for(int i = 1; i <= higharg; ++i)
{
Object sym = argsyms.valAt(i);
if(sym == null)
sym = garg(i);
args = args.cons(sym);
}
}
Object restsym = argsyms.valAt(-1);
if(restsym != null)
{
args = args.cons(Compiler._AMP_);
args = args.cons(restsym);
}
}
return RT.list(Compiler.FN, args, form);
}
finally
{
Var.popThreadBindings();
}
}
}

static Symbol registerArg(int n){

PersistentTreeMap argsyms = (PersistentTreeMap) ARG_ENV.deref();
if(argsyms == null)
{
throw new IllegalStateException("arg literal not in #()");
}
Symbol ret = (Symbol) argsyms.valAt(n);
716 CHAPTER 8. JVM/CLOJURE/LANG/

if(ret == null)
{
ret = garg(n);
ARG_ENV.set(argsyms.assoc(n, ret));
}
return ret;
}

static class ArgReader extends AFn{

public Object invoke(Object reader, Object pct) throws Exception{
PushbackReader r = (PushbackReader) reader;
if(ARG_ENV.deref() == null)
{
return interpretToken(readToken(r, ’%’));
}
int ch = r.read();
unread(r, ch);
//% alone is first arg
if(ch == -1 || isWhitespace(ch) || isTerminatingMacro(ch))
{
return registerArg(1);
}
Object n = read(r, true, null, true);
if(n.equals(Compiler._AMP_))
return registerArg(-1);
if(!(n instanceof Number))
throw new IllegalStateException(
"arg literal must be %, %& or %integer");
return registerArg(((Number) n).intValue());
}
}

public static class MetaReader extends AFn{

public Object invoke(Object reader, Object caret)
throws Exception{
PushbackReader r = (PushbackReader) reader;
int line = -1;
if(r instanceof LineNumberingPushbackReader)
line = ((LineNumberingPushbackReader) r).getLineNumber();
Object meta = read(r, true, null, true);
if(meta instanceof Symbol || meta instanceof String)
meta = RT.map(RT.TAG_KEY, meta);
else if (meta instanceof Keyword)
meta = RT.map(meta, RT.T);
else if(!(meta instanceof IPersistentMap))
throw new IllegalArgumentException(
"Metadata must be Symbol,Keyword,String or Map");

Object o = read(r, true, null, true);

if(o instanceof IMeta)
8.68. LISPREADER.JAVA 717

{
if(line != -1 && o instanceof ISeq)
meta = ((IPersistentMap) meta).assoc(RT.LINE_KEY, line);
if(o instanceof IReference)
{
((IReference)o).resetMeta((IPersistentMap) meta);
return o;
}
Object ometa = RT.meta(o);
for(ISeq s = RT.seq(meta); s != null; s = s.next()) {
IMapEntry kv = (IMapEntry) s.first();
ometa = RT.assoc(ometa, kv.getKey(), kv.getValue());
}
return ((IObj) o).withMeta((IPersistentMap) ometa);
}
else
throw new IllegalArgumentException(
"Metadata can only be applied to IMetas");
}

public static class SyntaxQuoteReader extends AFn{

public Object invoke(Object reader, Object backquote)
throws Exception{
PushbackReader r = (PushbackReader) reader;
try
{
Var.pushThreadBindings(
RT.map(GENSYM_ENV, PersistentHashMap.EMPTY));

Object form = read(r, true, null, true);

return syntaxQuote(form);
}
finally
{
Var.popThreadBindings();
}
}

static Object syntaxQuote(Object form) throws Exception{

Object ret;
if(Compiler.isSpecial(form))
ret = RT.list(Compiler.QUOTE, form);
else if(form instanceof Symbol)
{
Symbol sym = (Symbol) form;
if(sym.ns == null && sym.name.endsWith("#"))
{
IPersistentMap gmap =
718 CHAPTER 8. JVM/CLOJURE/LANG/

(IPersistentMap) GENSYM_ENV.deref();
if(gmap == null)
throw new IllegalStateException(
"Gensym literal not in syntax-quote");
Symbol gs = (Symbol) gmap.valAt(sym);
if(gs == null)
GENSYM_ENV.set(
gmap.assoc(sym,
gs = Symbol.intern(null,
sym.name.substring(0, sym.name.length() - 1)
+ "__" + RT.nextID() + "__auto__")));
sym = gs;
}
else if(sym.ns == null && sym.name.endsWith("."))
{
Symbol csym =
Symbol.intern(null,
sym.name.substring(0, sym.name.length() - 1));
csym = Compiler.resolveSymbol(csym);
sym = Symbol.intern(null, csym.name.concat("."));
}
else if(sym.ns == null && sym.name.startsWith("."))
{
// Simply quote method names.
}
else
{
Object maybeClass = null;
if(sym.ns != null)
maybeClass = Compiler.currentNS().getMapping(
Symbol.intern(null, sym.ns));
if(maybeClass instanceof Class)
{
// Classname/foo ->
// package.qualified.Classname/foo
sym = Symbol.intern(
((Class)maybeClass).getName(), sym.name);
}
else
sym = Compiler.resolveSymbol(sym);
}
ret = RT.list(Compiler.QUOTE, sym);
}
else if(isUnquote(form))
return RT.second(form);
else if(isUnquoteSplicing(form))
throw new IllegalStateException("splice not in list");
else if(form instanceof IPersistentCollection)
{
if(form instanceof IPersistentMap)
8.68. LISPREADER.JAVA 719

{
IPersistentVector keyvals = flattenMap(form);
ret = RT.list(APPLY, HASHMAP,
RT.list(SEQ,
RT.cons(CONCAT, sqExpandList(keyvals.seq()))));
}
else if(form instanceof IPersistentVector)
{
ret = RT.list(APPLY, VECTOR,
RT.list(SEQ,
RT.cons(CONCAT,
sqExpandList(
((IPersistentVector) form).seq()))));
}
else if(form instanceof IPersistentSet)
{
ret = RT.list(APPLY, HASHSET,
RT.list(SEQ,
RT.cons(CONCAT,
sqExpandList(
((IPersistentSet) form).seq()))));
}
else if(form instanceof ISeq ||
form instanceof IPersistentList)
{
ISeq seq = RT.seq(form);
if(seq == null)
ret = RT.cons(LIST,null);
else
ret =
RT.list(SEQ, RT.cons(CONCAT, sqExpandList(seq)));
}
else
throw new UnsupportedOperationException(
"Unknown Collection type");
}
else if(form instanceof Keyword
|| form instanceof Number
|| form instanceof Character
|| form instanceof String)
ret = form;
else
ret = RT.list(Compiler.QUOTE, form);

if(form instanceof IObj && RT.meta(form) != null)

{
//filter line numbers
IPersistentMap newMeta =
((IObj) form).meta().without(RT.LINE_KEY);
if(newMeta.count() > 0)
720 CHAPTER 8. JVM/CLOJURE/LANG/

return
RT.list(WITH_META, ret,
syntaxQuote(((IObj) form).meta()));
}
return ret;
}

private static ISeq sqExpandList(ISeq seq) throws Exception{

PersistentVector ret = PersistentVector.EMPTY;
for(; seq != null; seq = seq.next())
{
Object item = seq.first();
if(isUnquote(item))
ret = ret.cons(RT.list(LIST, RT.second(item)));
else if(isUnquoteSplicing(item))
ret = ret.cons(RT.second(item));
else
ret = ret.cons(RT.list(LIST, syntaxQuote(item)));
}
return ret.seq();
}

private static IPersistentVector flattenMap(Object form){

IPersistentVector keyvals = PersistentVector.EMPTY;
for(ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry) s.first();
keyvals = (IPersistentVector) keyvals.cons(e.key());
keyvals = (IPersistentVector) keyvals.cons(e.val());
}
return keyvals;
}

static boolean isUnquoteSplicing(Object form){

return form instanceof ISeq &&
Util.equals(RT.first(form),UNQUOTE_SPLICING);
}

static boolean isUnquote(Object form){

return form instanceof ISeq && Util.equals(RT.first(form),UNQUOTE);
}

static class UnquoteReader extends AFn{

public Object invoke(Object reader, Object comma) throws Exception{
PushbackReader r = (PushbackReader) reader;
int ch = r.read();
if(ch == -1)
throw new Exception("EOF while reading character");
8.68. LISPREADER.JAVA 721

if(ch == ’@’)
{
Object o = read(r, true, null, true);
return RT.list(UNQUOTE_SPLICING, o);
}
else
{
unread(r, ch);
Object o = read(r, true, null, true);
return RT.list(UNQUOTE, o);
}
}

public static class CharacterReader extends AFn{

public Object invoke(Object reader, Object backslash)
throws Exception{
PushbackReader r = (PushbackReader) reader;
int ch = r.read();
if(ch == -1)
throw new Exception("EOF while reading character");
String token = readToken(r, (char) ch);
if(token.length() == 1)
return Character.valueOf(token.charAt(0));
else if(token.equals("newline"))
return ’\n’;
else if(token.equals("space"))
return ’ ’;
else if(token.equals("tab"))
return ’\t’;
else if(token.equals("backspace"))
return ’\b’;
else if(token.equals("formfeed"))
return ’\f’;
else if(token.equals("return"))
return ’\r’;
else if(token.startsWith("u"))
{
char c = (char) readUnicodeChar(token, 1, 4, 16);
if(c >= ’\uD800’ && c <= ’\uDFFF’) // surrogate code unit?
throw new Exception(
"Invalid character constant: \\u" +
Integer.toString(c, 16));
return c;
}
else if(token.startsWith("o"))
{
int len = token.length() - 1;
if(len > 3)
722 CHAPTER 8. JVM/CLOJURE/LANG/

throw new Exception(

"Invalid octal escape sequence length: " + len);
int uc = readUnicodeChar(token, 1, len, 8);
if(uc > 0377)
throw new Exception(
"Octal escape sequence must be in range [0, 377].");
return (char) uc;
}
throw new Exception("Unsupported character: \\" + token);
}

public static class ListReader extends AFn{

public Object invoke(Object reader, Object leftparen)
throws Exception{
PushbackReader r = (PushbackReader) reader;
int line = -1;
if(r instanceof LineNumberingPushbackReader)
line = ((LineNumberingPushbackReader) r).getLineNumber();
List list = readDelimitedList(’)’, r, true);
if(list.isEmpty())
return PersistentList.EMPTY;
IObj s = (IObj) PersistentList.create(list);
// IObj s = (IObj) RT.seq(list);
if(line != -1)
return s.withMeta(RT.map(RT.LINE_KEY, line));
else
return s;
}

static class CtorReader extends AFn{

static final Symbol cls = Symbol.intern("class");

public Object invoke(Object reader, Object leftangle)

throws Exception{
PushbackReader r = (PushbackReader) reader;
// #<class classname>
// #<classname args*>
// #<classname/staticMethod args*>
List list = readDelimitedList(’>’, r, true);
if(list.isEmpty())
throw new Exception(
"Must supply ’class’, classname or classname/staticMethod");
Symbol s = (Symbol) list.get(0);
Object[] args = list.subList(1, list.size()).toArray();
if(s.equals(cls))
{
8.68. LISPREADER.JAVA 723

return RT.classForName(args[0].toString());
}
else if(s.ns != null) //static method
{
String classname = s.ns;
String method = s.name;
return Reflector.invokeStaticMethod(classname, method, args);
}
else
{
return
Reflector.invokeConstructor(RT.classForName(s.name), args);
}
}

public static class EvalReader extends AFn{

public Object invoke(Object reader, Object eq) throws Exception{
if (!RT.booleanCast(RT.READEVAL.deref()))
{
throw new Exception(
"EvalReader not allowed when *read-eval* is false.");
}

PushbackReader r = (PushbackReader) reader;

Object o = read(r, true, null, true);
if(o instanceof Symbol)
{
return RT.classForName(o.toString());
}
else if(o instanceof IPersistentList)
{
Symbol fs = (Symbol) RT.first(o);
if(fs.equals(THE_VAR))
{
Symbol vs = (Symbol) RT.second(o);
//Compiler.resolve((Symbol) RT.second(o),true);
return RT.var(vs.ns, vs.name);
}
if(fs.name.endsWith("."))
{
Object[] args = RT.toArray(RT.next(o));
return
Reflector.invokeConstructor(
RT.classForName(
fs.name.substring(0, fs.name.length() - 1)),
args);
}
if(Compiler.namesStaticMember(fs))
724 CHAPTER 8. JVM/CLOJURE/LANG/

{
Object[] args = RT.toArray(RT.next(o));
return
Reflector.invokeStaticMethod(
fs.ns, fs.name, args);
}
Object v =
Compiler.maybeResolveIn(Compiler.currentNS(), fs);
if(v instanceof Var)
{
return ((IFn) v).applyTo(RT.next(o));
}
throw new Exception("Can’t resolve " + fs);
}
else
throw new IllegalArgumentException("Unsupported #= form");
}
}

//static class ArgVectorReader extends AFn{

// public Object invoke(Object reader, Object leftparen)
// throws Exception{
// PushbackReader r = (PushbackReader) reader;
// return ArgVector.create(readDelimitedList(’|’, r, true));
// }
//
//}

public static class VectorReader extends AFn{

public Object invoke(Object reader, Object leftparen)
throws Exception{
PushbackReader r = (PushbackReader) reader;
return LazilyPersistentVector
.create(readDelimitedList(’]’, r, true));
}

public static class MapReader extends AFn{

public Object invoke(Object reader, Object leftparen)
throws Exception{
PushbackReader r = (PushbackReader) reader;
return RT.map(readDelimitedList(’}’, r, true).toArray());
}

public static class SetReader extends AFn{

public Object invoke(Object reader, Object leftbracket)
throws Exception{
8.68. LISPREADER.JAVA 725

PushbackReader r = (PushbackReader) reader;

return PersistentHashSet
.createWithCheck(readDelimitedList(’}’, r, true));
}

public static class UnmatchedDelimiterReader extends AFn{

public Object invoke(Object reader, Object rightdelim)
throws Exception{
throw new Exception("Unmatched delimiter: " + rightdelim);
}

public static class UnreadableReader extends AFn{

public Object invoke(Object reader, Object leftangle)
throws Exception{
throw new Exception("Unreadable form");
}
}

public static List readDelimitedList(char delim,

PushbackReader r,
boolean isRecursive)
throws Exception{
final int firstline =
(r instanceof LineNumberingPushbackReader) ?
((LineNumberingPushbackReader) r).getLineNumber() : -1;

ArrayList a = new ArrayList();

for(; ;)
{
int ch = r.read();

while(isWhitespace(ch))
ch = r.read();

if(ch == -1)
{
if(firstline < 0)
throw new Exception("EOF while reading");
else
throw new Exception(
"EOF while reading, starting at line " + firstline);
}

if(ch == delim)
break;
726 CHAPTER 8. JVM/CLOJURE/LANG/

IFn macroFn = getMacro(ch);

if(macroFn != null)
{
Object mret = macroFn.invoke(r, (char) ch);
//no op macros return the reader
if(mret != r)
a.add(mret);
}
else
{
unread(r, ch);

Object o = read(r, true, null, isRecursive);

if(o != r)
a.add(o);
}
}

return a;
}

/*
public static void main(String[] args)
throws Exception{
//RT.init();
PushbackReader rdr =
new PushbackReader( new java.io.StringReader( "(+ 21 21)" ) );
Object input = LispReader.read(rdr, false, new Object(), false );
System.out.println(Compiler.eval(input));
}

public static void main(String[] args){

LineNumberingPushbackReader r =
new LineNumberingPushbackReader(
new InputStreamReader(System.in));
OutputStreamWriter w = new OutputStreamWriter(System.out);
Object ret = null;
try
{
for(; ;)
{
ret = LispReader.read(r, true, null, false);
RT.print(ret, w);
w.write(’\n’);
if(ret != null)
w.write(ret.getClass().toString());
w.write(’\n’);
w.flush();
8.69. LOCKINGTRANSACTION.JAVA 727

}
}
catch(Exception e)
{
e.printStackTrace();
}
}
*/

———-

8.69 LockingTransaction.java

— LockingTransaction.java —

\getchunk{Clojure Copyright}
/* rich Jul 26, 2007 */

package clojure.lang;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.CountDownLatch;

@SuppressWarnings({"SynchronizeOnNonFinalField"})
public class LockingTransaction{

public static final int RETRY_LIMIT = 10000;

public static final int LOCK_WAIT_MSECS = 100;
public static final long BARGE_WAIT_NANOS = 10 * 1000000;
//public static int COMMUTE_RETRY_LIMIT = 10;

static final int RUNNING = 0;

static final int COMMITTING = 1;
static final int RETRY = 2;
static final int KILLED = 3;
static final int COMMITTED = 4;

final static ThreadLocal<LockingTransaction> transaction =

new ThreadLocal<LockingTransaction>();
728 CHAPTER 8. JVM/CLOJURE/LANG/

static class RetryEx extends Error{

}

static class AbortException extends Exception{

}

public static class Info{

final AtomicInteger status;
final long startPoint;
final CountDownLatch latch;

public Info(int status, long startPoint){

this.status = new AtomicInteger(status);
this.startPoint = startPoint;
this.latch = new CountDownLatch(1);
}

public boolean running(){

int s = status.get();
return s == RUNNING || s == COMMITTING;
}
}

static class CFn{

final IFn fn;
final ISeq args;

public CFn(IFn fn, ISeq args){

this.fn = fn;
this.args = args;
}
}
//total order on transactions
//transactions will consume a point for init, for each retry,
//and on commit if writing
final private static AtomicLong lastPoint = new AtomicLong();

void getReadPoint(){
readPoint = lastPoint.incrementAndGet();
}

long getCommitPoint(){
return lastPoint.incrementAndGet();
}

void stop(int status){

if(info != null)
{
8.69. LOCKINGTRANSACTION.JAVA 729

synchronized(info)
{
info.status.set(status);
info.latch.countDown();
}
info = null;
vals.clear();
sets.clear();
commutes.clear();
//actions.clear();
}
}

Info info;
long readPoint;
long startPoint;
long startTime;
final RetryEx retryex = new RetryEx();
final ArrayList<Agent.Action> actions = new ArrayList<Agent.Action>();
final HashMap<Ref, Object> vals = new HashMap<Ref, Object>();
final HashSet<Ref> sets = new HashSet<Ref>();
final TreeMap<Ref, ArrayList<CFn>> commutes =
new TreeMap<Ref, ArrayList<CFn>>();

final HashSet<Ref> ensures = new HashSet<Ref>(); //all hold readLock

void tryWriteLock(Ref ref){

try
{
if(!ref.lock
.writeLock()
.tryLock(LOCK_WAIT_MSECS, TimeUnit.MILLISECONDS))
throw retryex;
}
catch(InterruptedException e)
{
throw retryex;
}
}

//returns the most recent val

Object lock(Ref ref){
//can’t upgrade readLock, so release it
releaseIfEnsured(ref);

boolean unlocked = true;

try
{
730 CHAPTER 8. JVM/CLOJURE/LANG/

tryWriteLock(ref);
unlocked = false;

if(ref.tvals != null && ref.tvals.point > readPoint)

throw retryex;
Info refinfo = ref.tinfo;

//write lock conflict

if(refinfo != null && refinfo != info && refinfo.running())
{
if(!barge(refinfo))
{
ref.lock.writeLock().unlock();
unlocked = true;
return blockAndBail(refinfo);
}
}
ref.tinfo = info;
return ref.tvals == null ? null : ref.tvals.val;
}
finally
{
if(!unlocked)
ref.lock.writeLock().unlock();
}
}

private Object blockAndBail(Info refinfo){

//stop prior to blocking
stop(RETRY);
try
{
refinfo.latch.await(LOCK_WAIT_MSECS, TimeUnit.MILLISECONDS);
}
catch(InterruptedException e)
{
//ignore
}
throw retryex;
}

private void releaseIfEnsured(Ref ref){

if(ensures.contains(ref))
{
ensures.remove(ref);
ref.lock.readLock().unlock();
}
}

void abort() throws AbortException{

8.69. LOCKINGTRANSACTION.JAVA 731

stop(KILLED);
throw new AbortException();
}

private boolean bargeTimeElapsed(){

return System.nanoTime() - startTime > BARGE_WAIT_NANOS;
}

private boolean barge(Info refinfo){

boolean barged = false;
//if this transaction is older
// try to abort the other
if(bargeTimeElapsed() && startPoint < refinfo.startPoint)
{
barged = refinfo.status.compareAndSet(RUNNING, KILLED);
if(barged)
refinfo.latch.countDown();
}
return barged;
}

static LockingTransaction getEx(){

LockingTransaction t = transaction.get();
if(t == null || t.info == null)
throw new IllegalStateException("No transaction running");
return t;
}

static public boolean isRunning(){

return getRunning() != null;
}

static LockingTransaction getRunning(){

LockingTransaction t = transaction.get();
if(t == null || t.info == null)
return null;
return t;
}

static public Object runInTransaction(Callable fn) throws Exception{

LockingTransaction t = transaction.get();
if(t == null)
transaction.set(t = new LockingTransaction());

if(t.info != null)
return fn.call();

return t.run(fn);
}
732 CHAPTER 8. JVM/CLOJURE/LANG/

static class Notify{

final public Ref ref;
final public Object oldval;
final public Object newval;

Notify(Ref ref, Object oldval, Object newval){

this.ref = ref;
this.oldval = oldval;
this.newval = newval;
}
}

Object run(Callable fn) throws Exception{

boolean done = false;
Object ret = null;
ArrayList<Ref> locked = new ArrayList<Ref>();
ArrayList<Notify> notify = new ArrayList<Notify>();

for(int i = 0; !done && i < RETRY_LIMIT; i++)

{
try
{
getReadPoint();
if(i == 0)
{
startPoint = readPoint;
startTime = System.nanoTime();
}
info = new Info(RUNNING, startPoint);
ret = fn.call();
//make sure no one has killed us before this point,
//and can’t from now on
if(info.status.compareAndSet(RUNNING, COMMITTING))
{
for(Map.Entry<Ref, ArrayList<CFn>> e
: commutes.entrySet())
{
Ref ref = e.getKey();
if(sets.contains(ref)) continue;

boolean wasEnsured = ensures.contains(ref);

//can’t upgrade readLock, so release it
releaseIfEnsured(ref);
tryWriteLock(ref);
locked.add(ref);
if(wasEnsured && ref.tvals != null &&
ref.tvals.point > readPoint)
throw retryex;

Info refinfo = ref.tinfo;

8.69. LOCKINGTRANSACTION.JAVA 733

if(refinfo != null &&

refinfo != info &&
refinfo.running())
{
if(!barge(refinfo))
throw retryex;
}
Object val =
ref.tvals == null ? null : ref.tvals.val;
vals.put(ref, val);
for(CFn f : e.getValue())
{
vals.put(ref,
f.fn.applyTo(
RT.cons(vals.get(ref), f.args)));
}
}
for(Ref ref : sets)
{
tryWriteLock(ref);
locked.add(ref);
}

//validate and enqueue notifications

for(Map.Entry<Ref, Object> e : vals.entrySet())
{
Ref ref = e.getKey();
ref.validate(ref.getValidator(), e.getValue());
}

//at this point, all values calced, all refs to

//be written locked
//no more client code to be called
long msecs = System.currentTimeMillis();
long commitPoint = getCommitPoint();
for(Map.Entry<Ref, Object> e : vals.entrySet())
{
Ref ref = e.getKey();
Object oldval =
ref.tvals == null ? null : ref.tvals.val;
Object newval = e.getValue();
int hcount = ref.histCount();

if(ref.tvals == null)
{
ref.tvals =
new Ref.TVal(newval, commitPoint, msecs);
}
else if((ref.faults.get() > 0 &&
hcount < ref.maxHistory) ||
734 CHAPTER 8. JVM/CLOJURE/LANG/

hcount < ref.minHistory)

{
ref.tvals =
new Ref.TVal(newval,
commitPoint,
msecs,
ref.tvals);
ref.faults.set(0);
}
else
{
ref.tvals = ref.tvals.next;
ref.tvals.val = newval;
ref.tvals.point = commitPoint;
ref.tvals.msecs = msecs;
}
if(ref.getWatches().count() > 0)
notify.add(new Notify(ref, oldval, newval));
}

done = true;
info.status.set(COMMITTED);
}
}
catch(RetryEx retry)
{
//eat this so we retry rather than fall out
}
finally
{
for(int k = locked.size() - 1; k >= 0; --k)
{
locked.get(k).lock.writeLock().unlock();
}
locked.clear();
for(Ref r : ensures)
{
r.lock.readLock().unlock();
}
ensures.clear();
stop(done ? COMMITTED : RETRY);
try
{
if(done) //re-dispatch out of transaction
{
for(Notify n : notify)
{
n.ref.notifyWatches(n.oldval, n.newval);
}
for(Agent.Action action : actions)
8.69. LOCKINGTRANSACTION.JAVA 735

{
Agent.dispatchAction(action);
}
}
}
finally
{
notify.clear();
actions.clear();
}
}
}
if(!done)
throw new Exception(
"Transaction failed after reaching retry limit");
return ret;
}

public void enqueue(Agent.Action action){

actions.add(action);
}

Object doGet(Ref ref){

if(!info.running())
throw retryex;
if(vals.containsKey(ref))
return vals.get(ref);
try
{
ref.lock.readLock().lock();
if(ref.tvals == null)
throw new IllegalStateException(
ref.toString() + " is unbound.");
Ref.TVal ver = ref.tvals;
do
{
if(ver.point <= readPoint)
return ver.val;
} while((ver = ver.prior) != ref.tvals);
}
finally
{
ref.lock.readLock().unlock();
}
//no version of val precedes the read point
ref.faults.incrementAndGet();
throw retryex;

}
736 CHAPTER 8. JVM/CLOJURE/LANG/

Object doSet(Ref ref, Object val){

if(!info.running())
throw retryex;
if(commutes.containsKey(ref))
throw new IllegalStateException("Can’t set after commute");
if(!sets.contains(ref))
{
sets.add(ref);
lock(ref);
}
vals.put(ref, val);
return val;
}

void doEnsure(Ref ref){

if(!info.running())
throw retryex;
if(ensures.contains(ref))
return;
ref.lock.readLock().lock();

//someone completed a write after our snapshot

if(ref.tvals != null && ref.tvals.point > readPoint) {
ref.lock.readLock().unlock();
throw retryex;
}

Info refinfo = ref.tinfo;

//writer exists
if(refinfo != null && refinfo.running())
{
ref.lock.readLock().unlock();

if(refinfo != info) //not us, ensure is doomed

{
blockAndBail(refinfo);
}
}
else
ensures.add(ref);
}

Object doCommute(Ref ref, IFn fn, ISeq args) throws Exception{

if(!info.running())
throw retryex;
if(!vals.containsKey(ref))
{
Object val = null;
try
8.69. LOCKINGTRANSACTION.JAVA 737

{
ref.lock.readLock().lock();
val = ref.tvals == null ? null : ref.tvals.val;
}
finally
{
ref.lock.readLock().unlock();
}
vals.put(ref, val);
}
ArrayList<CFn> fns = commutes.get(ref);
if(fns == null)
commutes.put(ref, fns = new ArrayList<CFn>());
fns.add(new CFn(fn, args));
Object ret = fn.applyTo(RT.cons(vals.get(ref), args));
vals.put(ref, ret);
return ret;
}

/*
//for test
static CyclicBarrier barrier;
static ArrayList<Ref> items;

public static void main(String[] args){

try
{
if(args.length != 4)
System.err.println(
"Usage: LockingTransaction nthreads nitems niters ninstances");
int nthreads = Integer.parseInt(args[0]);
int nitems = Integer.parseInt(args[1]);
int niters = Integer.parseInt(args[2]);
int ninstances = Integer.parseInt(args[3]);

if(items == null)
{
ArrayList<Ref> temp = new ArrayList(nitems);
for(int i = 0; i < nitems; i++)
temp.add(new Ref(0));
items = temp;
}

class Incr extends AFn{

public Object invoke(Object arg1) throws Exception{
Integer i = (Integer) arg1;
return i + 1;
}

public Obj withMeta(IPersistentMap meta){

738 CHAPTER 8. JVM/CLOJURE/LANG/

throw new UnsupportedOperationException();

}
}

class Commuter extends AFn implements Callable{

int niters;
List<Ref> items;
Incr incr;

public Commuter(int niters, List<Ref> items){

this.niters = niters;
this.items = items;
this.incr = new Incr();
}

public Object call() throws Exception{

long nanos = 0;
for(int i = 0; i < niters; i++)
{
long start = System.nanoTime();
LockingTransaction.runInTransaction(this);
nanos += System.nanoTime() - start;
}
return nanos;
}

public Object invoke() throws Exception{

for(Ref tref : items)
{
LockingTransaction.getEx().doCommute(tref, incr);
}
return null;
}

public Obj withMeta(IPersistentMap meta){

throw new UnsupportedOperationException();

}
}

class Incrementer extends AFn implements Callable{

int niters;
List<Ref> items;

public Incrementer(int niters, List<Ref> items){

this.niters = niters;
this.items = items;
8.69. LOCKINGTRANSACTION.JAVA 739

public Object call() throws Exception{

long nanos = 0;
for(int i = 0; i < niters; i++)
{
long start = System.nanoTime();
LockingTransaction.runInTransaction(this);
nanos += System.nanoTime() - start;
}
return nanos;
}

public Object invoke() throws Exception{

for(Ref tref : items)
{
//Transaction.get().doTouch(tref);
// LockingTransaction t = LockingTransaction.getEx();
// int val = (Integer) t.doGet(tref);
// t.doSet(tref, val + 1);
int val = (Integer) tref.get();
tref.set(val + 1);
}
return null;
}

public Obj withMeta(IPersistentMap meta){

throw new UnsupportedOperationException();

}
}

ArrayList<Callable<Long>> tasks = new ArrayList(nthreads);

for(int i = 0; i < nthreads; i++)
{
ArrayList<Ref> si;
synchronized(items)
{
si = (ArrayList<Ref>) items.clone();
}
Collections.shuffle(si);
tasks.add(new Incrementer(niters, si));
//tasks.add(new Commuter(niters, si));
}
ExecutorService e = Executors.newFixedThreadPool(nthreads);

if(barrier == null)
barrier = new CyclicBarrier(ninstances);
System.out.println("waiting for other instances...");
barrier.await();
740 CHAPTER 8. JVM/CLOJURE/LANG/

System.out.println("starting");
long start = System.nanoTime();
List<Future<Long>> results = e.invokeAll(tasks);
long estimatedTime = System.nanoTime() - start;
System.out.printf(
"nthreads: %d, nitems: %d, niters: %d, time: %d%n",
nthreads, nitems, niters, estimatedTime / 1000000);
e.shutdown();
for(Future<Long> result : results)
{
System.out.printf("%d, ", result.get() / 1000000);
}
System.out.println();
System.out.println("waiting for other instances...");
barrier.await();
synchronized(items)
{
for(Ref item : items)
{
System.out.printf("%d, ", (Integer) item.currentVal());
}
}
System.out.println("\ndone");
System.out.flush();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
*/
}

———-

8.70 MapEntry.java

— MapEntry.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.util.Iterator;

public class MapEntry extends AMapEntry{

final Object _key;
final Object _val;
8.71. MAPEQUIVALENCE.JAVA 741

public MapEntry(Object key, Object val){

this._key = key;
this._val = val;
}

public Object key(){

return _key;
}

public Object val(){

return _val;
}

public Object getKey(){

return key();
}

public Object getValue(){

return val();
}

———-

8.71 MapEquivalence.java

— MapEquivalence.java —

\getchunk{Clojure Copyright}
/* rich Aug 4, 2010 */

package clojure.lang;

//marker interface
public interface MapEquivalence{
}

———-

8.72 MethodImplCache.java

— MethodImplCache.java —
742 CHAPTER 8. JVM/CLOJURE/LANG/

\getchunk{Clojure Copyright}
/* rich Nov 8, 2009 */

package clojure.lang;

public final class MethodImplCache{

static public class Entry{

final public Class c;
final public IFn fn;

public Entry(Class c, IFn fn){

this.c = c;
this.fn = fn;
}
}

public final IPersistentMap protocol;

public final Keyword methodk;
public final int shift;
public final int mask;
public final Object[] table; //[class, entry. class, entry ...]

Entry mre = null;

public MethodImplCache(IPersistentMap protocol, Keyword methodk){

this(protocol, methodk, 0, 0, RT.EMPTY_ARRAY);
}

public MethodImplCache(IPersistentMap protocol,

Keyword methodk,
int shift,
int mask,
Object[] table){
this.protocol = protocol;
this.methodk = methodk;
this.shift = shift;
this.mask = mask;
this.table = table;
}

public IFn fnFor(Class c){

Entry last = mre;
if(last != null && last.c == c)
return last.fn;
return findFnFor(c);
}

IFn findFnFor(Class c){

int idx = ((Util.hash(c) >> shift) & mask) << 1;
8.73. MULTIFN.JAVA 743

if(idx < table.length && table[idx] == c)

{
Entry e = ((Entry) table[idx + 1]);
mre = e;
return e != null ? e.fn : null;
}
return null;
}

———-

8.73 MultiFn.java

— MultiFn.java —

\getchunk{Clojure Copyright}
/* rich Sep 13, 2007 */

package clojure.lang;

import java.util.Map;

public class MultiFn extends AFn{

final public IFn dispatchFn;
final public Object defaultDispatchVal;
final public IRef hierarchy;
final String name;
IPersistentMap methodTable;
IPersistentMap preferTable;
IPersistentMap methodCache;
Object cachedHierarchy;

static final Var assoc = RT.var("clojure.core", "assoc");

static final Var dissoc = RT.var("clojure.core", "dissoc");
static final Var isa = RT.var("clojure.core", "isa?");
static final Var parents = RT.var("clojure.core", "parents");

public MultiFn(String name,

IFn dispatchFn,
Object defaultDispatchVal,
IRef hierarchy) throws Exception{
this.name = name;
this.dispatchFn = dispatchFn;
this.defaultDispatchVal = defaultDispatchVal;
744 CHAPTER 8. JVM/CLOJURE/LANG/

this.methodTable = PersistentHashMap.EMPTY;
this.methodCache = getMethodTable();
this.preferTable = PersistentHashMap.EMPTY;
this.hierarchy = hierarchy;
cachedHierarchy = null;
}

synchronized public MultiFn reset(){

methodTable = methodCache
= preferTable
= PersistentHashMap.EMPTY;
cachedHierarchy = null;
return this;
}

synchronized public MultiFn addMethod(Object dispatchVal,

IFn method)
throws Exception{
methodTable = getMethodTable().assoc(dispatchVal, method);
resetCache();
return this;
}

synchronized public MultiFn removeMethod(Object dispatchVal)

throws Exception{
methodTable = getMethodTable().without(dispatchVal);
resetCache();
return this;
}

synchronized public MultiFn preferMethod(Object dispatchValX,

Object dispatchValY)
throws Exception{
if(prefers(dispatchValY, dispatchValX))
throw new IllegalStateException(
String.format("Preference conflict in multimethod ’%s’:"+
" %s is already preferred to %s",
name, dispatchValY, dispatchValX));
preferTable =
getPreferTable().assoc(dispatchValX,
RT.conj((IPersistentCollection)
RT.get(getPreferTable(),
dispatchValX,
PersistentHashSet.EMPTY),
dispatchValY));
resetCache();
return this;
}

private boolean prefers(Object x, Object y) throws Exception{

8.73. MULTIFN.JAVA 745

IPersistentSet xprefs =
(IPersistentSet) getPreferTable().valAt(x);
if(xprefs != null && xprefs.contains(y))
return true;
for(ISeq ps = RT.seq(parents.invoke(y));
ps != null;
ps = ps.next())
{
if(prefers(x, ps.first()))
return true;
}
for(ISeq ps = RT.seq(parents.invoke(x));
ps != null;
ps = ps.next())
{
if(prefers(ps.first(), y))
return true;
}
return false;
}

private boolean isA(Object x, Object y) throws Exception{

return RT.booleanCast(isa.invoke(hierarchy.deref(), x, y));
}

private boolean dominates(Object x, Object y) throws Exception{

return prefers(x, y) || isA(x, y);
}

private IPersistentMap resetCache() throws Exception{

methodCache = getMethodTable();
cachedHierarchy = hierarchy.deref();
return methodCache;
}

synchronized public IFn getMethod(Object dispatchVal) throws Exception{

if(cachedHierarchy != hierarchy.deref())
resetCache();
IFn targetFn = (IFn) methodCache.valAt(dispatchVal);
if(targetFn != null)
return targetFn;
targetFn = findAndCacheBestMethod(dispatchVal);
if(targetFn != null)
return targetFn;
targetFn = (IFn) getMethodTable().valAt(defaultDispatchVal);
return targetFn;
}

private IFn getFn(Object dispatchVal) throws Exception{

IFn targetFn = getMethod(dispatchVal);
746 CHAPTER 8. JVM/CLOJURE/LANG/

if(targetFn == null)
throw new IllegalArgumentException(
String.format("No method in multimethod ’%s’ "+
"for dispatch value: %s",
name, dispatchVal));
return targetFn;
}

private IFn findAndCacheBestMethod(Object dispatchVal)

throws Exception{
Map.Entry bestEntry = null;
for(Object o : getMethodTable())
{
Map.Entry e = (Map.Entry) o;
if(isA(dispatchVal, e.getKey()))
{
if(bestEntry == null ||
dominates(e.getKey(), bestEntry.getKey()))
bestEntry = e;
if(!dominates(bestEntry.getKey(), e.getKey()))
throw new IllegalArgumentException(
String.format(
"Multiple methods in multimethod ’%s’ match "+
"dispatch value: %s -> %s and %s, and "+
"neither is preferred",
name, dispatchVal, e.getKey(), bestEntry.getKey()));
}
}
if(bestEntry == null)
return null;
//ensure basis has stayed stable throughout, else redo
if(cachedHierarchy == hierarchy.deref())
{
//place in cache
methodCache =
methodCache.assoc(dispatchVal, bestEntry.getValue());
return (IFn) bestEntry.getValue();
}
else
{
resetCache();
return findAndCacheBestMethod(dispatchVal);
}
}

public Object invoke()

throws Exception{
return getFn(dispatchFn.invoke()).invoke();
}
8.73. MULTIFN.JAVA 747

public Object invoke(Object arg1)

throws Exception{
return getFn(dispatchFn.invoke(arg1)).invoke(arg1);
}

public Object invoke(Object arg1, Object arg2)

throws Exception{
return getFn(dispatchFn.invoke(arg1, arg2)).invoke(arg1, arg2);
}

public Object invoke(Object arg1, Object arg2, Object arg3)

throws Exception{
return getFn(dispatchFn.invoke(arg1, arg2, arg3))
.invoke(arg1, arg2, arg3);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4)
throws Exception{
return getFn(dispatchFn.invoke(arg1, arg2, arg3, arg4))
.invoke(arg1, arg2, arg3, arg4);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5)
throws Exception{
return getFn(dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5))
.invoke(arg1, arg2, arg3, arg4, arg5);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8)
748 CHAPTER 8. JVM/CLOJURE/LANG/

throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12);
8.73. MULTIFN.JAVA 749

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14, arg15))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
750 CHAPTER 8. JVM/CLOJURE/LANG/

arg9, arg10, arg11, arg12, arg13, arg14, arg15,

arg16))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17,
arg18);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19)
throws Exception{
return getFn(
dispatchFn.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19))
.invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
8.73. MULTIFN.JAVA 751

arg10, arg11, arg12, arg13, arg14, arg15, arg16,

arg17, arg18, arg19);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

public IPersistentMap getMethodTable() {

return methodTable;
}

public IPersistentMap getPreferTable() {

return preferTable;
}
}

———-
752 CHAPTER 8. JVM/CLOJURE/LANG/

8.74 Named.java

— Named.java —

\getchunk{Clojure Copyright}
/* rich Sep 20, 2007 */

package clojure.lang;

public interface Named{

String getNamespace();

String getName();
}

———-

8.75 Namespace.java

— Namespace.java —

\getchunk{Clojure Copyright}
/* rich Jan 23, 2008 */

package clojure.lang;

import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;

public class Namespace extends AReference implements Serializable {

final public Symbol name;
transient final AtomicReference<IPersistentMap> mappings =
new AtomicReference<IPersistentMap>();
transient final AtomicReference<IPersistentMap> aliases =
new AtomicReference<IPersistentMap>();

final static ConcurrentHashMap<Symbol, Namespace> namespaces =

new ConcurrentHashMap<Symbol, Namespace>();

public String toString(){

return name.toString();
}
8.75. NAMESPACE.JAVA 753

Namespace(Symbol name){
super(name.meta());
this.name = name;
mappings.set(RT.DEFAULT_IMPORTS);
aliases.set(RT.map());
}

public static ISeq all(){

return RT.seq(namespaces.values());
}

public Symbol getName(){

return name;
}

public IPersistentMap getMappings(){

return mappings.get();
}

public Var intern(Symbol sym){

if(sym.ns != null)
{
throw new IllegalArgumentException(
"Can’t intern namespace-qualified symbol");
}
IPersistentMap map = getMappings();
Object o;
Var v = null;
while((o = map.valAt(sym)) == null)
{
if(v == null)
v = new Var(this, sym);
IPersistentMap newMap = map.assoc(sym, v);
mappings.compareAndSet(map, newMap);
map = getMappings();
}
if(o instanceof Var && ((Var) o).ns == this)
return (Var) o;

if(v == null)
v = new Var(this, sym);

warnOrFailOnReplace(sym, o, v);

while(!mappings.compareAndSet(map, map.assoc(sym, v)))

map = getMappings();

return v;
}
754 CHAPTER 8. JVM/CLOJURE/LANG/

private void warnOrFailOnReplace(Symbol sym, Object o, Object v){

if (o instanceof Var)
{
Namespace ns = ((Var)o).ns;
if (ns == this)
return;
if (ns != RT.CLOJURE_NS)
throw new IllegalStateException(
sym + " already refers to: " + o +
" in namespace: " + name);
}
RT.errPrintWriter().println("WARNING: " + sym +
" already refers to: " + o + " in namespace: " + name
+ ", being replaced by: " + v);
}

Object reference(Symbol sym, Object val){

if(sym.ns != null)
{
throw new IllegalArgumentException(
"Can’t intern namespace-qualified symbol");
}
IPersistentMap map = getMappings();
Object o;
while((o = map.valAt(sym)) == null)
{
IPersistentMap newMap = map.assoc(sym, val);
mappings.compareAndSet(map, newMap);
map = getMappings();
}
if(o == val)
return o;

warnOrFailOnReplace(sym, o, val);

while(!mappings.compareAndSet(map, map.assoc(sym, val)))

map = getMappings();

return val;

public static boolean

areDifferentInstancesOfSameClassName(Class cls1,
Class cls2) {
return (cls1 != cls2) && (cls1.getName().equals(cls2.getName()));
}

Class referenceClass(Symbol sym, Class val){

8.75. NAMESPACE.JAVA 755

if(sym.ns != null)
{
throw new IllegalArgumentException(
"Can’t intern namespace-qualified symbol");
}
IPersistentMap map = getMappings();
Class c = (Class) map.valAt(sym);
while((c == null) ||
(areDifferentInstancesOfSameClassName(c, val)))
{
IPersistentMap newMap = map.assoc(sym, val);
mappings.compareAndSet(map, newMap);
map = getMappings();
c = (Class) map.valAt(sym);
}
if(c == val)
return c;

throw new IllegalStateException(sym + " already refers to: " +

c + " in namespace: " + name);
}

public void unmap(Symbol sym) throws Exception{

if(sym.ns != null)
{
throw new IllegalArgumentException(
"Can’t unintern namespace-qualified symbol");
}
IPersistentMap map = getMappings();
while(map.containsKey(sym))
{
IPersistentMap newMap = map.without(sym);
mappings.compareAndSet(map, newMap);
map = getMappings();
}
}

public Class importClass(Symbol sym, Class c){

return referenceClass(sym, c);

public Class importClass(Class c){

String n = c.getName();
return importClass(
Symbol.intern(n.substring(n.lastIndexOf(’.’) + 1)), c);
}

public Var refer(Symbol sym, Var var){

return (Var) reference(sym, var);
756 CHAPTER 8. JVM/CLOJURE/LANG/

public static Namespace findOrCreate(Symbol name){

Namespace ns = namespaces.get(name);
if(ns != null)
return ns;
Namespace newns = new Namespace(name);
ns = namespaces.putIfAbsent(name, newns);
return ns == null ? newns : ns;
}

public static Namespace remove(Symbol name){

if(name.equals(RT.CLOJURE_NS.name))
throw new IllegalArgumentException(
"Cannot remove clojure namespace");
return namespaces.remove(name);
}

public static Namespace find(Symbol name){

return namespaces.get(name);
}

public Object getMapping(Symbol name){

return mappings.get().valAt(name);
}

public Var findInternedVar(Symbol symbol){

Object o = mappings.get().valAt(symbol);
if(o != null && o instanceof Var && ((Var) o).ns == this)
return (Var) o;
return null;
}

public IPersistentMap getAliases(){

return aliases.get();
}

public Namespace lookupAlias(Symbol alias){

IPersistentMap map = getAliases();
return (Namespace) map.valAt(alias);
}

public void addAlias(Symbol alias, Namespace ns){

if (alias == null || ns == null)
throw new NullPointerException("Expecting Symbol + Namespace");
IPersistentMap map = getAliases();
while(!map.containsKey(alias))
{
8.76. NUMBERS.JAVA 757

IPersistentMap newMap = map.assoc(alias, ns);

aliases.compareAndSet(map, newMap);
map = getAliases();
}
// you can rebind an alias, but only to the
// initially-aliased namespace.
if(!map.valAt(alias).equals(ns))
throw new IllegalStateException(
"Alias " + alias + " already exists in namespace "
+ name + ", aliasing " + map.valAt(alias));
}

public void removeAlias(Symbol alias) throws Exception{

IPersistentMap map = getAliases();
while(map.containsKey(alias))
{
IPersistentMap newMap = map.without(alias);
aliases.compareAndSet(map, newMap);
map = getAliases();
}
}

private Object readResolve() throws ObjectStreamException {

// ensures that serialized namespaces are "deserialized" to the
// namespace in the present runtime
return findOrCreate(name);
}
}

———-

8.76 Numbers.java

— Numbers.java —

\getchunk{Clojure Copyright}
/* rich Mar 31, 2008 */

package clojure.lang;

import java.math.BigInteger;
import java.math.BigDecimal;
import java.math.MathContext;

public class Numbers{

static interface Ops{

758 CHAPTER 8. JVM/CLOJURE/LANG/

Ops combine(Ops y);

Ops opsWith(LongOps x);

Ops opsWith(DoubleOps x);

Ops opsWith(RatioOps x);

Ops opsWith(BigIntOps x);

Ops opsWith(BigDecimalOps x);

public boolean isZero(Number x);

public boolean isPos(Number x);

public boolean isNeg(Number x);

public Number add(Number x, Number y);

public Number addP(Number x, Number y);

public Number multiply(Number x, Number y);

public Number multiplyP(Number x, Number y);

public Number divide(Number x, Number y);

public Number quotient(Number x, Number y);

public Number remainder(Number x, Number y);

public boolean equiv(Number x, Number y);

public boolean lt(Number x, Number y);

public Number negate(Number x);

public Number negateP(Number x);

public Number inc(Number x);

public Number incP(Number x);

public Number dec(Number x);

public Number decP(Number x);
}

static abstract class OpsP implements Ops{

public Number addP(Number x, Number y){
return add(x, y);
}

public Number multiplyP(Number x, Number y){

8.76. NUMBERS.JAVA 759

return multiply(x, y);

}

public Number negateP(Number x){

return negate(x);
}

public Number incP(Number x){

return inc(x);
}

public Number decP(Number x){

return dec(x);
}

}
static interface BitOps{
BitOps combine(BitOps y);

BitOps bitOpsWith(LongBitOps x);

BitOps bitOpsWith(BigIntBitOps x);

public Number not(Number x);

public Number and(Number x, Number y);

public Number or(Number x, Number y);

public Number xor(Number x, Number y);

public Number andNot(Number x, Number y);

public Number clearBit(Number x, int n);

public Number setBit(Number x, int n);

public Number flipBit(Number x, int n);

public boolean testBit(Number x, int n);

public Number shiftLeft(Number x, int n);

public Number shiftRight(Number x, int n);

}

static public boolean isZero(Object x){

return ops(x).isZero((Number)x);
}
760 CHAPTER 8. JVM/CLOJURE/LANG/

static public boolean isPos(Object x){

return ops(x).isPos((Number)x);
}

static public boolean isNeg(Object x){

return ops(x).isNeg((Number)x);
}

static public Number minus(Object x){

return ops(x).negate((Number)x);
}

static public Number minusP(Object x){

return ops(x).negateP((Number)x);
}

static public Number inc(Object x){

return ops(x).inc((Number)x);
}

static public Number incP(Object x){

return ops(x).incP((Number)x);
}

static public Number dec(Object x){

return ops(x).dec((Number)x);
}

static public Number decP(Object x){

return ops(x).decP((Number)x);
}

static public Number add(Object x, Object y){

return ops(x).combine(ops(y)).add((Number)x, (Number)y);
}

static public Number addP(Object x, Object y){

return ops(x).combine(ops(y)).addP((Number)x, (Number)y);
}

static public Number minus(Object x, Object y){

Ops yops = ops(y);
return ops(x).combine(yops).add((Number)x, yops.negate((Number)y));
}

static public Number minusP(Object x, Object y){

Ops yops = ops(y);
return ops(x).combine(yops).addP((Number)x, yops.negateP((Number)y));
}
8.76. NUMBERS.JAVA 761

static public Number multiply(Object x, Object y){

return ops(x).combine(ops(y)).multiply((Number)x, (Number)y);
}

static public Number multiplyP(Object x, Object y){

return ops(x).combine(ops(y)).multiplyP((Number)x, (Number)y);
}

static public Number divide(Object x, Object y){

Ops yops = ops(y);
if(yops.isZero((Number)y))
throw new ArithmeticException("Divide by zero");
return ops(x).combine(yops).divide((Number)x, (Number)y);
}

static public Number quotient(Object x, Object y){

Ops yops = ops(y);
if(yops.isZero((Number) y))
throw new ArithmeticException("Divide by zero");
return ops(x).combine(yops).quotient((Number)x, (Number)y);
}

static public Number remainder(Object x, Object y){

Ops yops = ops(y);
if(yops.isZero((Number) y))
throw new ArithmeticException("Divide by zero");
return ops(x).combine(yops).remainder((Number)x, (Number)y);
}

static public double quotient(double n, double d){

if(d == 0)
throw new ArithmeticException("Divide by zero");

double q = n / d;
if(q <= Long.MAX_VALUE && q >= Long.MIN_VALUE)
{
return (double)(long) q;
}
else
{ //bigint quotient
return new BigDecimal(q).toBigInteger().doubleValue();
}
}

static public double remainder(double n, double d){

if(d == 0)
throw new ArithmeticException("Divide by zero");

double q = n / d;
762 CHAPTER 8. JVM/CLOJURE/LANG/

if(q <= Long.MAX_VALUE && q >= Long.MIN_VALUE)

{
return (n - ((long) q) * d);
}
else
{ //bigint quotient
Number bq = new BigDecimal(q).toBigInteger();
return (n - bq.doubleValue() * d);
}
}

static public boolean equiv(Object x, Object y){

return equiv((Number) x, (Number) y);
}

static public boolean equiv(Number x, Number y){

return ops(x).combine(ops(y)).equiv(x, y);
}

static public boolean equal(Number x, Number y){

return category(x) == category(y)
&& ops(x).combine(ops(y)).equiv(x, y);
}

static public boolean lt(Object x, Object y){

return ops(x).combine(ops(y)).lt((Number)x, (Number)y);
}

static public boolean lte(Object x, Object y){

return !ops(x).combine(ops(y)).lt((Number)y, (Number)x);
}

static public boolean gt(Object x, Object y){

return ops(x).combine(ops(y)).lt((Number)y, (Number)x);
}

static public boolean gte(Object x, Object y){

return !ops(x).combine(ops(y)).lt((Number)x, (Number)y);
}

static public int compare(Number x, Number y){

Ops ops = ops(x).combine(ops(y));
if(ops.lt(x, y))
return -1;
else if(ops.lt(y, x))
return 1;
return 0;
}

static BigInt toBigInt(Object x){

8.76. NUMBERS.JAVA 763

if(x instanceof BigInt)

return (BigInt) x;
if(x instanceof BigInteger)
return BigInt.fromBigInteger((BigInteger) x);
else
return BigInt.fromLong(((Number) x).longValue());
}

static BigInteger toBigInteger(Object x){

if(x instanceof BigInteger)
return (BigInteger) x;
else if(x instanceof BigInt)
return ((BigInt) x).toBigInteger();
else
return BigInteger.valueOf(((Number) x).longValue());
}

static BigDecimal toBigDecimal(Object x){

if(x instanceof BigDecimal)
return (BigDecimal) x;
else if(x instanceof BigInt)
{
BigInt bi = (BigInt) x;
if(bi.bipart == null)
return BigDecimal.valueOf(bi.lpart);
else
return new BigDecimal(bi.bipart);
}
else if(x instanceof BigInteger)
return new BigDecimal((BigInteger) x);
else if(x instanceof Double)
return new BigDecimal(((Number) x).doubleValue());
else if(x instanceof Float)
return new BigDecimal(((Number) x).doubleValue());
else if(x instanceof Ratio)
{
Ratio r = (Ratio)x;
return (BigDecimal)divide(new BigDecimal(r.numerator),
r.denominator);
}
else
return BigDecimal.valueOf(((Number) x).longValue());
}

static public Ratio toRatio(Object x){

if(x instanceof Ratio)
return (Ratio) x;
else if(x instanceof BigDecimal)
{
BigDecimal bx = (BigDecimal) x;
764 CHAPTER 8. JVM/CLOJURE/LANG/

BigInteger bv = bx.unscaledValue();
int scale = bx.scale();
if(scale < 0)
return
new Ratio(bv.multiply(BigInteger.TEN.pow(-scale)),
BigInteger.ONE);
else
return new Ratio(bv, BigInteger.TEN.pow(scale));
}
return new Ratio(toBigInteger(x), BigInteger.ONE);
}

static public Number rationalize(Number x){

if(x instanceof Float || x instanceof Double)
return rationalize(BigDecimal.valueOf(x.doubleValue()));
else if(x instanceof BigDecimal)
{
BigDecimal bx = (BigDecimal) x;
BigInteger bv = bx.unscaledValue();
int scale = bx.scale();
if(scale < 0)
return
BigInt.fromBigInteger(
bv.multiply(BigInteger.TEN.pow(-scale)));
else
return divide(bv, BigInteger.TEN.pow(scale));
}
return x;
}

//static Number box(int val){

// return Integer.valueOf(val);
//}

//static Number box(long val){

// return Long.valueOf(val);
//}
//
//static Double box(double val){
// return Double.valueOf(val);
//}
//
//static Double box(float val){
// return Double.valueOf((double) val);
//}

static public Number reduceBigInt(BigInt val){

if(val.bipart == null)
return num(val.lpart);
else
8.76. NUMBERS.JAVA 765

return val.bipart;
}

static public Number divide(BigInteger n, BigInteger d){

if(d.equals(BigInteger.ZERO))
throw new ArithmeticException("Divide by zero");
BigInteger gcd = n.gcd(d);
if(gcd.equals(BigInteger.ZERO))
return BigInt.ZERO;
n = n.divide(gcd);
d = d.divide(gcd);
if(d.equals(BigInteger.ONE))
return BigInt.fromBigInteger(n);
else if(d.equals(BigInteger.ONE.negate()))
return BigInt.fromBigInteger(n.negate());
return new Ratio((d.signum() < 0 ? n.negate() : n),
(d.signum() < 0 ? d.negate() : d));
}

static public Number not(Object x){

return bitOps(x).not((Number)x);
}

static public Number and(Object x, Object y){

return bitOps(x).combine(bitOps(y)).and((Number)x, (Number)y);
}

static public Number or(Object x, Object y){

return bitOps(x).combine(bitOps(y)).or((Number)x, (Number)y);
}

static public Number xor(Object x, Object y){

return bitOps(x).combine(bitOps(y)).xor((Number)x, (Number)y);
}

static public Number andNot(Number x, Number y){

return bitOps(x).combine(bitOps(y)).andNot(x, y);
}

static public Number clearBit(Number x, int n){

if(n < 0)
throw new ArithmeticException("Negative bit index");
return bitOps(x).clearBit(x, n);
}

static public Number setBit(Number x, int n){

if(n < 0)
throw new ArithmeticException("Negative bit index");
return bitOps(x).setBit(x, n);
766 CHAPTER 8. JVM/CLOJURE/LANG/

static public Number flipBit(Number x, int n){

if(n < 0)
throw new ArithmeticException("Negative bit index");
return bitOps(x).flipBit(x, n);
}

static public boolean testBit(Number x, int n){

if(n < 0)
throw new ArithmeticException("Negative bit index");
return bitOps(x).testBit(x, n);
}

static public Number shiftLeft(Object x, Object n){

return bitOps(x).shiftLeft((Number)x, ((Number)n).intValue());
}

static public int shiftLeftInt(int x, int n){

return x << n;
}

static public long shiftLeft(long x, int n){

if(n < 0)
return shiftRight(x, -n);
return x << n;
}

static public Number shiftRight(Object x, Object n){

return bitOps(x).shiftRight((Number)x, ((Number)n).intValue());
}

static public int shiftRightInt(int x, int n){

return x >> n;
}

static public long shiftRight(long x, int n){

if(n < 0)
return shiftLeft(x, -n);
return x >> n;
}

final static class LongOps implements Ops{

public Ops combine(Ops y){
return y.opsWith(this);
}

final public Ops opsWith(LongOps x){

return this;
}
8.76. NUMBERS.JAVA 767

final public Ops opsWith(DoubleOps x){

return DOUBLE_OPS;
}

final public Ops opsWith(RatioOps x){

return RATIO_OPS;
}

final public Ops opsWith(BigIntOps x){

return BIGINT_OPS;
}

final public Ops opsWith(BigDecimalOps x){

return BIGDECIMAL_OPS;
}

public boolean isZero(Number x){

return x.longValue() == 0;
}

public boolean isPos(Number x){

return x.longValue() > 0;
}

public boolean isNeg(Number x){

return x.longValue() < 0;
}

final public Number add(Number x, Number y){

return num(Numbers.add(x.longValue(),y.longValue()));
}

final public Number addP(Number x, Number y){

long lx = x.longValue(), ly = y.longValue();
long ret = lx + ly;
if ((ret ^ lx) < 0 && (ret ^ ly) < 0)
return BIGINT_OPS.add(x, y);
return num(ret);
}

final public Number multiply(Number x, Number y){

return num(Numbers.multiply(x.longValue(), y.longValue()));
}

final public Number multiplyP(Number x, Number y){

long lx = x.longValue(), ly = y.longValue();
long ret = lx * ly;
if (ly != 0 && ret/ly != lx)
return BIGINT_OPS.multiply(x, y);
768 CHAPTER 8. JVM/CLOJURE/LANG/

return num(ret);
}
static long gcd(long u, long v){
while(v != 0)
{
long r = u % v;
u = v;
v = r;
}
return u;
}

public Number divide(Number x, Number y){

long n = x.longValue();
long val = y.longValue();
long gcd = gcd(n, val);
if(gcd == 0)
return num(0);

n = n / gcd;
long d = val / gcd;
if(d == 1)
return num(n);
if(d < 0)
{
n = -n;
d = -d;
}
return new Ratio(BigInteger.valueOf(n), BigInteger.valueOf(d));
}

public Number quotient(Number x, Number y){

return num(x.longValue() / y.longValue());
}

public Number remainder(Number x, Number y){

return num(x.longValue() % y.longValue());
}

public boolean equiv(Number x, Number y){

return x.longValue() == y.longValue();
}

public boolean lt(Number x, Number y){

return x.longValue() < y.longValue();
}

//public Number subtract(Number x, Number y);

final public Number add(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
Number ret = divide(ry.numerator.multiply(rx.denominator)
.add(rx.numerator.multiply(ry.denominator))
, ry.denominator.multiply(rx.denominator));
return normalizeRet(ret, x, y);
}

final public Number multiply(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
Number ret = Numbers.divide(ry.numerator.multiply(rx.numerator)
, ry.denominator.multiply(rx.denominator));
return normalizeRet(ret, x, y);
}

public Number divide(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
Number ret = Numbers.divide(ry.denominator.multiply(rx.numerator)
, ry.numerator.multiply(rx.denominator));
return normalizeRet(ret, x, y);
}

public Number quotient(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
BigInteger q = rx.numerator.multiply(ry.denominator).divide(
rx.denominator.multiply(ry.numerator));
return normalizeRet(BigInt.fromBigInteger(q), x, y);
}

public Number remainder(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
BigInteger q = rx.numerator.multiply(ry.denominator).divide(
8.76. NUMBERS.JAVA 773

rx.denominator.multiply(ry.numerator));
Number ret = Numbers.minus(x, Numbers.multiply(q, y));
return normalizeRet(ret, x, y);
}

public boolean equiv(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
return rx.numerator.equals(ry.numerator)
&& rx.denominator.equals(ry.denominator);
}

public boolean lt(Number x, Number y){

Ratio rx = toRatio(x);
Ratio ry = toRatio(y);
return Numbers.lt(
rx.numerator.multiply(ry.denominator),
ry.numerator.multiply(rx.denominator));
}

//public Number subtract(Number x, Number y);

final public Number negate(Number x){
Ratio r = (Ratio) x;
return new Ratio(r.numerator.negate(), r.denominator);
}

public Number inc(Number x){

return Numbers.add(x, 1);
}

public Number dec(Number x){

return Numbers.add(x, -1);
}

final static class BigIntOps extends OpsP{

public Ops combine(Ops y){
return y.opsWith(this);
}

final public Ops opsWith(LongOps x){

return this;
}

final public Ops opsWith(DoubleOps x){

return DOUBLE_OPS;
}

final public Ops opsWith(RatioOps x){

public Number divide(Number x, Number y){

MathContext mc = (MathContext) MATH_CONTEXT.deref();
return mc == null
? toBigDecimal(x).divide(toBigDecimal(y))
: toBigDecimal(x).divide(toBigDecimal(y), mc);
}

public Number quotient(Number x, Number y){

MathContext mc = (MathContext) MATH_CONTEXT.deref();
return
mc == null
8.76. NUMBERS.JAVA 777

? toBigDecimal(x).divideToIntegralValue(toBigDecimal(y))
: toBigDecimal(x).divideToIntegralValue(toBigDecimal(y), mc);
}

public Number remainder(Number x, Number y){

MathContext mc = (MathContext) MATH_CONTEXT.deref();
return mc == null
? toBigDecimal(x).remainder(toBigDecimal(y))
: toBigDecimal(x).remainder(toBigDecimal(y), mc);
}

public boolean equiv(Number x, Number y){

return toBigDecimal(x).equals(toBigDecimal(y));
}

public boolean lt(Number x, Number y){

return toBigDecimal(x).compareTo(toBigDecimal(y)) < 0;
}

//public Number subtract(Number x, Number y);

final public Number negate(Number x){
MathContext mc = (MathContext) MATH_CONTEXT.deref();
return mc == null
? ((BigDecimal) x).negate()
: ((BigDecimal) x).negate(mc);
}

public Number inc(Number x){

MathContext mc = (MathContext) MATH_CONTEXT.deref();
BigDecimal bx = (BigDecimal) x;
return mc == null
? bx.add(BigDecimal.ONE)
: bx.add(BigDecimal.ONE, mc);
}

public Number dec(Number x){

MathContext mc = (MathContext) MATH_CONTEXT.deref();
BigDecimal bx = (BigDecimal) x;
return mc == null
? bx.subtract(BigDecimal.ONE)
: bx.subtract(BigDecimal.ONE, mc);
}
}

final static class LongBitOps implements BitOps{

public BitOps combine(BitOps y){
return y.bitOpsWith(this);
}

final public BitOps bitOpsWith(LongBitOps x){

778 CHAPTER 8. JVM/CLOJURE/LANG/

return this;
}

final public BitOps bitOpsWith(BigIntBitOps x){

return BIGINT_BITOPS;
}

public Number not(Number x){

return num(~x.longValue());
}

public Number and(Number x, Number y){

return num(x.longValue() & y.longValue());
}

public Number or(Number x, Number y){

return num(x.longValue() | y.longValue());
}

public Number xor(Number x, Number y){

return num(x.longValue() ^ y.longValue());
}

public Number andNot(Number x, Number y){

return num(x.longValue() & ~y.longValue());
}

public Number clearBit(Number x, int n){

if(n < 63)
return (num(x.longValue() & ~(1L << n)));
else
return BigInt.fromBigInteger(toBigInteger(x).clearBit(n));
}

public Number setBit(Number x, int n){

if(n < 63)
return num(x.longValue() | (1L << n));
else
return BigInt.fromBigInteger(toBigInteger(x).setBit(n));
}

public Number flipBit(Number x, int n){

if(n < 63)
return num(x.longValue() ^ (1L << n));
else
return BigInt.fromBigInteger(toBigInteger(x).flipBit(n));
}

public boolean testBit(Number x, int n){

if(n < 64)
8.76. NUMBERS.JAVA 779

return (x.longValue() & (1L << n)) != 0;

else
return toBigInteger(x).testBit(n);
}

public Number shiftLeft(Number x, int n){

if(n < 0)
return shiftRight(x, -n);
return num(Numbers.shiftLeft(x.longValue(), n));
}

public Number shiftRight(Number x, int n){

if(n < 0)
return shiftLeft(x, -n);
return num(x.longValue() >> n);
}
}

final static class BigIntBitOps implements BitOps{

public BitOps combine(BitOps y){
return y.bitOpsWith(this);
}

final public BitOps bitOpsWith(LongBitOps x){

return this;
}

final public BitOps bitOpsWith(BigIntBitOps x){

return this;
}

public Number not(Number x){

return BigInt.fromBigInteger(toBigInteger(x).not());
}

public Number and(Number x, Number y){

return
BigInt.fromBigInteger(toBigInteger(x).and(toBigInteger(y)));
}

public Number or(Number x, Number y){

return
BigInt.fromBigInteger(toBigInteger(x).or(toBigInteger(y)));
}

public Number xor(Number x, Number y){

return
BigInt.fromBigInteger(toBigInteger(x).xor(toBigInteger(y)));
}
780 CHAPTER 8. JVM/CLOJURE/LANG/

public Number andNot(Number x, Number y){

return
BigInt.fromBigInteger(toBigInteger(x).andNot(toBigInteger(y)));
}

public Number clearBit(Number x, int n){

return BigInt.fromBigInteger(toBigInteger(x).clearBit(n));
}

public Number setBit(Number x, int n){

return BigInt.fromBigInteger(toBigInteger(x).setBit(n));
}

public Number flipBit(Number x, int n){

return BigInt.fromBigInteger(toBigInteger(x).flipBit(n));
}

public boolean testBit(Number x, int n){

return toBigInteger(x).testBit(n);
}

public Number shiftLeft(Number x, int n){

return BigInt.fromBigInteger(toBigInteger(x).shiftLeft(n));
}

public Number shiftRight(Number x, int n){

return BigInt.fromBigInteger(toBigInteger(x).shiftRight(n));
}
}

static final LongOps LONG_OPS = new LongOps();

static final DoubleOps DOUBLE_OPS = new DoubleOps();
static final RatioOps RATIO_OPS = new RatioOps();
static final BigIntOps BIGINT_OPS = new BigIntOps();
static final BigDecimalOps BIGDECIMAL_OPS = new BigDecimalOps();

static final LongBitOps LONG_BITOPS = new LongBitOps();

static final BigIntBitOps BIGINT_BITOPS = new BigIntBitOps();

static public enum Category {INTEGER, FLOATING, DECIMAL, RATIO};

static Ops ops(Object x){

if(sizeOrSeq instanceof Number)
return new float[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
float[] ret = new float[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).floatValue();
return ret;
}
}

static public double[] double_array(int size, Object init){

double[] ret = new double[size];
if(init instanceof Number)
{
double f = ((Number) init).doubleValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).doubleValue();
8.76. NUMBERS.JAVA 783

}
return ret;
}

static public double[] double_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new double[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
double[] ret = new double[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).doubleValue();
return ret;
}
}

static public int[] int_array(int size, Object init){

int[] ret = new int[size];
if(init instanceof Number)
{
int f = ((Number) init).intValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).intValue();
}
return ret;
}

static public int[] int_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new int[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
int[] ret = new int[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).intValue();
return ret;
}
}

static public long[] long_array(int size, Object init){

784 CHAPTER 8. JVM/CLOJURE/LANG/

long[] ret = new long[size];

if(init instanceof Number)
{
long f = ((Number) init).longValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).longValue();
}
return ret;
}

static public long[] long_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new long[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
long[] ret = new long[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = ((Number) s.first()).longValue();
return ret;
}
}

static public short[] short_array(int size, Object init){

short[] ret = new short[size];
if(init instanceof Short)
{
short s = (Short) init;
for(int i = 0; i < ret.length; i++)
ret[i] = s;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Short) s.first();
}
return ret;
}

static public short[] short_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new short[((Number) sizeOrSeq).intValue()];
8.76. NUMBERS.JAVA 785

else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
short[] ret = new short[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Short) s.first();
return ret;
}
}

static public char[] char_array(int size, Object init){

char[] ret = new char[size];
if(init instanceof Character)
{
char c = (Character) init;
for(int i = 0; i < ret.length; i++)
ret[i] = c;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Character) s.first();
}
return ret;
}

static public char[] char_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new char[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
char[] ret = new char[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Character) s.first();
return ret;
}
}

static public byte[] byte_array(int size, Object init){

byte[] ret = new byte[size];
if(init instanceof Byte)
{
byte b = (Byte) init;
for(int i = 0; i < ret.length; i++)
ret[i] = b;
}
786 CHAPTER 8. JVM/CLOJURE/LANG/

else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Byte) s.first();
}
return ret;
}

static public byte[] byte_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new byte[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
byte[] ret = new byte[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Byte)s.first();
return ret;
}
}

static public boolean[] boolean_array(int size, Object init){

boolean[] ret = new boolean[size];
if(init instanceof Boolean)
{
boolean b = (Boolean) init;
for(int i = 0; i < ret.length; i++)
ret[i] = b;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Boolean)s.first();
}
return ret;
}

static public boolean[] boolean_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new boolean[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
boolean[] ret = new boolean[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = (Boolean)s.first();
8.76. NUMBERS.JAVA 787

return ret;
}
}

static public boolean[] booleans(Object array){

return (boolean[]) array;
}

static public byte[] bytes(Object array){

return (byte[]) array;
}

static public char[] chars(Object array){

return (char[]) array;
}

static public short[] shorts(Object array){

return (short[]) array;
}

static public float[] floats(Object array){

return (float[]) array;
}

static public double[] doubles(Object array){

return (double[]) array;
}

static public int[] ints(Object array){

return (int[]) array;
}

static public long[] longs(Object array){

return (long[]) array;
}

static public Number num(Object x){

return (Number) x;
}

static public Number num(float x){

return Double.valueOf(x);
}

static public Number num(double x){

return Double.valueOf(x);
}

static public double add(double x, double y){

return x + y;
788 CHAPTER 8. JVM/CLOJURE/LANG/

static public double addP(double x, double y){

return x + y;
}

static public double minus(double x, double y){

return x - y;
}

static public double minusP(double x, double y){

return x - y;
}

static public double minus(double x){

return -x;
}

static public double minusP(double x){

return -x;
}

static public double inc(double x){

return x + 1;
}

static public double incP(double x){

return x + 1;
}

static public double dec(double x){

return x - 1;
}

static public double decP(double x){

return x - 1;
}

static public double multiply(double x, double y){

return x * y;
}

static public double multiplyP(double x, double y){

return x * y;
}

static public double divide(double x, double y){

return x / y;
}
8.76. NUMBERS.JAVA 789

static public boolean equiv(double x, double y){

return x == y;
}

static public boolean lt(double x, double y){

return x < y;
}

static public boolean lte(double x, double y){

return x <= y;
}

static public boolean gt(double x, double y){

return x > y;
}

static public boolean gte(double x, double y){

return x >= y;
}

static public boolean isPos(double x){

return x > 0;
}

static public boolean isNeg(double x){

return x < 0;
}

static public boolean isZero(double x){

return x == 0;
}

static int throwIntOverflow(){

throw new ArithmeticException("integer overflow");
}

//static public Number num(int x){

// return Integer.valueOf(x);
//}

static public int unchecked_int_add(int x, int y){

return x + y;
}

static public int unchecked_int_subtract(int x, int y){

return x - y;
}

static public int unchecked_int_negate(int x){

return -x;
790 CHAPTER 8. JVM/CLOJURE/LANG/

static public int unchecked_int_inc(int x){

return x + 1;
}

static public int unchecked_int_dec(int x){

return x - 1;
}

static public int unchecked_int_multiply(int x, int y){

return x * y;
}

//static public int add(int x, int y){

// int ret = x + y;
// if ((ret ^ x) < 0 && (ret ^ y) < 0)
// return throwIntOverflow();
// return ret;
//}

//static public int not(int x){

// return ~x;
//}

static public long not(long x){

return ~x;
}
//static public int and(int x, int y){
// return x & y;
//}

static public long and(long x, long y){

return x & y;
}

//static public int or(int x, int y){

// return x | y;
//}

static public long or(long x, long y){

return x | y;
}

//static public int xor(int x, int y){

// return x ^ y;
//}

static public long xor(long x, long y){

return x ^ y;
8.76. NUMBERS.JAVA 791

//static public int minus(int x, int y){

// int ret = x - y;
// if (((ret ^ x) < 0 && (ret ^ ~y) < 0))
// return throwIntOverflow();
// return ret;
//}

//static public int minus(int x){

// if(x == Integer.MIN_VALUE)
// return throwIntOverflow();
// return -x;
//}

//static public int inc(int x){

// if(x == Integer.MAX_VALUE)
// return throwIntOverflow();
// return x + 1;
//}

//static public int dec(int x){

// if(x == Integer.MIN_VALUE)
// return throwIntOverflow();
// return x - 1;
//}

//static public int multiply(int x, int y){

// int ret = x * y;
// if (y != 0 && ret/y != x)
// return throwIntOverflow();
// return ret;
//}

static public int unchecked_int_divide(int x, int y){

return x / y;
}

static public int unchecked_int_remainder(int x, int y){

return x % y;
}

//static public boolean equiv(int x, int y){

// return x == y;
//}

//static public boolean lt(int x, int y){

// return x < y;
//}
792 CHAPTER 8. JVM/CLOJURE/LANG/

//static public boolean lte(int x, int y){

// return x <= y;
//}

//static public boolean gt(int x, int y){

// return x > y;
//}

//static public boolean gte(int x, int y){

// return x >= y;
//}

//static public boolean isPos(int x){

// return x > 0;
//}

//static public boolean isNeg(int x){

// return x < 0;
//}

//static public boolean isZero(int x){

// return x == 0;
//}

static public Number num(long x){

return Long.valueOf(x);
}

static public long

unchecked_add(long x, long y){return x + y;}
static public long
unchecked_minus(long x, long y){return x - y;}
static public long
unchecked_multiply(long x, long y){return x * y;}
static public long
unchecked_minus(long x){return -x;}
static public long
unchecked_inc(long x){return x + 1;}
static public long
unchecked_dec(long x){return x - 1;}

static public Number

unchecked_add(Object x, Object y){return add(x,y);}
static public Number
unchecked_minus(Object x, Object y){return minus(x,y);}
static public Number
unchecked_multiply(Object x, Object y){return multiply(x,y);}
static public Number
unchecked_minus(Object x){return minus(x);}
static public Number
8.76. NUMBERS.JAVA 793

unchecked_inc(Object x){return inc(x);}

static public Number
unchecked_dec(Object x){return dec(x);}

static public double

unchecked_add(double x, double y){return add(x,y);}
static public double
unchecked_minus(double x, double y){return minus(x,y);}
static public double
unchecked_multiply(double x, double y){return multiply(x,y);}
static public double
unchecked_minus(double x){return minus(x);}
static public double
unchecked_inc(double x){return inc(x);}
static public double
unchecked_dec(double x){return dec(x);}

static public double

unchecked_add(double x, Object y){return add(x,y);}
static public double
unchecked_minus(double x, Object y){return minus(x,y);}
static public double
unchecked_multiply(double x, Object y){return multiply(x,y);}
static public double
unchecked_add(Object x, double y){return add(x,y);}
static public double
unchecked_minus(Object x, double y){return minus(x,y);}
static public double
unchecked_multiply(Object x, double y){return multiply(x,y);}

static public double

unchecked_add(double x, long y){return add(x,y);}
static public double
unchecked_minus(double x, long y){return minus(x,y);}
static public double
unchecked_multiply(double x, long y){return multiply(x,y);}
static public double
unchecked_add(long x, double y){return add(x,y);}
static public double
unchecked_minus(long x, double y){return minus(x,y);}
static public double
unchecked_multiply(long x, double y){return multiply(x,y);}

static public Number

unchecked_add(long x, Object y){return add(x,y);}
static public Number
unchecked_minus(long x, Object y){return minus(x,y);}
static public Number
unchecked_multiply(long x, Object y){return multiply(x,y);}
static public Number
794 CHAPTER 8. JVM/CLOJURE/LANG/

unchecked_add(Object x, long y){return add(x,y);}

static public Number
unchecked_minus(Object x, long y){return minus(x,y);}
static public Number
unchecked_multiply(Object x, long y){return multiply(x,y);}

static public Number

quotient(double x, Object y){return quotient((Object)x,y);}
static public Number
quotient(Object x, double y){return quotient(x,(Object)y);}
static public Number
quotient(long x, Object y){return quotient((Object)x,y);}
static public Number
quotient(Object x, long y){return quotient(x,(Object)y);}
static public double
quotient(double x, long y){return quotient(x,(double)y);}
static public double
quotient(long x, double y){return quotient((double)x,y);}

static public Number

remainder(double x, Object y){return remainder((Object)x,y);}
static public Number
remainder(Object x, double y){return remainder(x,(Object)y);}
static public Number
remainder(long x, Object y){return remainder((Object)x,y);}
static public Number
remainder(Object x, long y){return remainder(x,(Object)y);}
static public double
remainder(double x, long y){return remainder(x,(double)y);}
static public double
remainder(long x, double y){return remainder((double)x,y);}

static public long add(long x, long y){

long ret = x + y;
if ((ret ^ x) < 0 && (ret ^ y) < 0)
return throwIntOverflow();
return ret;
}

static public Number addP(long x, long y){

long ret = x + y;
if ((ret ^ x) < 0 && (ret ^ y) < 0)
return addP((Number)x,(Number)y);
return num(ret);
}

static public long minus(long x, long y){

long ret = x - y;
if (((ret ^ x) < 0 && (ret ^ ~y) < 0))
return throwIntOverflow();
8.76. NUMBERS.JAVA 795

return ret;
}

static public Number minusP(long x, long y){

long ret = x - y;
if (((ret ^ x) < 0 && (ret ^ ~y) < 0))
return minusP((Number)x,(Number)y);
return num(ret);
}

static public long minus(long x){

if(x == Long.MIN_VALUE)
return throwIntOverflow();
return -x;
}

static public Number minusP(long x){

if(x == Long.MIN_VALUE)
return BigInt.fromBigInteger(BigInteger.valueOf(x).negate());
return num(-x);
}

static public long inc(long x){

if(x == Long.MAX_VALUE)
return throwIntOverflow();
return x + 1;
}

static public Number incP(long x){

if(x == Long.MAX_VALUE)
return BIGINT_OPS.inc(x);
return num(x + 1);
}

static public long dec(long x){

if(x == Long.MIN_VALUE)
return throwIntOverflow();
return x - 1;
}

static public Number decP(long x){

if(x == Long.MIN_VALUE)
return BIGINT_OPS.dec(x);
return num(x - 1);
}

static public long multiply(long x, long y){

long ret = x * y;
if (y != 0 && ret/y != x)
796 CHAPTER 8. JVM/CLOJURE/LANG/

return throwIntOverflow();
return ret;
}

static public Number multiplyP(long x, long y){

long ret = x * y;
if (y != 0 && ret/y != x)
return multiplyP((Number)x,(Number)y);
return num(ret);
}

static public long quotient(long x, long y){

return x / y;
}

static public long remainder(long x, long y){

return x % y;
}

static public boolean equiv(long x, long y){

return x == y;
}

static public boolean lt(long x, long y){

return x < y;
}

static public boolean lte(long x, long y){

return x <= y;
}

static public boolean gt(long x, long y){

return x > y;
}

static public boolean gte(long x, long y){

return x >= y;
}

static public boolean isPos(long x){

return x > 0;
}

static public boolean isNeg(long x){

return x < 0;
}

static public boolean isZero(long x){

return x == 0;
}
8.76. NUMBERS.JAVA 797

/*
static public class F{
static public float add(float x, float y){
return x + y;
}

static public float subtract(float x, float y){

return x - y;
}

static public float negate(float x){

return -x;
}

static public float inc(float x){

return x + 1;
}

static public float dec(float x){

return x - 1;
}

static public float multiply(float x, float y){

return x * y;
}

static public float divide(float x, float y){

return x / y;
}

static public boolean equiv(float x, float y){

return x == y;
}

static public boolean lt(float x, float y){

return x < y;
}

static public boolean lte(float x, float y){

return x <= y;
}

static public boolean gt(float x, float y){

return x > y;
}

static public boolean gte(float x, float y){

return x >= y;
}
798 CHAPTER 8. JVM/CLOJURE/LANG/

static public boolean pos(float x){

return x > 0;
}

static public boolean neg(float x){

return x < 0;
}

static public boolean zero(float x){

return x == 0;
}

static public float aget(float[] xs, int i){

return xs[i];
}

static public float aset(float[] xs, int i, float v){

xs[i] = v;
return v;
}

static public int alength(float[] xs){

return xs.length;
}

static public float[] aclone(float[] xs){

return xs.clone();
}

static public float[] vec(int size, Object init){

float[] ret = new float[size];
if(init instanceof Number)
{
float f = ((Number) init).floatValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).floatValue();
}
return ret;
}

static public float[] vec(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new float[((Number) sizeOrSeq).intValue()];
8.76. NUMBERS.JAVA 799

else
{
ISeq s = RT.seq(sizeOrSeq);
int size = s.count();
float[] ret = new float[size];
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).intValue();
return ret;
}
}

static public float[] vsadd(float[] x, float y){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += y;
return xs;
}

static public float[] vssub(float[] x, float y){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= y;
return xs;
}

static public float[] vsdiv(float[] x, float y){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= y;
return xs;
}

static public float[] vsmul(float[] x, float y){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= y;
return xs;
}

static public float[] svdiv(float y, float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = y / xs[i];
return xs;
}

static public float[] vsmuladd(float[] x, float y, float[] zs){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
800 CHAPTER 8. JVM/CLOJURE/LANG/

xs[i] = xs[i] * y + zs[i];

return xs;
}

static public float[] vsmulsub(float[] x, float y, float[] zs){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - zs[i];
return xs;
}

static public float[] vsmulsadd(float[] x, float y, float z){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y + z;
return xs;
}

static public float[] vsmulssub(float[] x, float y, float z){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - z;
return xs;
}

static public float[] vabs(float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.abs(xs[i]);
return xs;
}

static public float[] vnegabs(float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -Math.abs(xs[i]);
return xs;
}

static public float[] vneg(float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -xs[i];
return xs;
}

static public float[] vsqr(float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= xs[i];
8.76. NUMBERS.JAVA 801

return xs;
}

static public float[] vsignedsqr(float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= Math.abs(xs[i]);
return xs;
}

static public float[] vclip(float[] x, float low, float high){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < low)
xs[i] = low;
else if(xs[i] > high)
xs[i] = high;
}
return xs;
}

static public IPersistentVector vclipcounts(float[] x,

float low,
float high){
final float[] xs = x.clone();
int lowc = 0;
int highc = 0;

for(int i = 0; i < xs.length; i++)

{
if(xs[i] < low)
{
++lowc;
xs[i] = low;
}
else if(xs[i] > high)
{
++highc;
xs[i] = high;
}
}
return RT.vector(xs, lowc, highc);
}

static public float[] vthresh(float[] x,

float thresh,
float otherwise){
final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
802 CHAPTER 8. JVM/CLOJURE/LANG/

{
if(xs[i] < thresh)
xs[i] = otherwise;
}
return xs;
}

static public float[] vreverse(float[] x){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[xs.length - i - 1];
return xs;
}

static public float[] vrunningsum(float[] x){

final float[] xs = x.clone();
for(int i = 1; i < xs.length; i++)
xs[i] = xs[i - 1] + xs[i];
return xs;
}

static public float[] vsort(float[] x){

final float[] xs = x.clone();
Arrays.sort(xs);
return xs;
}

static public float vdot(float[] xs, float[] ys){

float ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * ys[i];
return ret;
}

static public float vmax(float[] xs){

if(xs.length == 0)
return 0;
float ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.max(ret, xs[i]);
return ret;
}

static public float vmin(float[] xs){

if(xs.length == 0)
return 0;
float ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.min(ret, xs[i]);
return ret;
8.76. NUMBERS.JAVA 803

static public float vmean(float[] xs){

if(xs.length == 0)
return 0;
return vsum(xs) / xs.length;
}

static public double vrms(float[] xs){

if(xs.length == 0)
return 0;
float ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * xs[i];
return Math.sqrt(ret / xs.length);
}

static public float vsum(float[] xs){

float ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i];
return ret;
}

static public boolean vequiv(float[] xs, float[] ys){

return Arrays.equals(xs, ys);
}

static public float[] vadd(float[] x, float[] ys){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += ys[i];
return xs;
}

static public float[] vsub(float[] x, float[] ys){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= ys[i];
return xs;
}

static public float[] vaddmul(float[] x, float[] ys, float[] zs){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * zs[i];
return xs;
}

static public float[] vsubmul(float[] x, float[] ys, float[] zs){

804 CHAPTER 8. JVM/CLOJURE/LANG/

final float[] xs = x.clone();

for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * zs[i];
return xs;
}

static public float[] vaddsmul(float[] x, float[] ys, float z){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * z;
return xs;
}

static public float[] vsubsmul(float[] x, float[] ys, float z){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * z;
return xs;
}

static public float[] vmulsadd(float[] x, float[] ys, float z){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + z;
return xs;
}

static public float[] vdiv(float[] x, float[] ys){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= ys[i];
return xs;
}

static public float[] vmul(float[] x, float[] ys){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= ys[i];
return xs;
}

static public float[] vmuladd(float[] x, float[] ys, float[] zs){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + zs[i];
return xs;
}

static public float[] vmulsub(float[] x, float[] ys, float[] zs){

final float[] xs = x.clone();
8.76. NUMBERS.JAVA 805

for(int i = 0; i < xs.length; i++)

xs[i] = (xs[i] * ys[i]) - zs[i];
return xs;
}

static public float[] vmax(float[] x, float[] ys){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.max(xs[i], ys[i]);
return xs;
}

static public float[] vmin(float[] x, float[] ys){

final float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.min(xs[i], ys[i]);
return xs;
}

static public float[] vmap(IFn fn, float[] x) throws Exception{

float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = ((Number) fn.invoke(xs[i])).floatValue();
return xs;
}

static public float[] vmap(IFn fn,

float[] x,
float[] ys) throws Exception{
float[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = ((Number) fn.invoke(xs[i], ys[i])).floatValue();
return xs;
}

static public class D{

static public double add(double x, double y){
return x + y;
}

static public double subtract(double x, double y){

return x - y;
}

static public double negate(double x){

return -x;
}
806 CHAPTER 8. JVM/CLOJURE/LANG/

static public double inc(double x){

return x + 1;
}

static public double dec(double x){

return x - 1;
}

static public double multiply(double x, double y){

return x * y;
}

static public double divide(double x, double y){

return x / y;
}

static public boolean equiv(double x, double y){

return x == y;
}

static public boolean lt(double x, double y){

return x < y;
}

static public boolean lte(double x, double y){

return x <= y;
}

static public boolean gt(double x, double y){

return x > y;
}

static public boolean gte(double x, double y){

return x >= y;
}

static public boolean pos(double x){

return x > 0;
}

static public boolean neg(double x){

return x < 0;
}

static public boolean zero(double x){

return x == 0;
}

static public double aget(double[] xs, int i){

return xs[i];
8.76. NUMBERS.JAVA 807

static public double aset(double[] xs, int i, double v){

xs[i] = v;
return v;
}

static public int alength(double[] xs){

return xs.length;
}

static public double[] aclone(double[] xs){

return xs.clone();
}

static public double[] vec(int size, Object init){

double[] ret = new double[size];
if(init instanceof Number)
{
double f = ((Number) init).doubleValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).doubleValue();
}
return ret;
}

static public double[] vec(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new double[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = s.count();
double[] ret = new double[size];
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).intValue();
return ret;
}
}

static public double[] vsadd(double[] x, double y){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += y;
808 CHAPTER 8. JVM/CLOJURE/LANG/

return xs;
}

static public double[] vssub(double[] x, double y){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= y;
return xs;
}

static public double[] vsdiv(double[] x, double y){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= y;
return xs;
}

static public double[] vsmul(double[] x, double y){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= y;
return xs;
}

static public double[] svdiv(double y, double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = y / xs[i];
return xs;
}

static public double[] vsmuladd(double[] x, double y, double[] zs){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y + zs[i];
return xs;
}

static public double[] vsmulsub(double[] x, double y, double[] zs){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - zs[i];
return xs;
}

static public double[] vsmulsadd(double[] x, double y, double z){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y + z;
return xs;
8.76. NUMBERS.JAVA 809

static public double[] vsmulssub(double[] x, double y, double z){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - z;
return xs;
}

static public double[] vabs(double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.abs(xs[i]);
return xs;
}

static public double[] vnegabs(double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -Math.abs(xs[i]);
return xs;
}

static public double[] vneg(double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -xs[i];
return xs;
}

static public double[] vsqr(double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= xs[i];
return xs;
}

static public double[] vsignedsqr(double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= Math.abs(xs[i]);
return xs;
}

static public double[] vclip(double[] x, double low, double high){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < low)
xs[i] = low;
810 CHAPTER 8. JVM/CLOJURE/LANG/

else if(xs[i] > high)

xs[i] = high;
}
return xs;
}

static public IPersistentVector vclipcounts(double[] x,

double low,
double high){
final double[] xs = x.clone();
int lowc = 0;
int highc = 0;

for(int i = 0; i < xs.length; i++)

{
if(xs[i] < low)
{
++lowc;
xs[i] = low;
}
else if(xs[i] > high)
{
++highc;
xs[i] = high;
}
}
return RT.vector(xs, lowc, highc);
}

static public double[] vthresh(double[] x,

double thresh,
double otherwise){
final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < thresh)
xs[i] = otherwise;
}
return xs;
}

static public double[] vreverse(double[] x){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[xs.length - i - 1];
return xs;
}

static public double[] vrunningsum(double[] x){

final double[] xs = x.clone();
8.76. NUMBERS.JAVA 811

for(int i = 1; i < xs.length; i++)

xs[i] = xs[i - 1] + xs[i];
return xs;
}

static public double[] vsort(double[] x){

final double[] xs = x.clone();
Arrays.sort(xs);
return xs;
}

static public double vdot(double[] xs, double[] ys){

double ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * ys[i];
return ret;
}

static public double vmax(double[] xs){

if(xs.length == 0)
return 0;
double ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.max(ret, xs[i]);
return ret;
}

static public double vmin(double[] xs){

if(xs.length == 0)
return 0;
double ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.min(ret, xs[i]);
return ret;
}

static public double vmean(double[] xs){

if(xs.length == 0)
return 0;
return vsum(xs) / xs.length;
}

static public double vrms(double[] xs){

if(xs.length == 0)
return 0;
double ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * xs[i];
return Math.sqrt(ret / xs.length);
}
812 CHAPTER 8. JVM/CLOJURE/LANG/

static public double vsum(double[] xs){

double ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i];
return ret;
}

static public boolean vequiv(double[] xs, double[] ys){

return Arrays.equals(xs, ys);
}

static public double[] vadd(double[] x, double[] ys){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += ys[i];
return xs;
}

static public double[] vsub(double[] x, double[] ys){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= ys[i];
return xs;
}

static public double[] vaddmul(double[] x,

double[] ys,
double[] zs){
final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * zs[i];
return xs;
}

static public double[] vsubmul(double[] x, double[] ys, double[] zs){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * zs[i];
return xs;
}

static public double[] vaddsmul(double[] x, double[] ys, double z){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * z;
return xs;
}

static public double[] vsubsmul(double[] x, double[] ys, double z){

8.76. NUMBERS.JAVA 813

final double[] xs = x.clone();

for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * z;
return xs;
}

static public double[] vmulsadd(double[] x, double[] ys, double z){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + z;
return xs;
}

static public double[] vdiv(double[] x, double[] ys){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= ys[i];
return xs;
}

static public double[] vmul(double[] x, double[] ys){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= ys[i];
return xs;
}

static public double[] vmuladd(double[] x, double[] ys, double[] zs){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + zs[i];
return xs;
}

static public double[] vmulsub(double[] x, double[] ys, double[] zs){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) - zs[i];
return xs;
}

static public double[] vmax(double[] x, double[] ys){

final double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.max(xs[i], ys[i]);
return xs;
}

static public double[] vmin(double[] x, double[] ys){

final double[] xs = x.clone();
814 CHAPTER 8. JVM/CLOJURE/LANG/

for(int i = 0; i < xs.length; i++)

xs[i] = Math.min(xs[i], ys[i]);
return xs;
}

static public double[] vmap(IFn fn, double[] x) throws Exception{

double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = ((Number) fn.invoke(xs[i])).doubleValue();
return xs;
}

static public double[] vmap(IFn fn,

double[] x,
double[] ys) throws Exception{
double[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = ((Number) fn.invoke(xs[i], ys[i])).doubleValue();
return xs;
}
}

static public class I{

static public int add(int x, int y){
return x + y;
}

static public int subtract(int x, int y){

return x - y;
}

static public int negate(int x){

return -x;
}

static public int inc(int x){

return x + 1;
}

static public int dec(int x){

return x - 1;
}

static public int multiply(int x, int y){

return x * y;
}

static public int divide(int x, int y){

return x / y;
}
8.76. NUMBERS.JAVA 815

static public boolean equiv(int x, int y){

return x == y;
}

static public boolean lt(int x, int y){

return x < y;
}

static public boolean lte(int x, int y){

return x <= y;
}

static public boolean gt(int x, int y){

return x > y;
}

static public boolean gte(int x, int y){

return x >= y;
}

static public boolean pos(int x){

return x > 0;
}

static public boolean neg(int x){

return x < 0;
}

static public boolean zero(int x){

return x == 0;
}

static public int aget(int[] xs, int i){

return xs[i];
}

static public int aset(int[] xs, int i, int v){

xs[i] = v;
return v;
}

static public int alength(int[] xs){

return xs.length;
}

static public int[] aclone(int[] xs){

return xs.clone();
}
816 CHAPTER 8. JVM/CLOJURE/LANG/

static public int[] vec(int size, Object init){

int[] ret = new int[size];
if(init instanceof Number)
{
int f = ((Number) init).intValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).intValue();
}
return ret;
}

static public int[] vec(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new int[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = s.count();
int[] ret = new int[size];
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).intValue();
return ret;
}
}

static public int[] vsadd(int[] x, int y){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += y;
return xs;
}

static public int[] vssub(int[] x, int y){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= y;
return xs;
}

static public int[] vsdiv(int[] x, int y){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= y;
return xs;
8.76. NUMBERS.JAVA 817

static public int[] vsmul(int[] x, int y){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= y;
return xs;
}

static public int[] svdiv(int y, int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = y / xs[i];
return xs;
}

static public int[] vsmuladd(int[] x, int y, int[] zs){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y + zs[i];
return xs;
}

static public int[] vsmulsub(int[] x, int y, int[] zs){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - zs[i];
return xs;
}

static public int[] vsmulsadd(int[] x, int y, int z){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y + z;
return xs;
}

static public int[] vsmulssub(int[] x, int y, int z){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - z;
return xs;
}

static public int[] vabs(int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.abs(xs[i]);
return xs;
}
818 CHAPTER 8. JVM/CLOJURE/LANG/

static public int[] vnegabs(int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -Math.abs(xs[i]);
return xs;
}

static public int[] vneg(int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -xs[i];
return xs;
}

static public int[] vsqr(int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= xs[i];
return xs;
}

static public int[] vsignedsqr(int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= Math.abs(xs[i]);
return xs;
}

static public int[] vclip(int[] x, int low, int high){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < low)
xs[i] = low;
else if(xs[i] > high)
xs[i] = high;
}
return xs;
}

static public IPersistentVector vclipcounts(int[] x,

int low,
int high){
final int[] xs = x.clone();
int lowc = 0;
int highc = 0;

for(int i = 0; i < xs.length; i++)

{
8.76. NUMBERS.JAVA 819

if(xs[i] < low)

{
++lowc;
xs[i] = low;
}
else if(xs[i] > high)
{
++highc;
xs[i] = high;
}
}
return RT.vector(xs, lowc, highc);
}

static public int[] vthresh(int[] x, int thresh, int otherwise){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < thresh)
xs[i] = otherwise;
}
return xs;
}

static public int[] vreverse(int[] x){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[xs.length - i - 1];
return xs;
}

static public int[] vrunningsum(int[] x){

final int[] xs = x.clone();
for(int i = 1; i < xs.length; i++)
xs[i] = xs[i - 1] + xs[i];
return xs;
}

static public int[] vsort(int[] x){

final int[] xs = x.clone();
Arrays.sort(xs);
return xs;
}

static public int vdot(int[] xs, int[] ys){

int ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * ys[i];
return ret;
}
820 CHAPTER 8. JVM/CLOJURE/LANG/

static public int vmax(int[] xs){

if(xs.length == 0)
return 0;
int ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.max(ret, xs[i]);
return ret;
}

static public int vmin(int[] xs){

if(xs.length == 0)
return 0;
int ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.min(ret, xs[i]);
return ret;
}

static public double vmean(int[] xs){

if(xs.length == 0)
return 0;
return vsum(xs) / (double) xs.length;
}

static public double vrms(int[] xs){

if(xs.length == 0)
return 0;
int ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * xs[i];
return Math.sqrt(ret / (double) xs.length);
}

static public int vsum(int[] xs){

int ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i];
return ret;
}

static public boolean vequiv(int[] xs, int[] ys){

return Arrays.equals(xs, ys);
}

static public int[] vadd(int[] x, int[] ys){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += ys[i];
return xs;
8.76. NUMBERS.JAVA 821

static public int[] vsub(int[] x, int[] ys){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= ys[i];
return xs;
}

static public int[] vaddmul(int[] x, int[] ys, int[] zs){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * zs[i];
return xs;
}

static public int[] vsubmul(int[] x, int[] ys, int[] zs){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * zs[i];
return xs;
}

static public int[] vaddsmul(int[] x, int[] ys, int z){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * z;
return xs;
}

static public int[] vsubsmul(int[] x, int[] ys, int z){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * z;
return xs;
}

static public int[] vmulsadd(int[] x, int[] ys, int z){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + z;
return xs;
}

static public int[] vdiv(int[] x, int[] ys){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= ys[i];
return xs;
}
822 CHAPTER 8. JVM/CLOJURE/LANG/

static public int[] vmul(int[] x, int[] ys){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= ys[i];
return xs;
}

static public int[] vmuladd(int[] x, int[] ys, int[] zs){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + zs[i];
return xs;
}

static public int[] vmulsub(int[] x, int[] ys, int[] zs){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) - zs[i];
return xs;
}

static public int[] vmax(int[] x, int[] ys){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.max(xs[i], ys[i]);
return xs;
}

static public int[] vmin(int[] x, int[] ys){

final int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.min(xs[i], ys[i]);
return xs;
}

static public int[] vmap(IFn fn, int[] x) throws Exception{

int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = ((Number) fn.invoke(xs[i])).intValue();
return xs;
}

static public int[] vmap(IFn fn, int[] x, int[] ys) throws Exception{
int[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = ((Number) fn.invoke(xs[i], ys[i])).intValue();
return xs;
}
8.76. NUMBERS.JAVA 823

static public class L{

static public long add(long x, long y){
return x + y;
}

static public long subtract(long x, long y){

return x - y;
}

static public long negate(long x){

return -x;
}

static public long inc(long x){

return x + 1;
}

static public long dec(long x){

return x - 1;
}

static public long multiply(long x, long y){

return x * y;
}

static public long divide(long x, long y){

return x / y;
}

static public boolean equiv(long x, long y){

return x == y;
}

static public boolean lt(long x, long y){

return x < y;
}

static public boolean lte(long x, long y){

return x <= y;
}

static public boolean gt(long x, long y){

return x > y;
}

static public boolean gte(long x, long y){

return x >= y;
}
824 CHAPTER 8. JVM/CLOJURE/LANG/

static public boolean pos(long x){

return x > 0;
}

static public boolean neg(long x){

return x < 0;
}

static public boolean zero(long x){

return x == 0;
}

static public long aget(long[] xs, int i){

return xs[i];
}

static public long aset(long[] xs, int i, long v){

xs[i] = v;
return v;
}

static public int alength(long[] xs){

return xs.length;
}

static public long[] aclone(long[] xs){

return xs.clone();
}

static public long[] vec(int size, Object init){

long[] ret = new long[size];
if(init instanceof Number)
{
long f = ((Number) init).longValue();
for(int i = 0; i < ret.length; i++)
ret[i] = f;
}
else
{
ISeq s = RT.seq(init);
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).longValue();
}
return ret;
}

static public long[] vec(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new long[((Number) sizeOrSeq).intValue()];
8.76. NUMBERS.JAVA 825

else
{
ISeq s = RT.seq(sizeOrSeq);
int size = s.count();
long[] ret = new long[size];
for(int i = 0; i < size && s != null; i++, s = s.rest())
ret[i] = ((Number) s.first()).intValue();
return ret;
}
}

static public long[] vsadd(long[] x, long y){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += y;
return xs;
}

static public long[] vssub(long[] x, long y){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= y;
return xs;
}

static public long[] vsdiv(long[] x, long y){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= y;
return xs;
}

static public long[] vsmul(long[] x, long y){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= y;
return xs;
}

static public long[] svdiv(long y, long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = y / xs[i];
return xs;
}

static public long[] vsmuladd(long[] x, long y, long[] zs){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
826 CHAPTER 8. JVM/CLOJURE/LANG/

xs[i] = xs[i] * y + zs[i];

return xs;
}

static public long[] vsmulsub(long[] x, long y, long[] zs){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - zs[i];
return xs;
}

static public long[] vsmulsadd(long[] x, long y, long z){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y + z;
return xs;
}

static public long[] vsmulssub(long[] x, long y, long z){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[i] * y - z;
return xs;
}

static public long[] vabs(long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = Math.abs(xs[i]);
return xs;
}

static public long[] vnegabs(long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -Math.abs(xs[i]);
return xs;
}

static public long[] vneg(long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = -xs[i];
return xs;
}

static public long[] vsqr(long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= xs[i];
8.76. NUMBERS.JAVA 827

return xs;
}

static public long[] vsignedsqr(long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= Math.abs(xs[i]);
return xs;
}

static public long[] vclip(long[] x, long low, long high){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < low)
xs[i] = low;
else if(xs[i] > high)
xs[i] = high;
}
return xs;
}

static public IPersistentVector vclipcounts(long[] x,

long low,
long high){
final long[] xs = x.clone();
int lowc = 0;
int highc = 0;

for(int i = 0; i < xs.length; i++)

{
if(xs[i] < low)
{
++lowc;
xs[i] = low;
}
else if(xs[i] > high)
{
++highc;
xs[i] = high;
}
}
return RT.vector(xs, lowc, highc);
}

static public long[] vthresh(long[] x, long thresh, long otherwise){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
{
if(xs[i] < thresh)
828 CHAPTER 8. JVM/CLOJURE/LANG/

xs[i] = otherwise;
}
return xs;
}

static public long[] vreverse(long[] x){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = xs[xs.length - i - 1];
return xs;
}

static public long[] vrunningsum(long[] x){

final long[] xs = x.clone();
for(int i = 1; i < xs.length; i++)
xs[i] = xs[i - 1] + xs[i];
return xs;
}

static public long[] vsort(long[] x){

final long[] xs = x.clone();
Arrays.sort(xs);
return xs;
}

static public long vdot(long[] xs, long[] ys){

long ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * ys[i];
return ret;
}

static public long vmax(long[] xs){

if(xs.length == 0)
return 0;
long ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.max(ret, xs[i]);
return ret;
}

static public long vmin(long[] xs){

if(xs.length == 0)
return 0;
long ret = xs[0];
for(int i = 0; i < xs.length; i++)
ret = Math.min(ret, xs[i]);
return ret;
}
8.76. NUMBERS.JAVA 829

static public double vmean(long[] xs){

if(xs.length == 0)
return 0;
return vsum(xs) / (double) xs.length;
}

static public double vrms(long[] xs){

if(xs.length == 0)
return 0;
long ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i] * xs[i];
return Math.sqrt(ret / (double) xs.length);
}

static public long vsum(long[] xs){

long ret = 0;
for(int i = 0; i < xs.length; i++)
ret += xs[i];
return ret;
}

static public boolean vequiv(long[] xs, long[] ys){

return Arrays.equals(xs, ys);
}

static public long[] vadd(long[] x, long[] ys){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] += ys[i];
return xs;
}

static public long[] vsub(long[] x, long[] ys){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] -= ys[i];
return xs;
}

static public long[] vaddmul(long[] x, long[] ys, long[] zs){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * zs[i];
return xs;
}

static public long[] vsubmul(long[] x, long[] ys, long[] zs){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
830 CHAPTER 8. JVM/CLOJURE/LANG/

xs[i] = (xs[i] - ys[i]) * zs[i];

return xs;
}

static public long[] vaddsmul(long[] x, long[] ys, long z){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] + ys[i]) * z;
return xs;
}

static public long[] vsubsmul(long[] x, long[] ys, long z){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] - ys[i]) * z;
return xs;
}

static public long[] vmulsadd(long[] x, long[] ys, long z){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + z;
return xs;
}

static public long[] vdiv(long[] x, long[] ys){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] /= ys[i];
return xs;
}

static public long[] vmul(long[] x, long[] ys){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] *= ys[i];
return xs;
}

static public long[] vmuladd(long[] x, long[] ys, long[] zs){

final long[] xs = x.clone();
for(int i = 0; i < xs.length; i++)
xs[i] = (xs[i] * ys[i]) + zs[i];
return xs;
}

static public long[] vmulsub(long[] x, long[] ys, long[] zs){

static public Number minusP(long x, Object y){

return minusP((Object)x,y);
}

static public Number minusP(Object x, long y){

static public double divide(Object x, double y){

return ((Number)x).doubleValue() / y;
}

static public double divide(double x, long y){

8.76. NUMBERS.JAVA 835

return x / y;
}

static public double divide(long x, double y){

return x / y;
}

static public boolean lt(long x, Object y){

return lt((Object)x,y);
}

static public boolean lt(Object x, long y){

return lt(x,(Object)y);
}

static public boolean lt(double x, Object y){

return x < ((Number)y).doubleValue();
}

static public boolean lt(Object x, double y){

return ((Number)x).doubleValue() < y;
}

static public boolean lt(double x, long y){

return x < y;
}

static public boolean lt(long x, double y){

return x < y;
}

static public boolean lte(long x, Object y){

return lte((Object)x,y);
}

static public boolean lte(Object x, long y){

return lte(x,(Object)y);
}

static public boolean lte(double x, Object y){

return x <= ((Number)y).doubleValue();
}

static public boolean lte(Object x, double y){

return ((Number)x).doubleValue() <= y;
}

static public boolean lte(double x, long y){

return x <= y;
}
836 CHAPTER 8. JVM/CLOJURE/LANG/

static public boolean lte(long x, double y){

return x <= y;
}

static public boolean gt(long x, Object y){

return gt((Object)x,y);
}

static public boolean gt(Object x, long y){

return gt(x,(Object)y);
}

static public boolean gt(double x, Object y){

return x > ((Number)y).doubleValue();
}

static public boolean gt(Object x, double y){

return ((Number)x).doubleValue() > y;
}

static public boolean gt(double x, long y){

return x > y;
}

static public boolean gt(long x, double y){

return x > y;
}

static public boolean gte(long x, Object y){

return gte((Object)x,y);
}

static public boolean gte(Object x, long y){

return gte(x,(Object)y);
}

static public boolean gte(double x, Object y){

return x >= ((Number)y).doubleValue();
}

static public boolean gte(Object x, double y){

return ((Number)x).doubleValue() >= y;
}

static public boolean gte(double x, long y){

return x >= y;
}

static public boolean gte(long x, double y){

8.77. OBJ.JAVA 837

return x >= y;
}

static public boolean equiv(long x, Object y){

return equiv((Object)x,y);
}

static public boolean equiv(Object x, long y){

return equiv(x,(Object)y);
}

static public boolean equiv(double x, Object y){

return x == ((Number)y).doubleValue();
}

static public boolean equiv(Object x, double y){

return ((Number)x).doubleValue() == y;
}

static public boolean equiv(double x, long y){

return x == y;
}

static public boolean equiv(long x, double y){

return x == y;
}

———-

8.77 Obj.java

— Obj.java —

\getchunk{Clojure Copyright}
/* rich Mar 25, 2006 3:44:58 PM */

package clojure.lang;

import java.io.Serializable;

public abstract class Obj implements IObj, Serializable {

final IPersistentMap _meta;

838 CHAPTER 8. JVM/CLOJURE/LANG/

public Obj(IPersistentMap meta){

this._meta = meta;
}

public Obj(){
_meta = null;
}

final public IPersistentMap meta(){

return _meta;
}

abstract public Obj withMeta(IPersistentMap meta);

———-

8.78 PersistentArrayMap.java

— PersistentArrayMap.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;

/**
* Simple implementation of persistent map on an array
* 
* Note that instances of this class are constant values
* i.e. add/remove etc return new values
* 
* Copies array on every change, so only appropriate for
* _very_small_ maps
* 
* null keys and values are ok, but you won’t be able to distinguish
* a null value via valAt - use contains/entryAt
*/

public class PersistentArrayMap

extends APersistentMap implements IObj, IEditableCollection {

final Object[] array;

8.78. PERSISTENTARRAYMAP.JAVA 839

static final int HASHTABLE_THRESHOLD = 16;

public static final PersistentArrayMap EMPTY = new PersistentArrayMap();

private final IPersistentMap _meta;

static public IPersistentMap create(Map other){

ITransientMap ret = EMPTY.asTransient();
for(Object o : other.entrySet())
{
Map.Entry e = (Entry) o;
ret = ret.assoc(e.getKey(), e.getValue());
}
return ret.persistent();
}

protected PersistentArrayMap(){
this.array = new Object[]{};
this._meta = null;
}

public PersistentArrayMap withMeta(IPersistentMap meta){

return new PersistentArrayMap(meta, array);
}

PersistentArrayMap create(Object... init){

return new PersistentArrayMap(meta(), init);
}

IPersistentMap createHT(Object[] init){

return PersistentHashMap.create(meta(), init);
}

static public PersistentArrayMap createWithCheck(Object[] init){

for(int i=0;i< init.length;i += 2)
{
for(int j=i+2;j<init.length;j += 2)
{
if(equalKey(init[i],init[j]))
throw new IllegalArgumentException("Duplicate key: " + init[i]);
}
}
return new PersistentArrayMap(init);
}
/**
* This ctor captures/aliases the passed array, so do not modify later
*
* @param init {key1,val1,key2,val2,...}
*/
public PersistentArrayMap(Object[] init){
this.array = init;
840 CHAPTER 8. JVM/CLOJURE/LANG/

this._meta = null;
}

public PersistentArrayMap(IPersistentMap meta, Object[] init){

this._meta = meta;
this.array = init;
}

public int count(){

return array.length / 2;
}

public boolean containsKey(Object key){

return indexOf(key) >= 0;
}

public IMapEntry entryAt(Object key){

int i = indexOf(key);
if(i >= 0)
return new MapEntry(array[i],array[i+1]);
return null;
}

public IPersistentMap assocEx(Object key, Object val) throws Exception{

int i = indexOf(key);
Object[] newArray;
if(i >= 0)
{
throw new Exception("Key already present");
}
else //didn’t have key, grow
{
if(array.length > HASHTABLE_THRESHOLD)
return createHT(array).assocEx(key, val);
newArray = new Object[array.length + 2];
if(array.length > 0)
System.arraycopy(array, 0, newArray, 2, array.length);
newArray[0] = key;
newArray[1] = val;
}
return create(newArray);
}

public IPersistentMap assoc(Object key, Object val){

int i = indexOf(key);
Object[] newArray;
if(i >= 0) //already have key, same-sized replacement
{
if(array[i + 1] == val) //no change, no op
8.78. PERSISTENTARRAYMAP.JAVA 841

return this;
newArray = array.clone();
newArray[i + 1] = val;
}
else //didn’t have key, grow
{
if(array.length > HASHTABLE_THRESHOLD)
return createHT(array).assoc(key, val);
newArray = new Object[array.length + 2];
if(array.length > 0)
System.arraycopy(array, 0, newArray, 2, array.length);
newArray[0] = key;
newArray[1] = val;
}
return create(newArray);
}

public IPersistentMap without(Object key){

int i = indexOf(key);
if(i >= 0) //have key, will remove
{
int newlen = array.length - 2;
if(newlen == 0)
return empty();
Object[] newArray = new Object[newlen];
for(int s = 0, d = 0; s < array.length; s += 2)
{
if(!equalKey(array[s], key)) //skip removal key
{
newArray[d] = array[s];
newArray[d + 1] = array[s + 1];
d += 2;
}
}
return create(newArray);
}
//don’t have key, no op
return this;
}

public IPersistentMap empty(){

return (IPersistentMap) EMPTY.withMeta(meta());
}

final public Object valAt(Object key, Object notFound){

int i = indexOf(key);
if(i >= 0)
return array[i + 1];
return notFound;
}
842 CHAPTER 8. JVM/CLOJURE/LANG/

public Object valAt(Object key){

return valAt(key, null);
}

public int capacity(){

return count();
}

private int indexOf(Object key){

for(int i = 0; i < array.length; i += 2)
{
if(equalKey(array[i], key))
return i;
}
return -1;
}

static boolean equalKey(Object k1, Object k2){

return Util.equiv(k1, k2);
}

public Iterator iterator(){

return new Iter(array);
}

public ISeq seq(){

if(array.length > 0)
return new Seq(array, 0);
return null;
}

public IPersistentMap meta(){

return _meta;
}

static class Seq extends ASeq implements Counted{

final Object[] array;
final int i;

Seq(Object[] array, int i){

this.array = array;
this.i = i;
}

public Seq(IPersistentMap meta, Object[] array, int i){

super(meta);
this.array = array;
this.i = i;
}
8.78. PERSISTENTARRAYMAP.JAVA 843

public Object first(){

return new MapEntry(array[i],array[i+1]);
}

public ISeq next(){

if(i + 2 < array.length)
return new Seq(array, i + 2);
return null;
}

public int count(){

return (array.length - i) / 2;
}

public Obj withMeta(IPersistentMap meta){

return new Seq(meta, array, i);
}
}

static class Iter implements Iterator{

Object[] array;
int i;

//for iterator
Iter(Object[] array){
this(array, -2);
}

//for entryAt
Iter(Object[] array, int i){
this.array = array;
this.i = i;
}

public boolean hasNext(){

return i < array.length - 2;
}

public Object next(){

i += 2;
return new MapEntry(array[i],array[i+1]);
}

public void remove(){

throw new UnsupportedOperationException();
}

}
844 CHAPTER 8. JVM/CLOJURE/LANG/

public ITransientMap asTransient(){

return new TransientArrayMap(array);
}

static final class TransientArrayMap extends ATransientMap {

int len;
final Object[] array;
Thread owner;

public TransientArrayMap(Object[] array){

this.owner = Thread.currentThread();
this.array =
new Object[Math.max(HASHTABLE_THRESHOLD, array.length)];
System.arraycopy(array, 0, this.array, 0, array.length);
this.len = array.length;
}

private int indexOf(Object key){

for(int i = 0; i < len; i += 2)
{
if(equalKey(array[i], key))
return i;
}
return -1;
}

ITransientMap doAssoc(Object key, Object val){

int i = indexOf(key);
if(i >= 0) //already have key,
{
if(array[i + 1] != val) //no change, no op
array[i + 1] = val;
}
else //didn’t have key, grow
{
if(len >= array.length)
return
PersistentHashMap.create(array)
.asTransient()
.assoc(key, val);
array[len++] = key;
array[len++] = val;
}
return this;
}

ITransientMap doWithout(Object key) {

int i = indexOf(key);
if(i >= 0) //have key, will remove
{
8.79. PERSISTENTHASHMAP.JAVA 845

if (len >= 2)
{
array[i] = array[len - 2];
array[i + 1] = array[len - 1];
}
len -= 2;
}
return this;
}

Object doValAt(Object key, Object notFound) {

int i = indexOf(key);
if (i >= 0)
return array[i + 1];
return notFound;
}

int doCount() {
return len / 2;
}

IPersistentMap doPersistent(){
ensureEditable();
owner = null;
Object[] a = new Object[len];
System.arraycopy(array,0,a,0,len);
return new PersistentArrayMap(a);
}

void ensureEditable(){
if(owner == Thread.currentThread())
return;
if(owner != null)
throw new IllegalAccessError(
"Transient used by non-owner thread");
throw new IllegalAccessError(
"Transient used after persistent! call");
}
}
}

———-

8.79 PersistentHashMap.java

— PersistentHashMap.java —
846 CHAPTER 8. JVM/CLOJURE/LANG/

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

/*
A persistent rendition of Phil Bagwell’s Hash Array Mapped Trie

Uses path copying for persistence

HashCollision leaves vs. extended hashing
Node polymorphism vs. conditionals
No sub-tree pools or root-resizing
Any errors are my own
*/

public class PersistentHashMap

extends APersistentMap implements IEditableCollection, IObj {

final int count;

final INode root;
final boolean hasNull;
final Object nullValue;
final IPersistentMap _meta;

final public static PersistentHashMap EMPTY =

new PersistentHashMap(0, null, false, null);
final private static Object NOT_FOUND = new Object();

static public IPersistentMap create(Map other){

ITransientMap ret = EMPTY.asTransient();
for(Object o : other.entrySet())
{
Map.Entry e = (Entry) o;
ret = ret.assoc(e.getKey(), e.getValue());
}
return ret.persistent();
}

/*
* @param init {key1,val1,key2,val2,...}
*/
public static PersistentHashMap create(Object... init){
ITransientMap ret = EMPTY.asTransient();
for(int i = 0; i < init.length; i += 2)
{
ret = ret.assoc(init[i], init[i + 1]);
8.79. PERSISTENTHASHMAP.JAVA 847

}
return (PersistentHashMap) ret.persistent();
}

public static PersistentHashMap createWithCheck(Object... init){

ITransientMap ret = EMPTY.asTransient();
for(int i = 0; i < init.length; i += 2)
{
ret = ret.assoc(init[i], init[i + 1]);
if(ret.count() != i/2 + 1)
throw new IllegalArgumentException(
"Duplicate key: " + init[i]);
}
return (PersistentHashMap) ret.persistent();
}

static public PersistentHashMap create(ISeq items){

ITransientMap ret = EMPTY.asTransient();
for(; items != null; items = items.next().next())
{
if(items.next() == null)
throw new IllegalArgumentException(String.format(
"No value supplied for key: %s", items.first()));
ret = ret.assoc(items.first(), RT.second(items));
}
return (PersistentHashMap) ret.persistent();
}

static public PersistentHashMap createWithCheck(ISeq items){

ITransientMap ret = EMPTY.asTransient();
for(int i=0; items != null; items = items.next().next(), ++i)
{
if(items.next() == null)
throw new IllegalArgumentException(String.format(
"No value supplied for key: %s", items.first()));
ret = ret.assoc(items.first(), RT.second(items));
if(ret.count() != i + 1)
throw new IllegalArgumentException(
"Duplicate key: " + items.first());
}
return (PersistentHashMap) ret.persistent();
}

/*
* @param init {key1,val1,key2,val2,...}
*/
public static PersistentHashMap create(IPersistentMap meta,
Object... init){
return create(init).withMeta(meta);
}
848 CHAPTER 8. JVM/CLOJURE/LANG/

PersistentHashMap(int count,
INode root,
boolean hasNull,
Object nullValue){
this.count = count;
this.root = root;
this.hasNull = hasNull;
this.nullValue = nullValue;
this._meta = null;
}

public PersistentHashMap(IPersistentMap meta,

int count,
INode root,
boolean hasNull,
Object nullValue){
this._meta = meta;
this.count = count;
this.root = root;
this.hasNull = hasNull;
this.nullValue = nullValue;
}

public boolean containsKey(Object key){

if(key == null)
return hasNull;
return (root != null)
? root.find(0, Util.hash(key), key, NOT_FOUND) != NOT_FOUND
: false;
}

public IMapEntry entryAt(Object key){

if(key == null)
return hasNull ? new MapEntry(null, nullValue) : null;
return (root != null) ? root.find(0, Util.hash(key), key) : null;
}

public IPersistentMap assoc(Object key, Object val){

if(key == null) {
if(hasNull && val == nullValue)
return this;
return new PersistentHashMap(meta(),
hasNull ? count : count + 1,
root, true, val);
}
Box addedLeaf = new Box(null);
INode newroot = (root == null ? BitmapIndexedNode.EMPTY : root)
.assoc(0, Util.hash(key), key, val, addedLeaf);
if(newroot == root)
8.79. PERSISTENTHASHMAP.JAVA 849

return this;
return new PersistentHashMap(meta(),
addedLeaf.val == null
? count
: count + 1,
newroot, hasNull, nullValue);
}

public Object valAt(Object key, Object notFound){

if(key == null)
return hasNull ? nullValue : notFound;
return root != null
? root.find(0, Util.hash(key), key, notFound)
: notFound;
}

public Object valAt(Object key){

return valAt(key, null);
}

public IPersistentMap assocEx(Object key, Object val) throws Exception{

if(containsKey(key))
throw new Exception("Key already present");
return assoc(key, val);
}

public IPersistentMap without(Object key){

if(key == null)
return
hasNull
? new PersistentHashMap(meta(), count - 1, root, false, null)
: this;
if(root == null)
return this;
INode newroot = root.without(0, Util.hash(key), key);
if(newroot == root)
return this;
return
new PersistentHashMap(meta(), count - 1, newroot,
hasNull, nullValue);
}

public Iterator iterator(){

return new SeqIterator(seq());
}

public int count(){

return count;
}
850 CHAPTER 8. JVM/CLOJURE/LANG/

public ISeq seq(){

ISeq s = root != null ? root.nodeSeq() : null;
return hasNull ? new Cons(new MapEntry(null, nullValue), s) : s;
}

public IPersistentCollection empty(){

return EMPTY.withMeta(meta());
}

static int mask(int hash, int shift){

//return ((hash << shift) >>> 27);// & 0x01f;
return (hash >>> shift) & 0x01f;
}

public PersistentHashMap withMeta(IPersistentMap meta){

return new PersistentHashMap(meta, count, root, hasNull, nullValue);
}

public TransientHashMap asTransient() {

return new TransientHashMap(this);
}

public IPersistentMap meta(){

return _meta;
}

static final class TransientHashMap extends ATransientMap {

AtomicReference<Thread> edit;
INode root;
int count;
boolean hasNull;
Object nullValue;
final Box leafFlag = new Box(null);

TransientHashMap(PersistentHashMap m) {
this(new AtomicReference<Thread>(Thread.currentThread()),
m.root, m.count, m.hasNull, m.nullValue);
}

TransientHashMap(AtomicReference<Thread> edit, INode root,

int count, boolean hasNull, Object nullValue) {
this.edit = edit;
this.root = root;
this.count = count;
this.hasNull = hasNull;
this.nullValue = nullValue;
}

ITransientMap doAssoc(Object key, Object val) {

8.79. PERSISTENTHASHMAP.JAVA 851

if (key == null) {
if (this.nullValue != val)
this.nullValue = val;
if (!hasNull) {
this.count++;
this.hasNull = true;
}
return this;
}
// Box leafFlag = new Box(null);
leafFlag.val = null;
INode n = (root == null ? BitmapIndexedNode.EMPTY : root)
.assoc(edit, 0, Util.hash(key), key, val, leafFlag);
if (n != this.root)
this.root = n;
if(leafFlag.val != null) this.count++;
return this;
}

ITransientMap doWithout(Object key) {

if (key == null) {
if (!hasNull) return this;
hasNull = false;
nullValue = null;
this.count--;
return this;
}
if (root == null) return this;
// Box leafFlag = new Box(null);
leafFlag.val = null;
INode n = root.without(edit, 0, Util.hash(key), key, leafFlag);
if (n != root)
this.root = n;
if(leafFlag.val != null) this.count--;
return this;
}

IPersistentMap doPersistent() {
edit.set(null);
return new PersistentHashMap(count, root, hasNull, nullValue);
}

Object doValAt(Object key, Object notFound) {

if (key == null)
if (hasNull)
return nullValue;
else
return notFound;
if (root == null)
return null;
852 CHAPTER 8. JVM/CLOJURE/LANG/

return root.find(0, Util.hash(key), key, notFound);

}

int doCount() {
return count;
}

void ensureEditable(){
Thread owner = edit.get();
if(owner == Thread.currentThread())
return;
if(owner != null)
throw new IllegalAccessError(
"Transient used by non-owner thread");
throw new IllegalAccessError(
"Transient used after persistent! call");
}
}

static interface INode extends Serializable {

INode assoc(int shift, int hash, Object key,
Object val, Box addedLeaf);

INode without(int shift, int hash, Object key);

IMapEntry find(int shift, int hash, Object key);

Object find(int shift, int hash, Object key, Object notFound);

ISeq nodeSeq();

INode assoc(AtomicReference<Thread> edit, int shift, int hash,

Object key, Object val, Box addedLeaf);

INode without(AtomicReference<Thread> edit, int shift, int hash,

Object key, Box removedLeaf);
}

final static class ArrayNode implements INode{

int count;
final INode[] array;
final AtomicReference<Thread> edit;

ArrayNode(AtomicReference<Thread> edit, int count, INode[] array){

this.array = array;
this.edit = edit;
this.count = count;
}

public INode assoc(int shift, int hash, Object key,

8.79. PERSISTENTHASHMAP.JAVA 853

Object val, Box addedLeaf){

int idx = mask(hash, shift);
INode node = array[idx];
if(node == null)
return
new ArrayNode(null, count + 1,
cloneAndSet(array,
idx,
BitmapIndexedNode.EMPTY
.assoc(shift + 5,
hash,
key,
val,
addedLeaf)));
INode n = node.assoc(shift + 5, hash, key, val, addedLeaf);
if(n == node)
return this;
return new ArrayNode(null, count, cloneAndSet(array, idx, n));
}

public INode without(int shift, int hash, Object key){

int idx = mask(hash, shift);
INode node = array[idx];
if(node == null)
return this;
INode n = node.without(shift + 5, hash, key);
if(n == node)
return this;
if (n == null) {
if (count <= 8) // shrink
return pack(null, idx);
return
new ArrayNode(null, count - 1,
cloneAndSet(array, idx, n));
} else
return
new ArrayNode(null, count,
cloneAndSet(array, idx, n));
}

public IMapEntry find(int shift, int hash, Object key){

int idx = mask(hash, shift);
INode node = array[idx];
if(node == null)
return null;
return node.find(shift + 5, hash, key);
}

public Object find(int shift, int hash, Object key,

Object notFound){
854 CHAPTER 8. JVM/CLOJURE/LANG/

int idx = mask(hash, shift);

INode node = array[idx];
if(node == null)
return notFound;
return node.find(shift + 5, hash, key, notFound);
}

public ISeq nodeSeq(){

return Seq.create(array);
}

private ArrayNode ensureEditable(AtomicReference<Thread> edit){

if(this.edit == edit)
return this;
return new ArrayNode(edit, count, this.array.clone());
}

private ArrayNode editAndSet(AtomicReference<Thread> edit,

int i, INode n){
ArrayNode editable = ensureEditable(edit);
editable.array[i] = n;
return editable;
}

private INode pack(AtomicReference<Thread> edit, int idx) {

Object[] newArray = new Object[2*(count - 1)];
int j = 1;
int bitmap = 0;
for(int i = 0; i < idx; i++)
if (array[i] != null) {
newArray[j] = array[i];
bitmap |= 1 << i;
j += 2;
}
for(int i = idx + 1; i < array.length; i++)
if (array[i] != null) {
newArray[j] = array[i];
bitmap |= 1 << i;
j += 2;
}
return new BitmapIndexedNode(edit, bitmap, newArray);
}

public INode assoc(AtomicReference<Thread> edit, int shift,

int hash, Object key, Object val,
Box addedLeaf){
int idx = mask(hash, shift);
INode node = array[idx];
if(node == null) {
8.79. PERSISTENTHASHMAP.JAVA 855

ArrayNode editable =
editAndSet(edit, idx,
BitmapIndexedNode.EMPTY
.assoc(edit,
shift + 5,
hash,
key,
val,
addedLeaf));
editable.count++;
return editable;
}
INode n = node.assoc(edit, shift + 5, hash, key, val, addedLeaf);
if(n == node)
return this;
return editAndSet(edit, idx, n);
}

public INode without(AtomicReference<Thread> edit,

int shift,
int hash,
Object key,
Box removedLeaf){
int idx = mask(hash, shift);
INode node = array[idx];
if(node == null)
return this;
INode n = node.without(edit, shift + 5, hash, key, removedLeaf);
if(n == node)
return this;
if(n == null) {
if (count <= 8) // shrink
return pack(edit, idx);
ArrayNode editable = editAndSet(edit, idx, n);
editable.count--;
return editable;
}
return editAndSet(edit, idx, n);
}

static class Seq extends ASeq {

final INode[] nodes;
final int i;
final ISeq s;

static ISeq create(INode[] nodes) {

return create(null, nodes, 0, null);
}

private static ISeq create(IPersistentMap meta,

856 CHAPTER 8. JVM/CLOJURE/LANG/

INode[] nodes, int i, ISeq s) {

if (s != null)
return new Seq(meta, nodes, i, s);
for(int j = i; j < nodes.length; j++)
if (nodes[j] != null) {
ISeq ns = nodes[j].nodeSeq();
if (ns != null)
return new Seq(meta, nodes, j + 1, ns);
}
return null;
}

private Seq(IPersistentMap meta, INode[] nodes, int i, ISeq s) {

super(meta);
this.nodes = nodes;
this.i = i;
this.s = s;
}

public Obj withMeta(IPersistentMap meta) {

return new Seq(meta, nodes, i, s);
}

public Object first() {

return s.first();
}

public ISeq next() {

return create(null, nodes, i, s.next());
}

}
}

final static class BitmapIndexedNode implements INode{

static final BitmapIndexedNode EMPTY =
new BitmapIndexedNode(null, 0, new Object[0]);

int bitmap;
Object[] array;
final AtomicReference<Thread> edit;

final int index(int bit){

return Integer.bitCount(bitmap & (bit - 1));
}

BitmapIndexedNode(AtomicReference<Thread> edit,
int bitmap, Object[] array){
this.bitmap = bitmap;
this.array = array;
8.79. PERSISTENTHASHMAP.JAVA 857

this.edit = edit;
}

public INode assoc(int shift, int hash, Object key,

Object val, Box addedLeaf){
int bit = bitpos(hash, shift);
int idx = index(bit);
if((bitmap & bit) != 0) {
Object keyOrNull = array[2*idx];
Object valOrNode = array[2*idx+1];
if(keyOrNull == null) {
INode n = ((INode) valOrNode).assoc(shift + 5,
hash,
key,
val,
addedLeaf);
if(n == valOrNode)
return this;
return
new BitmapIndexedNode(null, bitmap,
cloneAndSet(array, 2*idx+1, n));
}
if(Util.equiv(key, keyOrNull)) {
if(val == valOrNode)
return this;
return
new BitmapIndexedNode(null, bitmap,
cloneAndSet(array,
2*idx+1,
val));
}
addedLeaf.val = addedLeaf;
return new BitmapIndexedNode(null, bitmap,
cloneAndSet(array,
2*idx, null,
2*idx+1, createNode(shift + 5,
keyOrNull,
valOrNode,
hash,
key,
val)));
} else {
int n = Integer.bitCount(bitmap);
if(n >= 16) {
INode[] nodes = new INode[32];
int jdx = mask(hash, shift);
nodes[jdx] = EMPTY.assoc(shift + 5,
hash,
key,
val,
858 CHAPTER 8. JVM/CLOJURE/LANG/

addedLeaf);
int j = 0;
for(int i = 0; i < 32; i++)
if(((bitmap >>> i) & 1) != 0) {
if (array[j] == null)
nodes[i] = (INode) array[j+1];
else
nodes[i] =
EMPTY.assoc(shift + 5,
Util.hash(array[j]),
array[j],
array[j+1],
addedLeaf);
j += 2;
}
return new ArrayNode(null, n + 1, nodes);
} else {
Object[] newArray = new Object[2*(n+1)];
System.arraycopy(array, 0, newArray, 0, 2*idx);
newArray[2*idx] = key;
addedLeaf.val = addedLeaf;
newArray[2*idx+1] = val;
System.arraycopy(array, 2*idx, newArray,
2*(idx+1), 2*(n-idx));
return
new BitmapIndexedNode(null, bitmap | bit, newArray);
}
}
}

public INode without(int shift, int hash, Object key){

int bit = bitpos(hash, shift);
if((bitmap & bit) == 0)
return this;
int idx = index(bit);
Object keyOrNull = array[2*idx];
Object valOrNode = array[2*idx+1];
if(keyOrNull == null) {
INode n =
((INode) valOrNode).without(shift + 5, hash, key);
if (n == valOrNode)
return this;
if (n != null)
return
new BitmapIndexedNode(null, bitmap,
cloneAndSet(array, 2*idx+1, n));
if (bitmap == bit)
return null;
return
new BitmapIndexedNode(null, bitmap ^ bit,
8.79. PERSISTENTHASHMAP.JAVA 859

removePair(array, idx));
}
if(Util.equiv(key, keyOrNull))
// TODO: collapse
return new BitmapIndexedNode(null,
bitmap ^ bit,
removePair(array, idx));
return this;
}

public IMapEntry find(int shift, int hash, Object key){

int bit = bitpos(hash, shift);
if((bitmap & bit) == 0)
return null;
int idx = index(bit);
Object keyOrNull = array[2*idx];
Object valOrNode = array[2*idx+1];
if(keyOrNull == null)
return ((INode) valOrNode).find(shift + 5, hash, key);
if(Util.equiv(key, keyOrNull))
return new MapEntry(keyOrNull, valOrNode);
return null;
}

public Object find(int shift, int hash,

Object key, Object notFound){
int bit = bitpos(hash, shift);
if((bitmap & bit) == 0)
return notFound;
int idx = index(bit);
Object keyOrNull = array[2*idx];
Object valOrNode = array[2*idx+1];
if(keyOrNull == null)
return
((INode) valOrNode).find(shift + 5, hash, key, notFound);
if(Util.equiv(key, keyOrNull))
return valOrNode;
return notFound;
}

public ISeq nodeSeq(){

return NodeSeq.create(array);
}

private BitmapIndexedNode
ensureEditable(AtomicReference<Thread> edit){
if(this.edit == edit)
return this;
int n = Integer.bitCount(bitmap);
Object[] newArray =
860 CHAPTER 8. JVM/CLOJURE/LANG/

new Object[n >= 0 ? 2*(n+1) : 4]; // make room for next assoc
System.arraycopy(array, 0, newArray, 0, 2*n);
return new BitmapIndexedNode(edit, bitmap, newArray);
}

private BitmapIndexedNode
editAndSet(AtomicReference<Thread> edit, int i, Object a) {
BitmapIndexedNode editable = ensureEditable(edit);
editable.array[i] = a;
return editable;
}

private BitmapIndexedNode
editAndSet(AtomicReference<Thread> edit, int i,
Object a, int j, Object b) {
BitmapIndexedNode editable = ensureEditable(edit);
editable.array[i] = a;
editable.array[j] = b;
return editable;
}

private BitmapIndexedNode
editAndRemovePair(AtomicReference<Thread> edit,
int bit, int i) {
if (bitmap == bit)
return null;
BitmapIndexedNode editable = ensureEditable(edit);
editable.bitmap ^= bit;
System.arraycopy(editable.array, 2*(i+1), editable.array,
2*i, editable.array.length - 2*(i+1));
editable.array[editable.array.length - 2] = null;
editable.array[editable.array.length - 1] = null;
return editable;
}

public INode assoc(AtomicReference<Thread> edit, int shift,

int hash, Object key, Object val,
Box addedLeaf){
int bit = bitpos(hash, shift);
int idx = index(bit);
if((bitmap & bit) != 0) {
Object keyOrNull = array[2*idx];
Object valOrNode = array[2*idx+1];
if(keyOrNull == null) {
INode n =
((INode) valOrNode).assoc(edit,
shift + 5,
hash,
key,
val,
8.79. PERSISTENTHASHMAP.JAVA 861

addedLeaf);
if(n == valOrNode)
return this;
return editAndSet(edit, 2*idx+1, n);
}
if(Util.equiv(key, keyOrNull)) {
if(val == valOrNode)
return this;
return editAndSet(edit, 2*idx+1, val);
}
addedLeaf.val = addedLeaf;
return editAndSet(edit, 2*idx, null, 2*idx+1,
createNode(edit, shift + 5, keyOrNull,
valOrNode, hash, key, val));
} else {
int n = Integer.bitCount(bitmap);
if(n*2 < array.length) {
addedLeaf.val = addedLeaf;
BitmapIndexedNode editable = ensureEditable(edit);
System.arraycopy(editable.array, 2*idx,
editable.array, 2*(idx+1),
2*(n-idx));
editable.array[2*idx] = key;
editable.array[2*idx+1] = val;
editable.bitmap |= bit;
return editable;
}
if(n >= 16) {
INode[] nodes = new INode[32];
int jdx = mask(hash, shift);
nodes[jdx] = EMPTY.assoc(edit, shift + 5, hash, key,
val, addedLeaf);
int j = 0;
for(int i = 0; i < 32; i++)
if(((bitmap >>> i) & 1) != 0) {
if (array[j] == null)
nodes[i] = (INode) array[j+1];
else
nodes[i] =
EMPTY.assoc(edit,
shift + 5,
Util.hash(array[j]),
array[j],
array[j+1],
addedLeaf);
j += 2;
}
return new ArrayNode(edit, n + 1, nodes);
} else {
Object[] newArray = new Object[2*(n+4)];
862 CHAPTER 8. JVM/CLOJURE/LANG/

System.arraycopy(array, 0, newArray, 0, 2*idx);

newArray[2*idx] = key;
addedLeaf.val = addedLeaf;
newArray[2*idx+1] = val;
System.arraycopy(array, 2*idx, newArray,
2*(idx+1), 2*(n-idx));
BitmapIndexedNode editable = ensureEditable(edit);
editable.array = newArray;
editable.bitmap |= bit;
return editable;
}
}
}

public INode without(AtomicReference<Thread> edit, int shift,

int hash, Object key, Box removedLeaf){
int bit = bitpos(hash, shift);
if((bitmap & bit) == 0)
return this;
int idx = index(bit);
Object keyOrNull = array[2*idx];
Object valOrNode = array[2*idx+1];
if(keyOrNull == null) {
INode n =
((INode) valOrNode).without(edit,
shift + 5,
hash,
key,
removedLeaf);
if (n == valOrNode)
return this;
if (n != null)
return editAndSet(edit, 2*idx+1, n);
if (bitmap == bit)
return null;
removedLeaf.val = removedLeaf;
return editAndRemovePair(edit, bit, idx);
}
if(Util.equiv(key, keyOrNull)) {
removedLeaf.val = removedLeaf;
// TODO: collapse
return editAndRemovePair(edit, bit, idx);
}
return this;
}
}

final static class HashCollisionNode implements INode{

final int hash;

8.79. PERSISTENTHASHMAP.JAVA 863

int count;
Object[] array;
final AtomicReference<Thread> edit;

HashCollisionNode(AtomicReference<Thread> edit, int hash,

int count, Object... array){
this.edit = edit;
this.hash = hash;
this.count = count;
this.array = array;
}

public INode assoc(int shift, int hash, Object key,

Object val, Box addedLeaf){
if(hash == this.hash) {
int idx = findIndex(key);
if(idx != -1) {
if(array[idx + 1] == val)
return this;
return
new HashCollisionNode(null, hash, count,
cloneAndSet(array,
idx + 1,
val));
}
Object[] newArray = new Object[array.length + 2];
System.arraycopy(array, 0, newArray, 0, array.length);
newArray[array.length] = key;
newArray[array.length + 1] = val;
addedLeaf.val = addedLeaf;
return
new HashCollisionNode(edit, hash, count + 1, newArray);
}
// nest it in a bitmap node
return
new BitmapIndexedNode(null, bitpos(this.hash, shift),
new Object[] {null, this})
.assoc(shift, hash, key, val, addedLeaf);
}

public INode without(int shift, int hash, Object key){

int idx = findIndex(key);
if(idx == -1)
return this;
if(count == 1)
return null;
return
new HashCollisionNode(null, hash, count - 1,
removePair(array, idx/2));
}
864 CHAPTER 8. JVM/CLOJURE/LANG/

public IMapEntry find(int shift, int hash, Object key){

int idx = findIndex(key);
if(idx < 0)
return null;
if(Util.equiv(key, array[idx]))
return new MapEntry(array[idx], array[idx+1]);
return null;
}

public Object find(int shift, int hash, Object key, Object notFound){
int idx = findIndex(key);
if(idx < 0)
return notFound;
if(Util.equiv(key, array[idx]))
return array[idx+1];
return notFound;
}

public ISeq nodeSeq(){

return NodeSeq.create(array);
}

public int findIndex(Object key){

for(int i = 0; i < 2*count; i+=2)
{
if(Util.equiv(key, array[i]))
return i;
}
return -1;
}

private HashCollisionNode
ensureEditable(AtomicReference<Thread> edit){
if(this.edit == edit)
return this;
return new HashCollisionNode(edit, hash, count, array);
}

private HashCollisionNode
ensureEditable(AtomicReference<Thread> edit, int count,
Object[] array){
if(this.edit == edit) {
this.array = array;
this.count = count;
return this;
}
return new HashCollisionNode(edit, hash, count, array);
}
8.79. PERSISTENTHASHMAP.JAVA 865

private HashCollisionNode
editAndSet(AtomicReference<Thread> edit, int i, Object a) {
HashCollisionNode editable = ensureEditable(edit);
editable.array[i] = a;
return editable;
}

private HashCollisionNode
editAndSet(AtomicReference<Thread> edit, int i, Object a,
int j, Object b) {
HashCollisionNode editable = ensureEditable(edit);
editable.array[i] = a;
editable.array[j] = b;
return editable;
}

public INode assoc(AtomicReference<Thread> edit, int shift,

int hash, Object key, Object val,
Box addedLeaf){
if(hash == this.hash) {
int idx = findIndex(key);
if(idx != -1) {
if(array[idx + 1] == val)
return this;
return editAndSet(edit, idx+1, val);
}
if (array.length > 2*count) {
addedLeaf.val = addedLeaf;
HashCollisionNode editable =
editAndSet(edit, 2*count, key, 2*count+1, val);
editable.count++;
return editable;
}
Object[] newArray = new Object[array.length + 2];
System.arraycopy(array, 0, newArray, 0, array.length);
newArray[array.length] = key;
newArray[array.length + 1] = val;
addedLeaf.val = addedLeaf;
return ensureEditable(edit, count + 1, newArray);
}
// nest it in a bitmap node
return
new BitmapIndexedNode(edit,
bitpos(this.hash, shift),
new Object[] {null, this, null, null})
.assoc(edit, shift, hash, key, val, addedLeaf);
}

public INode without(AtomicReference<Thread> edit, int shift,

866 CHAPTER 8. JVM/CLOJURE/LANG/

int hash, Object key, Box removedLeaf){

int idx = findIndex(key);
if(idx == -1)
return this;
if(count == 1)
return null;
HashCollisionNode editable = ensureEditable(edit);
editable.array[idx] = editable.array[2*count-2];
editable.array[idx+1] = editable.array[2*count-1];
editable.array[2*count-2] = editable.array[2*count-1] = null;
editable.count--;
return editable;
}
}

/*
public static void main(String[] args){
try
{
ArrayList words = new ArrayList();
Scanner s = new Scanner(new File(args[0]));
s.useDelimiter(Pattern.compile("\\W"));
while(s.hasNext())
{
String word = s.next();
words.add(word);
}
System.out.println("words: " + words.size());
IPersistentMap map = PersistentHashMap.EMPTY;
//IPersistentMap map = new PersistentTreeMap();
//Map ht = new Hashtable();
Map ht = new HashMap();
Random rand;

System.out.println("Building map");
long startTime = System.nanoTime();
for(Object word5 : words)
{
map = map.assoc(word5, word5);
}
rand = new Random(42);
IPersistentMap snapshotMap = map;
for(int i = 0; i < words.size() / 200; i++)
{
map = map.without(words.get(rand.nextInt(words.size() / 2)));
}
long estimatedTime = System.nanoTime() - startTime;
System.out.println("count = " + map.count() +
", time: " + estimatedTime / 1000000);
8.79. PERSISTENTHASHMAP.JAVA 867

System.out.println("Building ht");
startTime = System.nanoTime();
for(Object word1 : words)
{
ht.put(word1, word1);
}
rand = new Random(42);
for(int i = 0; i < words.size() / 200; i++)
{
ht.remove(words.get(rand.nextInt(words.size() / 2)));
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("count = " + ht.size() +
", time: " + estimatedTime / 1000000);

System.out.println("map lookup");
startTime = System.nanoTime();
int c = 0;
for(Object word2 : words)
{
if(!map.contains(word2))
++c;
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("notfound = " + c +
", time: " + estimatedTime / 1000000);
System.out.println("ht lookup");
startTime = System.nanoTime();
c = 0;
for(Object word3 : words)
{
if(!ht.containsKey(word3))
++c;
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("notfound = " + c +
", time: " + estimatedTime / 1000000);
System.out.println("snapshotMap lookup");
startTime = System.nanoTime();
c = 0;
for(Object word4 : words)
{
if(!snapshotMap.contains(word4))
++c;
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("notfound = " + c +
", time: " + estimatedTime / 1000000);
}
catch(FileNotFoundException e)
868 CHAPTER 8. JVM/CLOJURE/LANG/

{
e.printStackTrace();
}

}
*/

private static INode[] cloneAndSet(INode[] array, int i, INode a) {

INode[] clone = array.clone();
clone[i] = a;
return clone;
}

private static Object[] cloneAndSet(Object[] array, int i, Object a) {

Object[] clone = array.clone();
clone[i] = a;
return clone;
}

private static Object[] cloneAndSet(Object[] array, int i,

Object a, int j, Object b) {
Object[] clone = array.clone();
clone[i] = a;
clone[j] = b;
return clone;
}

private static Object[] removePair(Object[] array, int i) {

Object[] newArray = new Object[array.length - 2];
System.arraycopy(array, 0, newArray, 0, 2*i);
System.arraycopy(array, 2*(i+1), newArray,
2*i, newArray.length - 2*i);
return newArray;
}

private static INode createNode(int shift, Object key1, Object val1,

int key2hash, Object key2,
Object val2) {
int key1hash = Util.hash(key1);
if(key1hash == key2hash)
return
new HashCollisionNode(null, key1hash, 2,
new Object[] {key1, val1, key2, val2});
Box _ = new Box(null);
AtomicReference<Thread> edit = new AtomicReference<Thread>();
return BitmapIndexedNode.EMPTY
.assoc(edit, shift, key1hash, key1, val1, _)
.assoc(edit, shift, key2hash, key2, val2, _);
}
8.79. PERSISTENTHASHMAP.JAVA 869

private static INode createNode(AtomicReference<Thread> edit,

int shift, Object key1, Object val1,
int key2hash, Object key2,
Object val2) {
int key1hash = Util.hash(key1);
if(key1hash == key2hash)
return
new HashCollisionNode(null, key1hash, 2,
new Object[] {key1, val1, key2, val2});
Box _ = new Box(null);
return BitmapIndexedNode.EMPTY
.assoc(edit, shift, key1hash, key1, val1, _)
.assoc(edit, shift, key2hash, key2, val2, _);
}

private static int bitpos(int hash, int shift){

return 1 << mask(hash, shift);
}

static final class NodeSeq extends ASeq {

final Object[] array;
final int i;
final ISeq s;

NodeSeq(Object[] array, int i) {

this(null, array, i, null);
}

static ISeq create(Object[] array) {

return create(array, 0, null);
}

private static ISeq create(Object[] array, int i, ISeq s) {

if(s != null)
return new NodeSeq(null, array, i, s);
for(int j = i; j < array.length; j+=2) {
if(array[j] != null)
return new NodeSeq(null, array, j, null);
INode node = (INode) array[j+1];
if (node != null) {
ISeq nodeSeq = node.nodeSeq();
if(nodeSeq != null)
return new NodeSeq(null, array, j + 2, nodeSeq);
}
}
return null;
}

NodeSeq(IPersistentMap meta, Object[] array, int i, ISeq s) {

super(meta);
870 CHAPTER 8. JVM/CLOJURE/LANG/

this.array = array;
this.i = i;
this.s = s;
}

public Obj withMeta(IPersistentMap meta) {

return new NodeSeq(meta, array, i, s);
}

public Object first() {

if(s != null)
return s.first();
return new MapEntry(array[i], array[i+1]);
}

public ISeq next() {

if(s != null)
return create(array, i, s.next());
return create(array, i + 2, null);
}
}

———-

8.80 PersistentHashSet.java

— PersistentHashSet.java —

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

import java.util.List;

public class PersistentHashSet

extends APersistentSet implements IObj, IEditableCollection {

static public final PersistentHashSet EMPTY =

new PersistentHashSet(null, PersistentHashMap.EMPTY);

final IPersistentMap _meta;

public static PersistentHashSet create(Object... init){

PersistentHashSet ret = EMPTY;
8.80. PERSISTENTHASHSET.JAVA 871

for(int i = 0; i < init.length; i++)

{
ret = (PersistentHashSet) ret.cons(init[i]);
}
return ret;
}

public static PersistentHashSet create(List init){

PersistentHashSet ret = EMPTY;
for(Object key : init)
{
ret = (PersistentHashSet) ret.cons(key);
}
return ret;
}

static public PersistentHashSet create(ISeq items){

PersistentHashSet ret = EMPTY;
for(; items != null; items = items.next())
{
ret = (PersistentHashSet) ret.cons(items.first());
}
return ret;
}

public static PersistentHashSet createWithCheck(Object... init){

PersistentHashSet ret = EMPTY;
for(int i = 0; i < init.length; i++)
{
ret = (PersistentHashSet) ret.cons(init[i]);
if(ret.count() != i + 1)
throw new IllegalArgumentException(
"Duplicate key: " + init[i]);
}
return ret;
}

public static PersistentHashSet createWithCheck(List init){

PersistentHashSet ret = EMPTY;
int i=0;
for(Object key : init)
{
ret = (PersistentHashSet) ret.cons(key);
if(ret.count() != i + 1)
throw new IllegalArgumentException("Duplicate key: " + key);
++i;
}
return ret;
}
872 CHAPTER 8. JVM/CLOJURE/LANG/

static public PersistentHashSet createWithCheck(ISeq items){

PersistentHashSet ret = EMPTY;
for(int i=0; items != null; items = items.next(), ++i)
{
ret = (PersistentHashSet) ret.cons(items.first());
if(ret.count() != i + 1)
throw new IllegalArgumentException(
"Duplicate key: " + items.first());
}
return ret;
}

PersistentHashSet(IPersistentMap meta, IPersistentMap impl){

super(impl);
this._meta = meta;
}

public IPersistentSet disjoin(Object key) throws Exception{

if(contains(key))
return new PersistentHashSet(meta(),impl.without(key));
return this;
}

public IPersistentSet cons(Object o){

if(contains(o))
return this;
return new PersistentHashSet(meta(),impl.assoc(o,o));
}

public IPersistentCollection empty(){

return EMPTY.withMeta(meta());
}

public PersistentHashSet withMeta(IPersistentMap meta){

return new PersistentHashSet(meta, impl);
}

public ITransientCollection asTransient() {

return
new TransientHashSet(((PersistentHashMap) impl).asTransient());
}

public IPersistentMap meta(){

return _meta;
}

static final class TransientHashSet extends ATransientSet {

TransientHashSet(ITransientMap impl) {
super(impl);
}
8.81. PERSISTENTLIST.JAVA 873

public IPersistentCollection persistent() {

return new PersistentHashSet(null, impl.persistent());
}
}

———-

8.81 PersistentList.java

— PersistentList.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.io.Serializable;
import java.util.*;

public class PersistentList

extends ASeq implements IPersistentList, IReduce, List, Counted {

private final Object _first;

private final IPersistentList _rest;
private final int _count;

public static IFn creator = new RestFn(){

final public int getRequiredArity(){
return 0;
}

final protected Object doInvoke(Object args) throws Exception{

if(args instanceof ArraySeq)
{
Object[] argsarray = (Object[]) ((ArraySeq) args).array;
IPersistentList ret = EMPTY;
for(int i = argsarray.length - 1; i >= 0; --i)
ret = (IPersistentList) ret.cons(argsarray[i]);
return ret;
}
LinkedList list = new LinkedList();
for(ISeq s = RT.seq(args); s != null; s = s.next())
list.add(s.first());
return create(list);
}
874 CHAPTER 8. JVM/CLOJURE/LANG/

public IObj withMeta(IPersistentMap meta){

throw new UnsupportedOperationException();
}

public IPersistentMap meta(){

return null;
}
};

final public static EmptyList EMPTY = new EmptyList(null);

public PersistentList(Object first){

this._first = first;
this._rest = null;

this._count = 1;
}

PersistentList(IPersistentMap meta,
Object _first,
IPersistentList _rest,
int _count){
super(meta);
this._first = _first;
this._rest = _rest;
this._count = _count;
}

public static IPersistentList create(List init){

IPersistentList ret = EMPTY;
for(ListIterator i = init.listIterator(init.size())
; i.hasPrevious();)
{
ret = (IPersistentList) ret.cons(i.previous());
}
return ret;
}

public Object first(){

return _first;
}

public ISeq next(){

if(_count == 1)
return null;
return (ISeq) _rest;
}

public Object peek(){

return first();
8.81. PERSISTENTLIST.JAVA 875

public IPersistentList pop(){

if(_rest == null)
return EMPTY.withMeta(_meta);
return _rest;
}

public int count(){

return _count;
}

public PersistentList cons(Object o){

return new PersistentList(meta(), o, this, _count + 1);
}

public IPersistentCollection empty(){

return EMPTY.withMeta(meta());
}

public PersistentList withMeta(IPersistentMap meta){

if(meta != _meta)
return new PersistentList(meta, _first, _rest, _count);
return this;
}

public Object reduce(IFn f) throws Exception{

Object ret = first();
for(ISeq s = next(); s != null; s = s.next())
ret = f.invoke(ret, s.first());
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start, first());
for(ISeq s = next(); s != null; s = s.next())
ret = f.invoke(ret, s.first());
return ret;
}

static class EmptyList

extends Obj implements IPersistentList, List, ISeq, Counted{

public int hashCode(){

return 1;
}

public boolean equals(Object o) {

return (o instanceof Sequential ||
876 CHAPTER 8. JVM/CLOJURE/LANG/

o instanceof List) &&

RT.seq(o) == null;
}

public boolean equiv(Object o){

public List subList(int fromIndex, int toIndex){

return reify().subList(fromIndex, toIndex);
}

public Object set(int index, Object element){

throw new UnsupportedOperationException();
}

public Object remove(int index){

throw new UnsupportedOperationException();
}

public int indexOf(Object o){

ISeq s = seq();
for(int i = 0; s != null; s = s.next(), i++)
{
if(Util.equiv(s.first(), o))
return i;
}
return -1;
}

public int lastIndexOf(Object o){

8.82. PERSISTENTQUEUE.JAVA 879

return reify().lastIndexOf(o);
}

public ListIterator listIterator(){

return reify().listIterator();
}

public ListIterator listIterator(int index){

return reify().listIterator(index);
}

public Object get(int index){

return RT.nth(this, index);
}

public void add(int index, Object element){

throw new UnsupportedOperationException();
}

public boolean addAll(int index, Collection c){

throw new UnsupportedOperationException();
}

———-

8.82 PersistentQueue.java

— PersistentQueue.java —

\getchunk{Clojure Copyright}
package clojure.lang;

import java.util.Collection;
import java.util.Iterator;
//import java.util.concurrent.ConcurrentLinkedQueue;

/**
* conses onto rear, peeks/pops from front
* See Okasaki’s Batched Queues
* This differs in that it uses a PersistentVector as the rear,
* which is in-order,
* so no reversing or suspensions required for persistent use
880 CHAPTER 8. JVM/CLOJURE/LANG/

public class PersistentQueue

extends Obj implements IPersistentList, Collection, Counted{

final public static PersistentQueue EMPTY =

new PersistentQueue(null, 0, null, null);

//*
final int cnt;
final ISeq f;
final PersistentVector r;
//static final int INITIAL_REAR_SIZE = 4;
int _hash = -1;

PersistentQueue(IPersistentMap meta,
int cnt,
ISeq f,
PersistentVector r){
super(meta);
this.cnt = cnt;
this.f = f;
this.r = r;
}

public boolean equiv(Object obj){

if(!(obj instanceof Sequential))

return false;
ISeq ms = RT.seq(obj);
for(ISeq s = seq(); s != null; s = s.next(), ms = ms.next())
{
if(ms == null || !Util.equiv(s.first(), ms.first()))
return false;
}
return ms == null;

public boolean equals(Object obj){

if(!(obj instanceof Sequential))

return false;
ISeq ms = RT.seq(obj);
for(ISeq s = seq(); s != null; s = s.next(), ms = ms.next())
{
if(ms == null || !Util.equals(s.first(), ms.first()))
return false;
}
return ms == null;
8.82. PERSISTENTQUEUE.JAVA 881

public int hashCode(){

if(_hash == -1)
{
int hash = 0;
for(ISeq s = seq(); s != null; s = s.next())
{
hash = Util.hashCombine(hash, Util.hash(s.first()));
}
this._hash = hash;
}
return _hash;
}

public Object peek(){

return RT.first(f);
}

public PersistentQueue pop(){

if(f == null) //hmmm... pop of empty queue -> empty queue?
return this;
//throw new IllegalStateException("popping empty queue");
ISeq f1 = f.next();
PersistentVector r1 = r;
if(f1 == null)
{
f1 = RT.seq(r);
r1 = null;
}
return new PersistentQueue(meta(), cnt - 1, f1, r1);
}

public int count(){

return cnt;
}

public ISeq seq(){

if(f == null)
return null;
return new Seq(f, RT.seq(r));
}

public PersistentQueue cons(Object o){

if(f == null) //empty
return new PersistentQueue(meta(), cnt + 1, RT.list(o), null);
else
return new PersistentQueue(meta(), cnt + 1, f,
(r != null
882 CHAPTER 8. JVM/CLOJURE/LANG/

? r
: PersistentVector.EMPTY).cons(o));
}

public IPersistentCollection empty(){

return EMPTY.withMeta(meta());
}

public PersistentQueue withMeta(IPersistentMap meta){

return new PersistentQueue(meta, cnt, f, r);
}

static class Seq extends ASeq{

final ISeq f;
final ISeq rseq;

Seq(ISeq f, ISeq rseq){

this.f = f;
this.rseq = rseq;
}

Seq(IPersistentMap meta, ISeq f, ISeq rseq){

super(meta);
this.f = f;
this.rseq = rseq;
}

public Object first(){

return f.first();
}

public ISeq next(){

ISeq f1 = f.next();
ISeq r1 = rseq;
if(f1 == null)
{
if(rseq == null)
return null;
f1 = rseq;
r1 = null;
}
return new Seq(f1, r1);
}

public int count(){

return RT.count(f) + RT.count(rseq);
}

public Seq withMeta(IPersistentMap meta){

return new Seq(meta, f, rseq);
8.82. PERSISTENTQUEUE.JAVA 883

}
}

// java.util.Collection implementation

public Object[] toArray(){

return RT.seqToArray(seq());
}

public boolean add(Object o){

throw new UnsupportedOperationException();
}

public boolean remove(Object o){

throw new UnsupportedOperationException();
}

public boolean addAll(Collection c){

throw new UnsupportedOperationException();
}

public void clear(){

throw new UnsupportedOperationException();
}

public boolean retainAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean removeAll(Collection c){

throw new UnsupportedOperationException();
}

public boolean containsAll(Collection c){

for(Object o : c)
{
if(contains(o))
return true;
}
return false;
}

public Object[] toArray(Object[] a){

if(a.length >= count())
{
ISeq s = seq();
for(int i = 0; s != null; ++i, s = s.next())
{
a[i] = s.first();
}
884 CHAPTER 8. JVM/CLOJURE/LANG/

if(a.length >= count())

a[count()] = null;
return a;
}
else
return toArray();
}

public int size(){

return count();
}

public boolean isEmpty(){

return count() == 0;
}

public boolean contains(Object o){

for(ISeq s = seq(); s != null; s = s.next())
{
if(Util.equiv(s.first(), o))
return true;
}
return false;
}

public Iterator iterator(){

return new SeqIterator(seq());
}

/*
public static void main(String[] args){
if(args.length != 1)
{
System.err.println("Usage: PersistentQueue n");
return;
}
int n = Integer.parseInt(args[0]);

long startTime, estimatedTime;

Queue list = new LinkedList();

//Queue list = new ConcurrentLinkedQueue();
System.out.println("Queue");
startTime = System.nanoTime();
for(int i = 0; i < n; i++)
{
list.add(i);
list.add(i);
list.remove();
8.82. PERSISTENTQUEUE.JAVA 885

}
for(int i = 0; i < n - 10; i++)
{
list.remove();
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("time: " + estimatedTime / 1000000);
System.out.println("peek: " + list.peek());

PersistentQueue q = PersistentQueue.EMPTY;
System.out.println("PersistentQueue");
startTime = System.nanoTime();
for(int i = 0; i < n; i++)
{
q = q.cons(i);
q = q.cons(i);
q = q.pop();
}
// IPersistentList lastq = null;
// IPersistentList lastq2;
for(int i = 0; i < n - 10; i++)
{
//lastq2 = lastq;
//lastq = q;
q = q.pop();
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("time: " + estimatedTime / 1000000);
System.out.println("peek: " + q.peek());

IPersistentList q2 = q;
for(int i = 0; i < 10; i++)
{
q2 = (IPersistentList) q2.cons(i);
}
// for(ISeq s = q.seq();s != null;s = s.rest())
// System.out.println("q: " + s.first().toString());
// for(ISeq s = q2.seq();s != null;s = s.rest())
// System.out.println("q2: " + s.first().toString());
}
*/
}

———-
886 CHAPTER 8. JVM/CLOJURE/LANG/

8.83 PersistentStructMap.java

— PersistentStructMap.java —

\getchunk{Clojure Copyright}
/* rich Dec 16, 2007 */

package clojure.lang;

import java.util.Iterator;
import java.util.Map;
import java.io.Serializable;

public class PersistentStructMap extends APersistentMap implements IObj{

public static class Def implements Serializable{

final ISeq keys;
final IPersistentMap keyslots;

Def(ISeq keys, IPersistentMap keyslots){

this.keys = keys;
this.keyslots = keyslots;
}
}

final Def def;

final Object[] vals;
final IPersistentMap ext;
final IPersistentMap _meta;

static public Def createSlotMap(ISeq keys){

if(keys == null)
throw new IllegalArgumentException("Must supply keys");
int c = RT.count(keys);
Object[] v = new Object[2*c];
int i = 0;
for(ISeq s = keys; s != null; s = s.next(), i++)
{
v[2*i] = s.first();
v[2*i+1] = i;
}
return new Def(keys, RT.map(v));
}

static public PersistentStructMap create(Def def, ISeq keyvals){

Object[] vals = new Object[def.keyslots.count()];
IPersistentMap ext = PersistentHashMap.EMPTY;
8.83. PERSISTENTSTRUCTMAP.JAVA 887

for(; keyvals != null; keyvals = keyvals.next().next())

{
if(keyvals.next() == null)
throw new IllegalArgumentException(String.format(
"No value supplied for key: %s", keyvals.first()));
Object k = keyvals.first();
Object v = RT.second(keyvals);
Map.Entry e = def.keyslots.entryAt(k);
if(e != null)
vals[(Integer) e.getValue()] = v;
else
ext = ext.assoc(k, v);
}
return new PersistentStructMap(null, def, vals, ext);
}

static public PersistentStructMap construct(Def def, ISeq valseq){

Object[] vals = new Object[def.keyslots.count()];
IPersistentMap ext = PersistentHashMap.EMPTY;
for(int i = 0;
i < vals.length && valseq != null; valseq = valseq.next(),
i++)
{
vals[i] = valseq.first();
}
if(valseq != null)
throw new IllegalArgumentException(
"Too many arguments to struct constructor");
return new PersistentStructMap(null, def, vals, ext);
}

static public IFn getAccessor(final Def def, Object key){

Map.Entry e = def.keyslots.entryAt(key);
if(e != null)
{
final int i = (Integer) e.getValue();
return new AFn(){
public Object invoke(Object arg1) throws Exception{
PersistentStructMap m = (PersistentStructMap) arg1;
if(m.def != def)
throw new Exception("Accessor/struct mismatch");
return m.vals[i];
}
};
}
throw new IllegalArgumentException("Not a key of struct");
}

protected PersistentStructMap(IPersistentMap meta, Def def,

Object[] vals, IPersistentMap ext){
888 CHAPTER 8. JVM/CLOJURE/LANG/

this._meta = meta;
this.ext = ext;
this.def = def;
this.vals = vals;
}

/**
* Returns a new instance of PersistentStructMap using the given
* parameters. This function is used instead of the
* PersistentStructMap constructor by all methods that return a
* new PersistentStructMap. This is done so as to allow subclasses
* to return instances of their class from all PersistentStructMap
* methods.
*/
protected PersistentStructMap makeNew(IPersistentMap meta,
Def def,
Object[] vals,
IPersistentMap ext){
return new PersistentStructMap(meta, def, vals, ext);
}

public IObj withMeta(IPersistentMap meta){

if(meta == _meta)
return this;
return makeNew(meta, def, vals, ext);
}

public IPersistentMap meta(){

return _meta;
}

public boolean containsKey(Object key){

return def.keyslots.containsKey(key) || ext.containsKey(key);
}

public IMapEntry entryAt(Object key){

Map.Entry e = def.keyslots.entryAt(key);
if(e != null)
{
return new MapEntry(e.getKey(), vals[(Integer) e.getValue()]);
}
return ext.entryAt(key);
}

public IPersistentMap assoc(Object key, Object val){

Map.Entry e = def.keyslots.entryAt(key);
if(e != null)
{
int i = (Integer) e.getValue();
Object[] newVals = vals.clone();
8.83. PERSISTENTSTRUCTMAP.JAVA 889

newVals[i] = val;
return makeNew(_meta, def, newVals, ext);
}
return makeNew(_meta, def, vals, ext.assoc(key, val));
}

public Object valAt(Object key){

Integer i = (Integer) def.keyslots.valAt(key);
if(i != null)
{
return vals[i];
}
return ext.valAt(key);
}

public Object valAt(Object key, Object notFound){

Integer i = (Integer) def.keyslots.valAt(key);
if(i != null)
{
return vals[i];
}
return ext.valAt(key, notFound);
}

public IPersistentMap assocEx(Object key, Object val) throws Exception{

if(containsKey(key))
throw new Exception("Key already present");
return assoc(key, val);
}

public IPersistentMap without(Object key) throws Exception{

Map.Entry e = def.keyslots.entryAt(key);
if(e != null)
throw new Exception("Can’t remove struct key");
IPersistentMap newExt = ext.without(key);
if(newExt == ext)
return this;
return makeNew(_meta, def, vals, newExt);
}

public Iterator iterator(){

return new SeqIterator(seq());
}

public int count(){

return vals.length + RT.count(ext);
}

public ISeq seq(){

890 CHAPTER 8. JVM/CLOJURE/LANG/

return new Seq(null, def.keys, vals, 0, ext);

}

public IPersistentCollection empty(){

return construct(def, null);
}

static class Seq extends ASeq{

final int i;
final ISeq keys;
final Object[] vals;
final IPersistentMap ext;

public Seq(IPersistentMap meta,

ISeq keys,
Object[] vals,
int i,
IPersistentMap ext){
super(meta);
this.i = i;
this.keys = keys;
this.vals = vals;
this.ext = ext;
}

public Obj withMeta(IPersistentMap meta){

if(meta != _meta)
return new Seq(meta, keys, vals, i, ext);
return this;
}

public Object first(){

return new MapEntry(keys.first(), vals[i]);
}

public ISeq next(){

if(i + 1 < vals.length)
return new Seq(_meta, keys.next(), vals, i + 1, ext);
return ext.seq();
}
}
}

———-
8.84. PERSISTENTTREEMAP.JAVA 891

8.84 PersistentTreeMap.java

— PersistentTreeMap.java —

\getchunk{Clojure Copyright}
/* rich May 20, 2006 */

package clojure.lang;

import java.util.*;

/**
* Persistent Red Black Tree
* Note that instances of this class are constant values
* i.e. add/remove etc return new values
* 
* See Okasaki, Kahrs, Larsen et al
*/

public class PersistentTreeMap

extends APersistentMap implements IObj, Reversible, Sorted{

public final Comparator comp;

public final Node tree;
public final int _count;
final IPersistentMap _meta;

final static public PersistentTreeMap EMPTY = new PersistentTreeMap();

static public IPersistentMap create(Map other){

IPersistentMap ret = EMPTY;
for(Object o : other.entrySet())
{
Map.Entry e = (Entry) o;
ret = ret.assoc(e.getKey(), e.getValue());
}
return ret;
}

public PersistentTreeMap(){
this(RT.DEFAULT_COMPARATOR);
}

public PersistentTreeMap withMeta(IPersistentMap meta){

return new PersistentTreeMap(meta, comp, tree, _count);
}

private PersistentTreeMap(Comparator comp){

892 CHAPTER 8. JVM/CLOJURE/LANG/

this(null, comp);
}

public PersistentTreeMap(IPersistentMap meta, Comparator comp){

this.comp = comp;
this._meta = meta;
tree = null;
_count = 0;
}

PersistentTreeMap(IPersistentMap meta,
Comparator comp,
Node tree,
int _count){
this._meta = meta;
this.comp = comp;
this.tree = tree;
this._count = _count;
}

static public PersistentTreeMap create(ISeq items){

IPersistentMap ret = EMPTY;
for(; items != null; items = items.next().next())
{
if(items.next() == null)
throw new IllegalArgumentException(String.format(
"No value supplied for key: %s", items.first()));
ret = ret.assoc(items.first(), RT.second(items));
}
return (PersistentTreeMap) ret;
}

static public PersistentTreeMap create(Comparator comp, ISeq items){

IPersistentMap ret = new PersistentTreeMap(comp);
for(; items != null; items = items.next().next())
{
if(items.next() == null)
throw new IllegalArgumentException(String.format(
"No value supplied for key: %s", items.first()));
ret = ret.assoc(items.first(), RT.second(items));
}
return (PersistentTreeMap) ret;
}

public boolean containsKey(Object key){

return entryAt(key) != null;
}

public PersistentTreeMap assocEx(Object key, Object val)

8.84. PERSISTENTTREEMAP.JAVA 893

throws Exception{
Box found = new Box(null);
Node t = add(tree, key, val, found);
if(t == null) //null == already contains key
{
throw new Exception("Key already present");
}
return new PersistentTreeMap(comp, t.blacken(), _count + 1, meta());
}

public PersistentTreeMap assoc(Object key, Object val){

Box found = new Box(null);
Node t = add(tree, key, val, found);
if(t == null) //null == already contains key
{
Node foundNode = (Node) found.val;
if(foundNode.val() == val) //note only get same collection
//on identity of val, not equals()
return this;
return
new PersistentTreeMap(comp,
replace(tree, key, val),
_count,
meta());
}
return new PersistentTreeMap(comp, t.blacken(), _count + 1, meta());
}

public PersistentTreeMap without(Object key){

Box found = new Box(null);
Node t = remove(tree, key, found);
if(t == null)
{
if(found.val == null)//null == doesn’t contain key
return this;
//empty
return new PersistentTreeMap(meta(), comp);
}
return new PersistentTreeMap(comp, t.blacken(), _count - 1, meta());
}

public ISeq seq(){

if(_count > 0)
return Seq.create(tree, true, _count);
return null;
}

public IPersistentCollection empty(){

return new PersistentTreeMap(meta(), comp);
894 CHAPTER 8. JVM/CLOJURE/LANG/

public ISeq rseq() throws Exception{

if(_count > 0)
return Seq.create(tree, false, _count);
return null;
}

public Comparator comparator(){

return comp;
}

public Object entryKey(Object entry){

return ((IMapEntry) entry).key();
}

public ISeq seq(boolean ascending){

if(_count > 0)
return Seq.create(tree, ascending, _count);
return null;
}

public ISeq seqFrom(Object key, boolean ascending){

if(_count > 0)
{
ISeq stack = null;
Node t = tree;
while(t != null)
{
int c = doCompare(key, t.key);
if(c == 0)
{
stack = RT.cons(t, stack);
return new Seq(stack, ascending);
}
else if(ascending)
{
if(c < 0)
{
stack = RT.cons(t, stack);
t = t.left();
}
else
t = t.right();
}
else
{
if(c > 0)
{
stack = RT.cons(t, stack);
8.84. PERSISTENTTREEMAP.JAVA 895

t = t.right();
}
else
t = t.left();
}
}
if(stack != null)
return new Seq(stack, ascending);
}
return null;
}

public NodeIterator iterator(){

return new NodeIterator(tree, true);
}

public NodeIterator reverseIterator(){

return new NodeIterator(tree, false);
}

public Iterator keys(){

return keys(iterator());
}

public Iterator vals(){

return vals(iterator());
}

public Iterator keys(NodeIterator it){

return new KeyIterator(it);
}

public Iterator vals(NodeIterator it){

return new ValIterator(it);
}

public Object minKey(){

Node t = min();
return t != null ? t.key : null;
}

public Node min(){

Node t = tree;
if(t != null)
{
while(t.left() != null)
t = t.left();
}
return t;
}
896 CHAPTER 8. JVM/CLOJURE/LANG/

public Object maxKey(){

Node t = max();
return t != null ? t.key : null;
}

public Node max(){

Node t = tree;
if(t != null)
{
while(t.right() != null)
t = t.right();
}
return t;
}

public int depth(){

return depth(tree);
}

int depth(Node t){

if(t == null)
return 0;
return 1 + Math.max(depth(t.left()), depth(t.right()));
}

public Object valAt(Object key, Object notFound){

Node n = entryAt(key);
return (n != null) ? n.val() : notFound;
}

public Object valAt(Object key){

return valAt(key, null);
}

public int capacity(){

return _count;
}

public int count(){

return _count;
}

public Node entryAt(Object key){

Node t = tree;
while(t != null)
{
int c = doCompare(key, t.key);
if(c == 0)
return t;
8.84. PERSISTENTTREEMAP.JAVA 897

else if(c < 0)

t = t.left();
else
t = t.right();
}
return t;
}

public int doCompare(Object k1, Object k2){

// if(comp != null)
return comp.compare(k1, k2);
// return ((Comparable) k1).compareTo(k2);
}

Node add(Node t, Object key, Object val, Box found){

if(t == null)
{
if(val == null)
return new Red(key);
return new RedVal(key, val);
}
int c = doCompare(key, t.key);
if(c == 0)
{
found.val = t;
return null;
}
Node ins = c < 0
? add(t.left(), key, val, found)
: add(t.right(), key, val, found);
if(ins == null) //found below
return null;
if(c < 0)
return t.addLeft(ins);
return t.addRight(ins);
}

Node remove(Node t, Object key, Box found){

if(t == null)
return null; //not found indicator
int c = doCompare(key, t.key);
if(c == 0)
{
found.val = t;
return append(t.left(), t.right());
}
Node del = c < 0
? remove(t.left(), key, found)
: remove(t.right(), key, found);
if(del == null && found.val == null) //not found below
898 CHAPTER 8. JVM/CLOJURE/LANG/

return null;
if(c < 0)
{
if(t.left() instanceof Black)
return balanceLeftDel(t.key, t.val(), del, t.right());
else
return red(t.key, t.val(), del, t.right());
}
if(t.right() instanceof Black)
return balanceRightDel(t.key, t.val(), t.left(), del);
return red(t.key, t.val(), t.left(), del);
// return t.removeLeft(del);
// return t.removeRight(del);
}

static Node append(Node left, Node right){

if(left == null)
return right;
else if(right == null)
return left;
else if(left instanceof Red)
{
if(right instanceof Red)
{
Node app = append(left.right(), right.left());
if(app instanceof Red)
return
red(app.key, app.val(),
red(left.key, left.val(),
left.left(), app.left()),
red(right.key, right.val(),
app.right(), right.right()));
else
return
red(left.key, left.val(), left.left(),
red(right.key, right.val(), app, right.right()));
}
else
return red(left.key, left.val(), left.left(),
append(left.right(), right));
}
else if(right instanceof Red)
return red(right.key, right.val(),
append(left, right.left()), right.right());
else //black/black
{
Node app = append(left.right(), right.left());
if(app instanceof Red)
return
red(app.key, app.val(),
8.84. PERSISTENTTREEMAP.JAVA 899

black(left.key, left.val(),
left.left(), app.left()),
black(right.key, right.val(),
app.right(), right.right()));
else
return balanceLeftDel(left.key, left.val(), left.left(),
black(right.key, right.val(),
app, right.right()));
}
}

static Node balanceLeftDel(Object key, Object val,

Node del, Node right){
if(del instanceof Red)
return red(key, val, del.blacken(), right);
else if(right instanceof Black)
return rightBalance(key, val, del, right.redden());
else if(right instanceof Red && right.left() instanceof Black)
return red(right.left().key, right.left().val(),
black(key, val, del, right.left().left()),
rightBalance(right.key, right.val(),
right.left().right(),
right.right().redden()));
else
throw new UnsupportedOperationException("Invariant violation");
}

static Node balanceRightDel(Object key, Object val,

Node left, Node del){
if(del instanceof Red)
return red(key, val, left, del.blacken());
else if(left instanceof Black)
return leftBalance(key, val, left.redden(), del);
else if(left instanceof Red && left.right() instanceof Black)
return red(left.right().key, left.right().val(),
leftBalance(left.key, left.val(),
left.left().redden(),
left.right().left()),
black(key, val, left.right().right(), del));
else
throw new UnsupportedOperationException("Invariant violation");
}

static Node leftBalance(Object key, Object val,

Node ins, Node right){
if(ins instanceof Red && ins.left() instanceof Red)
return red(ins.key, ins.val(),
ins.left().blacken(),
black(key, val, ins.right(), right));
else if(ins instanceof Red && ins.right() instanceof Red)
900 CHAPTER 8. JVM/CLOJURE/LANG/

return red(ins.right().key, ins.right().val(),

black(ins.key, ins.val(),
ins.left(), ins.right().left()),
black(key, val, ins.right().right(), right));
else
return black(key, val, ins, right);
}

static Node rightBalance(Object key, Object val, Node left, Node ins){
if(ins instanceof Red && ins.right() instanceof Red)
return red(ins.key, ins.val(),
black(key, val, left, ins.left()),
ins.right().blacken());
else if(ins instanceof Red && ins.left() instanceof Red)
return red(ins.left().key, ins.left().val(),
black(key, val, left, ins.left().left()),
black(ins.key, ins.val(),
ins.left().right(), ins.right()));
else
return black(key, val, left, ins);
}

Node replace(Node t, Object key, Object val){

int c = doCompare(key, t.key);
return t.replace(t.key,
c == 0 ? val : t.val(),
c < 0 ? replace(t.left(), key, val) : t.left(),
c > 0 ? replace(t.right(), key, val) : t.right());
}

PersistentTreeMap(Comparator comp, Node tree,

int count, IPersistentMap meta){
this._meta = meta;
this.comp = comp;
this.tree = tree;
this._count = count;
}

static Red red(Object key, Object val, Node left, Node right){
if(left == null && right == null)
{
if(val == null)
return new Red(key);
return new RedVal(key, val);
}
if(val == null)
return new RedBranch(key, left, right);
return new RedBranchVal(key, val, left, right);
}
8.84. PERSISTENTTREEMAP.JAVA 901

static Black black(Object key, Object val, Node left, Node right){
if(left == null && right == null)
{
if(val == null)
return new Black(key);
return new BlackVal(key, val);
}
if(val == null)
return new BlackBranch(key, left, right);
return new BlackBranchVal(key, val, left, right);
}

public IPersistentMap meta(){

return _meta;
}

\getchunk{PersistentTreeMap Node Class}

\getchunk{PersistentTreeMap Black Class}

\getchunk{PersistentTreeMap BlackVal Class}

\getchunk{PersistentTreeMap BlackBranch Class}

\getchunk{PersistentTreeMap BlackBranchVal Class}

\getchunk{PersistentTreeMap Red Class}

\getchunk{PersistentTreeMap RedVal Class}

\getchunk{PersistentTreeMap RedBranch Class}

\getchunk{PersistentTreeMap RedBranchVal Class}

\getchunk{PersistentTreeMap Seq Class}

\getchunk{PersistentTreeMap NodeIterator Class}

\getchunk{PersistentTreeMap KeyIterator Class}

\getchunk{PersistentTreeMap ValIterator Class}

/*
static public void main(String args[]){
if(args.length != 1)
System.err.println("Usage: RBTree n");
int n = Integer.parseInt(args[0]);
Integer[] ints = new Integer[n];
for(int i = 0; i < ints.length; i++)
902 CHAPTER 8. JVM/CLOJURE/LANG/

{
ints[i] = i;
}
Collections.shuffle(Arrays.asList(ints));
//force the ListMap class loading now
// try
// {
//
// //PersistentListMap.EMPTY.assocEx(1, null)
// .assocEx(2,null).assocEx(3,null);
// }
// catch(Exception e)
// {
// e.printStackTrace(); //To change body of catch statement
// //use File | Settings | File Templates.
// }
System.out.println("Building set");
//IPersistentMap set = new PersistentArrayMap();
//IPersistentMap set = new PersistentHashtableMap(1001);
IPersistentMap set = PersistentHashMap.EMPTY;
//IPersistentMap set = new ListMap();
//IPersistentMap set = new ArrayMap();
//IPersistentMap set = new PersistentTreeMap();
// for(int i = 0; i < ints.length; i++)
// {
// Integer anInt = ints[i];
// set = set.add(anInt);
// }
long startTime = System.nanoTime();
for(Integer anInt : ints)
{
set = set.assoc(anInt, anInt);
}
//System.out.println("_count = " + set.count());

// System.out.println("_count = " + set._count +

// ", min: " + set.minKey() + ", max: " +
// set.maxKey()
// + ", depth: " + set.depth());
for(Object aSet : set)
{
IMapEntry o = (IMapEntry) aSet;
if(!set.contains(o.key()))
System.err.println("Can’t find: " + o.key());
//else if(n < 2000)
// System.out.print(o.key().toString() + ",");
}

Random rand = new Random(42);

for(int i = 0; i < ints.length / 2; i++)
8.84. PERSISTENTTREEMAP.JAVA 903

{
Integer anInt = ints[rand.nextInt(n)];
set = set.without(anInt);
}

long estimatedTime = System.nanoTime() - startTime;

System.out.println();

System.out.println("_count = " + set.count() +

", time: " + estimatedTime / 1000000);

System.out.println("Building ht");
Hashtable ht = new Hashtable(1001);
startTime = System.nanoTime();
// for(int i = 0; i < ints.length; i++)
// {
// Integer anInt = ints[i];
// ht.put(anInt,null);
// }
for(Integer anInt : ints)
{
ht.put(anInt, anInt);
}
//System.out.println("size = " + ht.size());
//Iterator it = ht.entrySet().iterator();
for(Object o1 : ht.entrySet())
{
Map.Entry o = (Map.Entry) o1;
if(!ht.containsKey(o.getKey()))
System.err.println("Can’t find: " + o);
//else if(n < 2000)
// System.out.print(o.toString() + ",");
}

rand = new Random(42);

for(int i = 0; i < ints.length / 2; i++)
{
Integer anInt = ints[rand.nextInt(n)];
ht.remove(anInt);
}
estimatedTime = System.nanoTime() - startTime;
System.out.println();
System.out.println("size = " + ht.size() + ", time: " +
estimatedTime / 1000000);

System.out.println("set lookup");
startTime = System.nanoTime();
int c = 0;
for(Integer anInt : ints)
{
904 CHAPTER 8. JVM/CLOJURE/LANG/

if(!set.contains(anInt))
++c;
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("notfound = " + c + ", time: " +
estimatedTime / 1000000);

System.out.println("ht lookup");
startTime = System.nanoTime();
c = 0;
for(Integer anInt : ints)
{
if(!ht.containsKey(anInt))
++c;
}
estimatedTime = System.nanoTime() - startTime;
System.out.println("notfound = " + c + ", time: " +
estimatedTime / 1000000);

// System.out.println("_count = " + set._count +

// ", min: " + set.minKey() +
// ", max: " + set.maxKey()
// + ", depth: " + set.depth());
}
*/
}

———-

8.85 PersistentTreeSet.java

— PersistentTreeSet.java —

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

import java.util.Comparator;

public class PersistentTreeSet

extends APersistentSet implements IObj, Reversible, Sorted{

static public final PersistentTreeSet EMPTY =

new PersistentTreeSet(null, PersistentTreeMap.EMPTY);
final IPersistentMap _meta;
8.85. PERSISTENTTREESET.JAVA 905

static public PersistentTreeSet create(ISeq items){

PersistentTreeSet ret = EMPTY;
for(; items != null; items = items.next())
{
ret = (PersistentTreeSet) ret.cons(items.first());
}
return ret;
}

static public PersistentTreeSet create(Comparator comp, ISeq items){

PersistentTreeSet ret =
new PersistentTreeSet(null, new PersistentTreeMap(null, comp));
for(; items != null; items = items.next())
{
ret = (PersistentTreeSet) ret.cons(items.first());
}
return ret;
}

PersistentTreeSet(IPersistentMap meta, IPersistentMap impl){

super(impl);
this._meta = meta;
}

public IPersistentSet disjoin(Object key) throws Exception{

if(contains(key))
return new PersistentTreeSet(meta(),impl.without(key));
return this;
}

public IPersistentSet cons(Object o){

if(contains(o))
return this;
return new PersistentTreeSet(meta(),impl.assoc(o,o));
}

public IPersistentCollection empty(){

return
new PersistentTreeSet(meta(),(PersistentTreeMap)impl.empty());
}

public ISeq rseq() throws Exception{

return APersistentMap.KeySeq.create(((Reversible) impl).rseq());
}

public PersistentTreeSet withMeta(IPersistentMap meta){

return new PersistentTreeSet(meta, impl);
}
906 CHAPTER 8. JVM/CLOJURE/LANG/

public Comparator comparator(){

return ((Sorted)impl).comparator();
}

public Object entryKey(Object entry){

return entry;
}

public ISeq seq(boolean ascending){

PersistentTreeMap m = (PersistentTreeMap) impl;
return RT.keys(m.seq(ascending));
}

public ISeq seqFrom(Object key, boolean ascending){

PersistentTreeMap m = (PersistentTreeMap) impl;
return RT.keys(m.seqFrom(key,ascending));
}

public IPersistentMap meta(){

return _meta;
}
}

———-

8.86 PersistentVector.java

— PersistentVector.java —

\getchunk{Clojure Copyright}
/* rich Jul 5, 2007 */

package clojure.lang;

import java.io.Serializable;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

public class PersistentVector

extends APersistentVector implements IObj, IEditableCollection{

static class Node implements Serializable {

transient final AtomicReference<Thread> edit;
final Object[] array;

Node(AtomicReference<Thread> edit, Object[] array){

this.edit = edit;
8.86. PERSISTENTVECTOR.JAVA 907

this.array = array;
}

Node(AtomicReference<Thread> edit){
this.edit = edit;
this.array = new Object[32];
}
}

final static AtomicReference<Thread> NOEDIT =

new AtomicReference<Thread>(null);
final static Node EMPTY_NODE = new Node(NOEDIT, new Object[32]);

final int cnt;

final int shift;
final Node root;
final Object[] tail;
final IPersistentMap _meta;

public final static PersistentVector EMPTY =

new PersistentVector(0, 5, EMPTY_NODE, new Object[]{});

static public PersistentVector create(ISeq items){

TransientVector ret = EMPTY.asTransient();
for(; items != null; items = items.next())
ret = ret.conj(items.first());
return ret.persistent();
}

static public PersistentVector create(List items){

TransientVector ret = EMPTY.asTransient();
for(Object item : items)
ret = ret.conj(item);
return ret.persistent();
}

static public PersistentVector create(Object... items){

TransientVector ret = EMPTY.asTransient();
for(Object item : items)
ret = ret.conj(item);
return ret.persistent();
}

PersistentVector(int cnt, int shift, Node root, Object[] tail){

this._meta = null;
this.cnt = cnt;
this.shift = shift;
this.root = root;
this.tail = tail;
908 CHAPTER 8. JVM/CLOJURE/LANG/

PersistentVector(IPersistentMap meta, int cnt, int shift,

Node root, Object[] tail){
this._meta = meta;
this.cnt = cnt;
this.shift = shift;
this.root = root;
this.tail = tail;
}

public TransientVector asTransient(){

return new TransientVector(this);
}

final int tailoff(){

if(cnt < 32)
return 0;
return ((cnt - 1) >>> 5) << 5;
}

public Object[] arrayFor(int i){

if(i >= 0 && i < cnt)
{
if(i >= tailoff())
return tail;
Node node = root;
for(int level = shift; level > 0; level -= 5)
node = (Node) node.array[(i >>> level) & 0x01f];
return node.array;
}
throw new IndexOutOfBoundsException();
}

public Object nth(int i){

Object[] node = arrayFor(i);
return node[i & 0x01f];
}

public Object nth(int i, Object notFound){

if(i >= 0 && i < cnt)
return nth(i);
return notFound;
}

public PersistentVector assocN(int i, Object val){

if(i >= 0 && i < cnt)
{
if(i >= tailoff())
8.86. PERSISTENTVECTOR.JAVA 909

{
Object[] newTail = new Object[tail.length];
System.arraycopy(tail, 0, newTail, 0, tail.length);
newTail[i & 0x01f] = val;
return
new PersistentVector(meta(), cnt, shift, root, newTail);
}

return
new PersistentVector(meta(), cnt, shift,
doAssoc(shift, root, i, val), tail);
}
if(i == cnt)
return cons(val);
throw new IndexOutOfBoundsException();
}

private static Node doAssoc(int level, Node node, int i, Object val){
Node ret = new Node(node.edit,node.array.clone());
if(level == 0)
{
ret.array[i & 0x01f] = val;
}
else
{
int subidx = (i >>> level) & 0x01f;
ret.array[subidx] =
doAssoc(level - 5, (Node) node.array[subidx], i, val);
}
return ret;
}

public int count(){

return cnt;
}

public PersistentVector withMeta(IPersistentMap meta){

return new PersistentVector(meta, cnt, shift, root, tail);
}

public IPersistentMap meta(){

return _meta;
}

public PersistentVector cons(Object val){

int i = cnt;
//room in tail?
// if(tail.length < 32)
if(cnt - tailoff() < 32)
910 CHAPTER 8. JVM/CLOJURE/LANG/

{
Object[] newTail = new Object[tail.length + 1];
System.arraycopy(tail, 0, newTail, 0, tail.length);
newTail[tail.length] = val;
return
new PersistentVector(meta(), cnt + 1, shift, root, newTail);
}
//full tail, push into tree
Node newroot;
Node tailnode = new Node(root.edit,tail);
int newshift = shift;
//overflow root?
if((cnt >>> 5) > (1 << shift))
{
newroot = new Node(root.edit);
newroot.array[0] = root;
newroot.array[1] = newPath(root.edit,shift, tailnode);
newshift += 5;
}
else
newroot = pushTail(shift, root, tailnode);
return
new PersistentVector(meta(), cnt + 1, newshift,
newroot, new Object[]{val});
}

private Node pushTail(int level, Node parent, Node tailnode){

//if parent is leaf, insert node,
// else does it map to an existing
// child? -> nodeToInsert = pushNode one more level
// else alloc new path
//return nodeToInsert placed in copy of parent
int subidx = ((cnt - 1) >>> level) & 0x01f;
Node ret = new Node(parent.edit, parent.array.clone());
Node nodeToInsert;
if(level == 5)
{
nodeToInsert = tailnode;
}
else
{
Node child = (Node) parent.array[subidx];
nodeToInsert = (child != null)?
pushTail(level-5,child, tailnode)
:newPath(root.edit,level-5, tailnode);
}
ret.array[subidx] = nodeToInsert;
return ret;
}
8.86. PERSISTENTVECTOR.JAVA 911

private static Node newPath(AtomicReference<Thread> edit,

int level, Node node){
if(level == 0)
return node;
Node ret = new Node(edit);
ret.array[0] = newPath(edit, level - 5, node);
return ret;
}

public IChunkedSeq chunkedSeq(){

if(count() == 0)
return null;
return new ChunkedSeq(this,0,0);
}

public ISeq seq(){

return chunkedSeq();
}

static public final class ChunkedSeq

extends ASeq implements IChunkedSeq{

public final PersistentVector vec;

final Object[] node;
final int i;
public final int offset;

public ChunkedSeq(PersistentVector vec, int i, int offset){

this.vec = vec;
this.i = i;
this.offset = offset;
this.node = vec.arrayFor(i);
}

ChunkedSeq(IPersistentMap meta, PersistentVector vec,

Object[] node, int i, int offset){
super(meta);
this.vec = vec;
this.node = node;
this.i = i;
this.offset = offset;
}

ChunkedSeq(PersistentVector vec, Object[] node, int i, int offset){

this.vec = vec;
this.node = node;
this.i = i;
this.offset = offset;
}
912 CHAPTER 8. JVM/CLOJURE/LANG/

public IChunk chunkedFirst() throws Exception{

return new ArrayChunk(node, offset);
}

public ISeq chunkedNext(){

if(i + node.length < vec.cnt)
return new ChunkedSeq(vec,i+ node.length,0);
return null;
}

public ISeq chunkedMore(){

ISeq s = chunkedNext();
if(s == null)
return PersistentList.EMPTY;
return s;
}

public Obj withMeta(IPersistentMap meta){

if(meta == this._meta)
return this;
return new ChunkedSeq(meta, vec, node, i, offset);
}

public Object first(){

return node[offset];
}

public ISeq next(){

if(offset + 1 < node.length)
return new ChunkedSeq(vec, node, i, offset + 1);
return chunkedNext();
}
}

public IPersistentCollection empty(){

return EMPTY.withMeta(meta());
}

//private Node pushTail(int level, Node node,

// Object[] tailNode, Box expansion){
// Object newchild;
// if(level == 0)
// {
// newchild = tailNode;
// }
// else
// {
// newchild =
// pushTail(level - 5,
// (Object[]) arr[arr.length - 1], tailNode, expansion);
8.86. PERSISTENTVECTOR.JAVA 913

// if(expansion.val == null)
// {
// Object[] ret = arr.clone();
// ret[arr.length - 1] = newchild;
// return ret;
// }
// else
// newchild = expansion.val;
// }
// //expansion
// if(arr.length == 32)
// {
// expansion.val = new Object[]{newchild};
// return arr;
// }
// Object[] ret = new Object[arr.length + 1];
// System.arraycopy(arr, 0, ret, 0, arr.length);
// ret[arr.length] = newchild;
// expansion.val = null;
// return ret;
//}

public PersistentVector pop(){

if(cnt == 0)
throw new IllegalStateException("Can’t pop empty vector");
if(cnt == 1)
return EMPTY.withMeta(meta());
//if(tail.length > 1)
if(cnt-tailoff() > 1)
{
Object[] newTail = new Object[tail.length - 1];
System.arraycopy(tail, 0, newTail, 0, newTail.length);
return
new PersistentVector(meta(), cnt - 1, shift, root, newTail);
}
Object[] newtail = arrayFor(cnt - 2);

Node newroot = popTail(shift, root);

int newshift = shift;
if(newroot == null)
{
newroot = EMPTY_NODE;
}
if(shift > 5 && newroot.array[1] == null)
{
newroot = (Node) newroot.array[0];
newshift -= 5;
}
return
new PersistentVector(meta(), cnt - 1, newshift, newroot, newtail);
914 CHAPTER 8. JVM/CLOJURE/LANG/

private Node popTail(int level, Node node){

int subidx = ((cnt-2) >>> level) & 0x01f;
if(level > 5)
{
Node newchild = popTail(level - 5, (Node) node.array[subidx]);
if(newchild == null && subidx == 0)
return null;
else
{
Node ret = new Node(root.edit, node.array.clone());
ret.array[subidx] = newchild;
return ret;
}
}
else if(subidx == 0)
return null;
else
{
Node ret = new Node(root.edit, node.array.clone());
ret.array[subidx] = null;
return ret;
}
}

static final class TransientVector

extends AFn implements ITransientVector, Counted{
int cnt;
int shift;
Node root;
Object[] tail;

TransientVector(int cnt, int shift, Node root, Object[] tail){

this.cnt = cnt;
this.shift = shift;
this.root = root;
this.tail = tail;
}

TransientVector(PersistentVector v){
this(v.cnt, v.shift, editableRoot(v.root), editableTail(v.tail));
}

public int count(){

ensureEditable();
return cnt;
}

Node ensureEditable(Node node){

8.86. PERSISTENTVECTOR.JAVA 915

if(node.edit == root.edit)
return node;
return new Node(root.edit, node.array.clone());
}

void ensureEditable(){
Thread owner = root.edit.get();
if(owner == Thread.currentThread())
return;
if(owner != null)
throw new IllegalAccessError(
"Transient used by non-owner thread");
throw new IllegalAccessError(
"Transient used after persistent! call");

// root = editableRoot(root);
// tail = editableTail(tail);
}

static Node editableRoot(Node node){

return
new Node(new AtomicReference<Thread>(Thread.currentThread()),
node.array.clone());
}

public PersistentVector persistent(){

ensureEditable();
// Thread owner = root.edit.get();
// if(owner != null && owner != Thread.currentThread())
// {
// throw new IllegalAccessError(
// "Mutation release by non-owner thread");
// }
root.edit.set(null);
Object[] trimmedTail = new Object[cnt-tailoff()];
System.arraycopy(tail,0,trimmedTail,0,trimmedTail.length);
return new PersistentVector(cnt, shift, root, trimmedTail);
}

static Object[] editableTail(Object[] tl){

Object[] ret = new Object[32];
System.arraycopy(tl,0,ret,0,tl.length);
return ret;
}

public TransientVector conj(Object val){

ensureEditable();
int i = cnt;
//room in tail?
if(i - tailoff() < 32)
916 CHAPTER 8. JVM/CLOJURE/LANG/

{
tail[i & 0x01f] = val;
++cnt;
return this;
}
//full tail, push into tree
Node newroot;
Node tailnode = new Node(root.edit, tail);
tail = new Object[32];
tail[0] = val;
int newshift = shift;
//overflow root?
if((cnt >>> 5) > (1 << shift))
{
newroot = new Node(root.edit);
newroot.array[0] = root;
newroot.array[1] = newPath(root.edit,shift, tailnode);
newshift += 5;
}
else
newroot = pushTail(shift, root, tailnode);
root = newroot;
shift = newshift;
++cnt;
return this;
}

private Node pushTail(int level, Node parent, Node tailnode){

//if parent is leaf, insert node,
// else does it map to an existing
// child? -> nodeToInsert = pushNode one more level
// else alloc new path
//return nodeToInsert placed in parent
parent = ensureEditable(parent);
int subidx = ((cnt - 1) >>> level) & 0x01f;
Node ret = parent;
Node nodeToInsert;
if(level == 5)
{
nodeToInsert = tailnode;
}
else
{
Node child = (Node) parent.array[subidx];
nodeToInsert =
(child != null)
? pushTail(level - 5, child, tailnode)
: newPath(root.edit, level - 5, tailnode);
}
ret.array[subidx] = nodeToInsert;
8.86. PERSISTENTVECTOR.JAVA 917

return ret;
}

final private int tailoff(){

if(cnt < 32)
return 0;
return ((cnt-1) >>> 5) << 5;
}

private Object[] arrayFor(int i){

public Object valAt(Object key){

//note - relies on ensureEditable in 2-arg valAt
return valAt(key, null);
}

public Object valAt(Object key, Object notFound){

ensureEditable();
if(Util.isInteger(key))
{
int i = ((Number) key).intValue();
if(i >= 0 && i < cnt)
return nth(i);
}
return notFound;
}

public Object invoke(Object arg1) throws Exception{

//note - relies on ensureEditable in nth
if(Util.isInteger(arg1))
return nth(((Number) arg1).intValue());
throw new IllegalArgumentException("Key must be integer");
}

public Object nth(int i){

ensureEditable();
Object[] node = arrayFor(i);
return node[i & 0x01f];
}
918 CHAPTER 8. JVM/CLOJURE/LANG/

public Object nth(int i, Object notFound){

if(i >= 0 && i < count())
return nth(i);
return notFound;
}

public TransientVector assocN(int i, Object val){

ensureEditable();
if(i >= 0 && i < cnt)
{
if(i >= tailoff())
{
tail[i & 0x01f] = val;
return this;
}

root = doAssoc(shift, root, i, val);

return this;
}
if(i == cnt)
return conj(val);
throw new IndexOutOfBoundsException();
}

public TransientVector assoc(Object key, Object val){

//note - relies on ensureEditable in assocN
if(Util.isInteger(key))
{
int i = ((Number) key).intValue();
return assocN(i, val);
}
throw new IllegalArgumentException("Key must be integer");
}

private Node doAssoc(int level, Node node, int i, Object val){

node = ensureEditable(node);
Node ret = node;
if(level == 0)
{
ret.array[i & 0x01f] = val;
}
else
{
int subidx = (i >>> level) & 0x01f;
ret.array[subidx] =
doAssoc(level - 5, (Node) node.array[subidx], i, val);
}
return ret;
}
8.86. PERSISTENTVECTOR.JAVA 919

public TransientVector pop(){

ensureEditable();
if(cnt == 0)
throw new IllegalStateException("Can’t pop empty vector");
if(cnt == 1)
{
cnt = 0;
return this;
}
int i = cnt - 1;
//pop in tail?
if((i & 0x01f) > 0)
{
--cnt;
return this;
}

Object[] newtail = arrayFor(cnt - 2);

Node newroot = popTail(shift, root);

int newshift = shift;
if(newroot == null)
{
newroot = new Node(root.edit);
}
if(shift > 5 && newroot.array[1] == null)
{
newroot = ensureEditable((Node) newroot.array[0]);
newshift -= 5;
}
root = newroot;
shift = newshift;
--cnt;
tail = newtail;
return this;
}

private Node popTail(int level, Node node){

node = ensureEditable(node);
int subidx = ((cnt - 2) >>> level) & 0x01f;
if(level > 5)
{
Node newchild =
popTail(level - 5, (Node) node.array[subidx]);
if(newchild == null && subidx == 0)
return null;
else
{
Node ret = node;
920 CHAPTER 8. JVM/CLOJURE/LANG/

ret.array[subidx] = newchild;
return ret;
}
}
else if(subidx == 0)
return null;
else
{
Node ret = node;
ret.array[subidx] = null;
return ret;
}
}
}
/*
static public void main(String[] args){
if(args.length != 3)
{
System.err.println("Usage: PersistentVector size writes reads");
return;
}
int size = Integer.parseInt(args[0]);
int writes = Integer.parseInt(args[1]);
int reads = Integer.parseInt(args[2]);
// Vector v = new Vector(size);
ArrayList v = new ArrayList(size);
// v.setSize(size);
//PersistentArray p = new PersistentArray(size);
PersistentVector p = PersistentVector.EMPTY;
// MutableVector mp = p.mutable();

for(int i = 0; i < size; i++)

{
v.add(i);
// v.set(i, i);
//p = p.set(i, 0);
p = p.cons(i);
// mp = mp.conj(i);
}

Random rand;

rand = new Random(42);

long tv = 0;
System.out.println("ArrayList");
long startTime = System.nanoTime();
for(int i = 0; i < writes; i++)
{
v.set(rand.nextInt(size), i);
}
8.86. PERSISTENTVECTOR.JAVA 921

for(int i = 0; i < reads; i++)

{
tv += (Integer) v.get(rand.nextInt(size));
}
long estimatedTime = System.nanoTime() - startTime;
System.out.println("time: " + estimatedTime / 1000000);
System.out.println("PersistentVector");
rand = new Random(42);
startTime = System.nanoTime();
long tp = 0;

// PersistentVector oldp = p;
//Random rand2 = new Random(42);

MutableVector mp = p.mutable();
for(int i = 0; i < writes; i++)
{
// p = p.assocN(rand.nextInt(size), i);
mp = mp.assocN(rand.nextInt(size), i);
// mp = mp.assoc(rand.nextInt(size), i);
//dummy set to force perverse branching
//oldp = oldp.assocN(rand2.nextInt(size), i);
}
for(int i = 0; i < reads; i++)
{
// tp += (Integer) p.nth(rand.nextInt(size));
tp += (Integer) mp.nth(rand.nextInt(size));
}
// p = mp.immutable();
//mp.cons(42);
estimatedTime = System.nanoTime() - startTime;
System.out.println("time: " + estimatedTime / 1000000);
for(int i = 0; i < size / 2; i++)
{
mp = mp.pop();
// p = p.pop();
v.remove(v.size() - 1);
}
p = (PersistentVector) mp.immutable();
//mp.pop(); //should fail
for(int i = 0; i < size / 2; i++)
{
tp += (Integer) p.nth(i);
tv += (Integer) v.get(i);
}
System.out.println("Done: " + tv + ", " + tp);

}
// */
}
922 CHAPTER 8. JVM/CLOJURE/LANG/

———-

8.87 ProxyHandler.java

— ProxyHandler.java —

\getchunk{Clojure Copyright}
/* rich Oct 4, 2007 */

package clojure.lang;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyHandler implements InvocationHandler{

//method-name-string->fn
final IPersistentMap fns;

public ProxyHandler(IPersistentMap fns){

this.fns = fns;
}

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable{
Class rt = method.getReturnType();
IFn fn = (IFn) fns.valAt(method.getName());
if(fn == null)
{
if(rt == Void.TYPE)
return null;
else if(method.getName().equals("equals"))
{
return proxy == args[0];
}
else if(method.getName().equals("hashCode"))
{
return System.identityHashCode(proxy);
}
else if(method.getName().equals("toString"))
{
return "Proxy: " + System.identityHashCode(proxy);
}
throw new UnsupportedOperationException();
}
Object ret = fn.applyTo(ArraySeq.create(args));
if(rt == Void.TYPE)
8.88. RANGE.JAVA 923

return null;
else if(rt.isPrimitive())
{
if(rt == Character.TYPE)
return ret;
else if(rt == Integer.TYPE)
return ((Number) ret).intValue();
else if(rt == Long.TYPE)
return ((Number) ret).longValue();
else if(rt == Float.TYPE)
return ((Number) ret).floatValue();
else if(rt == Double.TYPE)
return ((Number) ret).doubleValue();
else if(rt == Boolean.TYPE && !(ret instanceof Boolean))
return ret == null ? Boolean.FALSE : Boolean.TRUE;
else if(rt == Byte.TYPE)
return (byte) ((Number) ret).intValue();
else if(rt == Short.TYPE)
return (short) ((Number) ret).intValue();
}
return ret;
}
}

———-

8.88 Range.java

— Range.java —

\getchunk{Clojure Copyright}
/* rich Apr 1, 2008 */

package clojure.lang;

public class Range extends ASeq implements IReduce, Counted{

final int end;
final int n;

public Range(int start, int end){

this.end = end;
this.n = start;
}

public Range(IPersistentMap meta, int start, int end){

super(meta);
this.end = end;
924 CHAPTER 8. JVM/CLOJURE/LANG/

this.n = start;
}

public Obj withMeta(IPersistentMap meta){

if(meta == meta())
return this;
return new Range(meta(), end, n);
}

public Object first(){

return n;
}

public ISeq next(){

if(n < end-1)
return new Range(_meta, n + 1, end);
return null;
}

public Object reduce(IFn f) throws Exception{

Object ret = n;
for(int x = n+1;x < end;x++)
ret = f.invoke(ret, x);
return ret;
}

public Object reduce(IFn f, Object start) throws Exception{

Object ret = f.invoke(start,n);
for(int x = n+1;x < end;x++)
ret = f.invoke(ret, x);
return ret;
}

public int count() {

return end - n;
}

———-

8.89 Ratio.java

— Ratio.java —

\getchunk{Clojure Copyright}
/* rich Mar 31, 2008 */
8.89. RATIO.JAVA 925

package clojure.lang;

import java.math.BigInteger;
import java.math.BigDecimal;
import java.math.MathContext;

public class Ratio extends Number implements Comparable{

final public BigInteger numerator;
final public BigInteger denominator;

public Ratio(BigInteger numerator, BigInteger denominator){

this.numerator = numerator;
this.denominator = denominator;
}

public boolean equals(Object arg0){

return arg0 != null
&& arg0 instanceof Ratio
&& ((Ratio) arg0).numerator.equals(numerator)
&& ((Ratio) arg0).denominator.equals(denominator);
}

public int hashCode(){

return numerator.hashCode() ^ denominator.hashCode();
}

public String toString(){

return numerator.toString() + "/" + denominator.toString();
}

public int intValue(){

return (int) doubleValue();
}

public long longValue(){

return bigIntegerValue().longValue();
}

public float floatValue(){

return (float)doubleValue();
}

public double doubleValue(){

return decimalValue(MathContext.DECIMAL64).doubleValue();
}

public BigDecimal decimalValue(){

return decimalValue(MathContext.UNLIMITED);
}
926 CHAPTER 8. JVM/CLOJURE/LANG/

public BigDecimal decimalValue(MathContext mc){

BigDecimal numerator = new BigDecimal(this.numerator);
BigDecimal denominator = new BigDecimal(this.denominator);

return numerator.divide(denominator, mc);

}

public BigInteger bigIntegerValue(){

return numerator.divide(denominator);
}

public int compareTo(Object o){

Number other = (Number)o;
return Numbers.compare(this, other);
}
}

———-

8.90 Ref.java

— Ref.java —

\getchunk{Clojure Copyright}
/* rich Jul 25, 2007 */

package clojure.lang;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Ref extends ARef implements IFn, Comparable<Ref>, IRef{

public int compareTo(Ref ref) {
if(this.id == ref.id)
return 0;
else if(this.id < ref.id)
return -1;
else
return 1;
}

public int getMinHistory(){

return minHistory;
}
8.90. REF.JAVA 927

public Ref setMinHistory(int minHistory){

this.minHistory = minHistory;
return this;
}

public int getMaxHistory(){

return maxHistory;
}

public Ref setMaxHistory(int maxHistory){

this.maxHistory = maxHistory;
return this;
}

public static class TVal{

Object val;
long point;
long msecs;
TVal prior;
TVal next;

TVal(Object val, long point, long msecs, TVal prior){

this.val = val;
this.point = point;
this.msecs = msecs;
this.prior = prior;
this.next = prior.next;
this.prior.next = this;
this.next.prior = this;
}

TVal(Object val, long point, long msecs){

this.val = val;
this.point = point;
this.msecs = msecs;
this.next = this;
this.prior = this;
}

TVal tvals;
final AtomicInteger faults;
final ReentrantReadWriteLock lock;
LockingTransaction.Info tinfo;
//IFn validator;
final long id;

volatile int minHistory = 0;

volatile int maxHistory = 10;
928 CHAPTER 8. JVM/CLOJURE/LANG/

static final AtomicLong ids = new AtomicLong();

public Ref(Object initVal) throws Exception{

this(initVal, null);
}

public Ref(Object initVal,IPersistentMap meta) throws Exception{

super(meta);
this.id = ids.getAndIncrement();
this.faults = new AtomicInteger();
this.lock = new ReentrantReadWriteLock();
tvals = new TVal(initVal, 0, System.currentTimeMillis());
}

//the latest val

// ok out of transaction
Object currentVal(){
try
{
lock.readLock().lock();
if(tvals != null)
return tvals.val;
throw new IllegalStateException(
this.toString() + " is unbound.");
}
finally
{
lock.readLock().unlock();
}
}

//*

public Object deref(){

LockingTransaction t = LockingTransaction.getRunning();
if(t == null)
return currentVal();
return t.doGet(this);
}

//void validate(IFn vf, Object val){

// try{
// if(vf != null && !RT.booleanCast(vf.invoke(val)))
// throw new IllegalStateException("Invalid ref state");
// }
// catch(RuntimeException re)
// {
// throw re;
8.90. REF.JAVA 929

// }
// catch(Exception e)
// {
// throw new IllegalStateException("Invalid ref state", e);
// }
//}
//
//public void setValidator(IFn vf){
// try
// {
// lock.writeLock().lock();
// validate(vf,currentVal());
// validator = vf;
// }
// finally
// {
// lock.writeLock().unlock();
// }
//}
//
//public IFn getValidator(){
// try
// {
// lock.readLock().lock();
// return validator;
// }
// finally
// {
// lock.readLock().unlock();
// }
//}

public Object set(Object val){

return LockingTransaction.getEx().doSet(this, val);
}

public Object commute(IFn fn, ISeq args) throws Exception{

return LockingTransaction.getEx().doCommute(this, fn, args);
}

public Object alter(IFn fn, ISeq args) throws Exception{

LockingTransaction t = LockingTransaction.getEx();
return t.doSet(this, fn.applyTo(RT.cons(t.doGet(this), args)));
}

public void touch(){

LockingTransaction.getEx().doEnsure(this);
}

//*/
930 CHAPTER 8. JVM/CLOJURE/LANG/

boolean isBound(){
try
{
lock.readLock().lock();
return tvals != null;
}
finally
{
lock.readLock().unlock();
}
}

public void trimHistory(){

try
{
lock.writeLock().lock();
if(tvals != null)
{
tvals.next = tvals;
tvals.prior = tvals;
}
}
finally
{
lock.writeLock().unlock();
}
}

public int getHistoryCount(){

try
{
lock.writeLock().lock();
return histCount();
}
finally
{
lock.writeLock().unlock();
}
}

int histCount(){
if(tvals == null)
return 0;
else
{
int count = 0;
for(TVal tv = tvals.next;tv != tvals;tv = tv.next)
count++;
return count;
8.90. REF.JAVA 931

}
}

final public IFn fn(){

return (IFn) deref();
}

public Object call() throws Exception{

return invoke();
}

public void run(){

try
{
invoke();
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}

public Object invoke()

throws Exception{
return fn().invoke();
}

public Object invoke(Object arg1)

throws Exception{
return fn().invoke(arg1);
}

public Object invoke(Object arg1, Object arg2)

throws Exception{
return fn().invoke(arg1, arg2);
}

public Object invoke(Object arg1, Object arg2, Object arg3)

throws Exception{
return fn().invoke(arg1, arg2, arg3);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5)
932 CHAPTER 8. JVM/CLOJURE/LANG/

throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11);
8.90. REF.JAVA 933

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
934 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg16)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16,
arg17);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16,
arg17, arg18);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
8.91. REFLECTOR.JAVA 935

Object arg10, Object arg11, Object arg12,

Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19, Object arg20)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19, arg20);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

public Object applyTo(ISeq arglist) throws Exception{

return AFn.applyToHelper(this, arglist);
}

———-

8.91 Reflector.java

— Reflector.java —

\getchunk{Clojure Copyright}
/* rich Apr 19, 2006 */

package clojure.lang;

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Arrays;
936 CHAPTER 8. JVM/CLOJURE/LANG/

public class Reflector{

public static Object invokeInstanceMethod(Object target,

String methodName,
Object[] args)
throws Exception{
try
{
Class c = target.getClass();
List methods = getMethods(c, args.length, methodName, false);
return invokeMatchingMethod(methodName, methods, target, args);
}
catch(InvocationTargetException e)
{
if(e.getCause() instanceof Exception)
throw (Exception) e.getCause();
else if(e.getCause() instanceof Error)
throw (Error) e.getCause();
throw e;
}
}

private static String noMethodReport(String methodName, Object target){

return "No matching method found: " + methodName
+ (target==null?"":" for " + target.getClass());
}
static Object invokeMatchingMethod(String methodName,
List methods,
Object target,
Object[] args)
throws Exception{
Method m = null;
Object[] boxedArgs = null;
if(methods.isEmpty())
{
throw new IllegalArgumentException(
noMethodReport(methodName,target));
}
else if(methods.size() == 1)
{
m = (Method) methods.get(0);
boxedArgs = boxArgs(m.getParameterTypes(), args);
}
else //overloaded w/same arity
{
Method foundm = null;
for(Iterator i = methods.iterator(); i.hasNext();)
{
m = (Method) i.next();
8.91. REFLECTOR.JAVA 937

Class[] params = m.getParameterTypes();

if(isCongruent(params, args))
{
if(foundm == null ||
Compiler.subsumes(params,
foundm.getParameterTypes()))
{
foundm = m;
boxedArgs = boxArgs(params, args);
}
}
}
m = foundm;
}
if(m == null)
throw new IllegalArgumentException(
noMethodReport(methodName,target));

if(!Modifier.isPublic(m.getDeclaringClass().getModifiers()))
{
//public method of non-public class, try to find it in
//hierarchy
Method oldm = m;
m = getAsMethodOfPublicBase(m.getDeclaringClass(), m);
if(m == null)
throw new IllegalArgumentException(
"Can’t call public method of non-public class: " +
oldm.toString());
}
try
{
return prepRet(m.getReturnType(), m.invoke(target, boxedArgs));
}
catch(InvocationTargetException e)
{
if(e.getCause() instanceof Exception)
throw (Exception) e.getCause();
else if(e.getCause() instanceof Error)
throw (Error) e.getCause();
throw e;
}

public static Method getAsMethodOfPublicBase(Class c, Method m){

for(Class iface : c.getInterfaces())
{
for(Method im : iface.getMethods())
{
938 CHAPTER 8. JVM/CLOJURE/LANG/

if(im.getName().equals(m.getName())
&& Arrays.equals(m.getParameterTypes(),
im.getParameterTypes()))
{
return im;
}
}
}
Class sc = c.getSuperclass();
if(sc == null)
return null;
for(Method scm : sc.getMethods())
{
if(scm.getName().equals(m.getName())
&& Arrays.equals(m.getParameterTypes(),
scm.getParameterTypes())
&& Modifier.isPublic(scm.getDeclaringClass()
.getModifiers()))
{
return scm;
}
}
return getAsMethodOfPublicBase(sc, m);
}

public static Object invokeConstructor(Class c, Object[] args)

throws Exception{
try
{
Constructor[] allctors = c.getConstructors();
ArrayList ctors = new ArrayList();
for(int i = 0; i < allctors.length; i++)
{
Constructor ctor = allctors[i];
if(ctor.getParameterTypes().length == args.length)
ctors.add(ctor);
}
if(ctors.isEmpty())
{
throw new IllegalArgumentException("No matching ctor found"
+ " for " + c);
}
else if(ctors.size() == 1)
{
Constructor ctor = (Constructor) ctors.get(0);
return
ctor.newInstance(
boxArgs(ctor.getParameterTypes(), args));
}
else //overloaded w/same arity
8.91. REFLECTOR.JAVA 939

{
for(Iterator iterator = ctors.iterator();
iterator.hasNext();)
{
Constructor ctor = (Constructor) iterator.next();
Class[] params = ctor.getParameterTypes();
if(isCongruent(params, args))
{
Object[] boxedArgs = boxArgs(params, args);
return ctor.newInstance(boxedArgs);
}
}
throw new IllegalArgumentException("No matching ctor found"
+ " for " + c);
}
}
catch(InvocationTargetException e)
{
if(e.getCause() instanceof Exception)
throw (Exception) e.getCause();
else if(e.getCause() instanceof Error)
throw (Error) e.getCause();
throw e;
}
}

public static Object invokeStaticMethodVariadic(String className,

String methodName,
Object... args)
throws Exception{
return invokeStaticMethod(className, methodName, args);

public static Object invokeStaticMethod(String className,

String methodName,
Object[] args)
throws Exception{
Class c = RT.classForName(className);
try
{
return invokeStaticMethod(c, methodName, args);
}
catch(InvocationTargetException e)
{
if(e.getCause() instanceof Exception)
throw (Exception) e.getCause();
else if(e.getCause() instanceof Error)
throw (Error) e.getCause();
throw e;
940 CHAPTER 8. JVM/CLOJURE/LANG/

}
}

public static Object invokeStaticMethod(Class c,

String methodName,
Object[] args)
throws Exception{
if(methodName.equals("new"))
return invokeConstructor(c, args);
List methods = getMethods(c, args.length, methodName, true);
return invokeMatchingMethod(methodName, methods, null, args);
}

public static Object getStaticField(String className,

String fieldName)
throws Exception{
Class c = RT.classForName(className);
return getStaticField(c, fieldName);
}

public static Object getStaticField(Class c,

String fieldName)
throws Exception{
// if(fieldName.equals("class"))
// return c;
Field f = getField(c, fieldName, true);
if(f != null)
{
return prepRet(f.getType(), f.get(null));
}
throw new IllegalArgumentException(
"No matching field found: " + fieldName
+ " for " + c);
}

public static Object setStaticField(String className,

String fieldName,
Object val)
throws Exception{
Class c = RT.classForName(className);
return setStaticField(c, fieldName, val);
}

public static Object setStaticField(Class c,

String fieldName,
Object val)
throws Exception{
Field f = getField(c, fieldName, true);
if(f != null)
{
8.91. REFLECTOR.JAVA 941

f.set(null, boxArg(f.getType(), val));

return val;
}
throw new IllegalArgumentException(
"No matching field found: " + fieldName
+ " for " + c);
}

public static Object getInstanceField(Object target,

String fieldName)
throws Exception{
Class c = target.getClass();
Field f = getField(c, fieldName, false);
if(f != null)
{
return prepRet(f.getType(), f.get(target));
}
throw new IllegalArgumentException(
"No matching field found: " + fieldName
+ " for " + target.getClass());
}

public static Object setInstanceField(Object target,

String fieldName,
Object val)
throws Exception{
Class c = target.getClass();
Field f = getField(c, fieldName, false);
if(f != null)
{
f.set(target, boxArg(f.getType(), val));
return val;
}
throw new IllegalArgumentException(
"No matching field found: " + fieldName
+ " for " + target.getClass());
}

public static Object invokeNoArgInstanceMember(Object target,

String name)
throws Exception{
//favor method over field
List meths = getMethods(target.getClass(), 0, name, false);
if(meths.size() > 0)
return
invokeMatchingMethod(name, meths, target, RT.EMPTY_ARRAY);
else
return getInstanceField(target, name);
}
942 CHAPTER 8. JVM/CLOJURE/LANG/

public static Object invokeInstanceMember(Object target,

String name)
throws Exception{
//check for field first
Class c = target.getClass();
Field f = getField(c, name, false);
if(f != null) //field get
{
return prepRet(f.getType(), f.get(target));
}
return invokeInstanceMethod(target, name, RT.EMPTY_ARRAY);
}

public static Object invokeInstanceMember(String name,

Object target,
Object arg1)
throws Exception{
//check for field first
Class c = target.getClass();
Field f = getField(c, name, false);
if(f != null) //field set
{
f.set(target, boxArg(f.getType(), arg1));
return arg1;
}
return invokeInstanceMethod(target, name, new Object[]{arg1});
}

public static Object invokeInstanceMember(String name,

Object target,
Object... args)
throws Exception{
return invokeInstanceMethod(target, name, args);
}

static public Field getField(Class c,

String name,
boolean getStatics){
Field[] allfields = c.getFields();
for(int i = 0; i < allfields.length; i++)
{
if(name.equals(allfields[i].getName())
&& Modifier.isStatic(allfields[i].getModifiers())
== getStatics)
return allfields[i];
}
return null;
}
8.91. REFLECTOR.JAVA 943

static public List getMethods(Class c,

int arity,
String name,
boolean getStatics){
Method[] allmethods = c.getMethods();
ArrayList methods = new ArrayList();
ArrayList bridgeMethods = new ArrayList();
for(int i = 0; i < allmethods.length; i++)
{
Method method = allmethods[i];
if(name.equals(method.getName())
&& Modifier.isStatic(method.getModifiers()) == getStatics
&& method.getParameterTypes().length == arity)
{
try
{
if(method.isBridge()
&& c.getMethod(method.getName(),
method.getParameterTypes())
.equals(method))
bridgeMethods.add(method);
else
methods.add(method);
}
catch(NoSuchMethodException e)
{
}
}
// && (!method.isBridge()
// || (c == StringBuilder.class &&
// c.getMethod(method.getName(),
// method.getParameterTypes())
// .equals(method))))
// {
// methods.add(allmethods[i]);
// }
}

if(methods.isEmpty())
methods.addAll(bridgeMethods);

if(!getStatics && c.isInterface())

{
allmethods = Object.class.getMethods();
for(int i = 0; i < allmethods.length; i++)
{
if(name.equals(allmethods[i].getName())
&& Modifier.isStatic(allmethods[i].getModifiers())
== getStatics
&& allmethods[i].getParameterTypes().length == arity)
944 CHAPTER 8. JVM/CLOJURE/LANG/

{
methods.add(allmethods[i]);
}
}
}
return methods;
}

static Object boxArg(Class paramType, Object arg){

if(!paramType.isPrimitive())
return paramType.cast(arg);
else if(paramType == boolean.class)
return Boolean.class.cast(arg);
else if(paramType == char.class)
return Character.class.cast(arg);
else if(arg instanceof Number)
{
Number n = (Number) arg;
if(paramType == int.class)
return n.intValue();
else if(paramType == float.class)
return n.floatValue();
else if(paramType == double.class)
return n.doubleValue();
else if(paramType == long.class)
return n.longValue();
else if(paramType == short.class)
return n.shortValue();
else if(paramType == byte.class)
return n.byteValue();
}
throw new IllegalArgumentException(
"Unexpected param type, expected: " + paramType +
", given: " + arg.getClass().getName());
}

static Object[] boxArgs(Class[] params, Object[] args){

if(params.length == 0)
return null;
Object[] ret = new Object[params.length];
for(int i = 0; i < params.length; i++)
{
Object arg = args[i];
Class paramType = params[i];
ret[i] = boxArg(paramType, arg);
}
return ret;
}
8.91. REFLECTOR.JAVA 945

static public boolean paramArgTypeMatch(Class paramType,

Class argType){
if(argType == null)
return !paramType.isPrimitive();
if(paramType == argType || paramType.isAssignableFrom(argType))
return true;
if(paramType == int.class)
return argType == Integer.class
|| argType == long.class
|| argType == Long.class;// || argType==FixNum.class;
else if(paramType == float.class)
return argType == Float.class
|| argType == double.class;
else if(paramType == double.class)
return argType == Double.class
|| argType == float.class;
// || argType == DoubleNum.class;
else if(paramType == long.class)
return argType == Long.class
|| argType == int.class;
// || argType == BigNum.class;
else if(paramType == char.class)
return argType == Character.class;
else if(paramType == short.class)
return argType == Short.class;
else if(paramType == byte.class)
return argType == Byte.class;
else if(paramType == boolean.class)
return argType == Boolean.class;
return false;
}

static boolean isCongruent(Class[] params, Object[] args){

boolean ret = false;
if(args == null)
return params.length == 0;
if(params.length == args.length)
{
ret = true;
for(int i = 0; ret && i < params.length; i++)
{
Object arg = args[i];
Class argType = (arg == null) ? null : arg.getClass();
Class paramType = params[i];
ret = paramArgTypeMatch(paramType, argType);
}
}
return ret;
}
946 CHAPTER 8. JVM/CLOJURE/LANG/

public static Object prepRet(Class c, Object x){

if (!(c.isPrimitive() || c == Boolean.class))
return x;
if(x instanceof Boolean)
return ((Boolean) x)?Boolean.TRUE:Boolean.FALSE;
else if(x instanceof Integer)
{
return ((Integer)x).longValue();
}
else if(x instanceof Float)
return Double.valueOf(((Float) x).doubleValue());
return x;
}
}

———-

8.92 Repl.java

— Repl.java —

\getchunk{Clojure Copyright}
/* rich Oct 18, 2007 */

package clojure.lang;

import clojure.main;

public class Repl {

public static void main(String[] args) throws Exception{

main.legacy_repl(args);
}
}

———-

8.93 RestFn.java

— RestFn.java —

\getchunk{Clojure Copyright}
package clojure.lang;
8.93. RESTFN.JAVA 947

public abstract class RestFn extends AFunction{

abstract public int getRequiredArity();

protected Object doInvoke(Object args) throws Exception{

return null;
}

protected Object doInvoke(Object arg1, Object args) throws Exception{

return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object args) throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object args) throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object args) throws Except
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object args)
throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6,
throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6,
Object args) throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6,
Object arg8, Object args) throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6,
Object arg8, Object arg9, Object args) throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6,
948 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg8, Object arg9, Object arg10, Object args) throws Excepti
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Ob
Object arg8, Object arg9, Object arg10, Object arg11, Object args)
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Ob
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12,
throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Ob
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12,
Object arg14, Object args) throws Exception{
return null;
}

protected Object doInvoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6,
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg
Object arg14, Object arg15, Object arg16, Object arg17, Object arg18, Object a
Object args)
throws Exception{
return null;
}

public Object applyTo(ISeq args) throws Exception{

if(RT.boundedLength(args, getRequiredArity()) <= getRequiredArity())
{
return AFn.applyToHelper(this, Util.ret1(args,args = null));
}
switch(getRequiredArity())
{
case 0:
return doInvoke(Util.ret1(args,args = null));
case 1:
return doInvoke(args.first()
, Util.ret1(args.next(),args=null));
case 2:
return doInvoke(args.first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 3:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 4:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 5:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
950 CHAPTER 8. JVM/CLOJURE/LANG/

, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 6:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 7:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 8:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 9:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 10:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
8.93. RESTFN.JAVA 951

, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 11:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 12:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 13:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 14:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
952 CHAPTER 8. JVM/CLOJURE/LANG/

, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 15:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 16:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 17:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
8.93. RESTFN.JAVA 953

, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 18:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 19:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
954 CHAPTER 8. JVM/CLOJURE/LANG/

, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));
case 20:
return doInvoke(args.first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, (args = args.next()).first()
, Util.ret1(args.next(),args=null));

}
return throwArity(-1);
}

public Object invoke() throws Exception{

switch(getRequiredArity())
{
case 0:
return doInvoke(null);
default:
return throwArity(0);
}

public Object invoke(Object arg1) throws Exception{

switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(Util.ret1(arg1, arg1 = null)));
case 1:
return doInvoke(Util.ret1(arg1, arg1 = null), null);
8.93. RESTFN.JAVA 955

default:
return throwArity(1);
}

public Object invoke(Object arg1, Object arg2) throws Exception{

switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null)))
case 1:
return doInvoke(Util.ret1(arg1, arg1 = null), ArraySeq.create(Util.ret1(arg2, arg2 = null)))
case 2:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), null);
default:
return throwArity(2);
}

public Object invoke(Object arg1, Object arg2, Object arg3) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
Util.ret1(arg3, arg3 = null)));
case 1:
return doInvoke(Util.ret1(arg1, arg1 = null),
ArraySeq.create(Util.ret1(arg2, arg2 = null), Util.ret1(arg3, arg3 = null)))
case 2:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
ArraySeq.create(Util.ret1(arg3, arg3 = null)));
case 3:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.ret1(arg3,
null);
default:
return throwArity(3);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
Util.ret1(arg3, arg3 = null), Util.ret1(arg4, arg4 = null)))
case 1:
return doInvoke(Util.ret1(arg1, arg1 = null),
956 CHAPTER 8. JVM/CLOJURE/LANG/

ArraySeq.create(Util.ret1(arg2, arg2 = null), Util.ret1(arg3, arg

Util.ret1(arg4, arg4 = null)));
case 2:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
ArraySeq.create(Util.ret1(arg3, arg3 = null), Util.ret1(arg4, arg
case 3:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.
ArraySeq.create(Util.ret1(arg4, arg4 = null)));
case 4:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.
Util.ret1(arg4, arg4 = null), null);
default:
return throwArity(4);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) throws
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg
Util.ret1(arg3, arg3 = null), Util.ret1(arg4, arg
Util.ret1(arg5, arg5 = null)));
case 1:
return doInvoke(Util.ret1(arg1, arg1 = null),
ArraySeq.create(Util.ret1(arg2, arg2 = null), Util.ret1(arg3, arg
Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg
case 2:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
ArraySeq.create(Util.ret1(arg3, arg3 = null), Util.ret1(arg4, arg
Util.ret1(arg5, arg5 = null)));
case 3:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.
ArraySeq.create(Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg
case 4:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.
Util.ret1(arg4, arg4 = null), ArraySeq.create(Util.ret1(arg5, arg
case 5:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.
Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg5 = null), null)
default:
return throwArity(5);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
switch(getRequiredArity())
{
8.93. RESTFN.JAVA 957

case 0:
return doInvoke(ArraySeq.create(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
Util.ret1(arg3, arg3 = null), Util.ret1(arg4, arg4 = null),
Util.ret1(arg5, arg5 = null), Util.ret1(arg6, arg6 = null)))
case 1:
return doInvoke(Util.ret1(arg1, arg1 = null),
ArraySeq.create(Util.ret1(arg2, arg2 = null), Util.ret1(arg3, arg3 = null),
Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg5 = null),
Util.ret1(arg6, arg6 = null)));
case 2:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null),
ArraySeq.create(Util.ret1(arg3, arg3 = null), Util.ret1(arg4, arg4 = null),
Util.ret1(arg5, arg5 = null), Util.ret1(arg6, arg6 = null)))
case 3:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.ret1(arg3,
ArraySeq.create(Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg5 = null),
Util.ret1(arg6, arg6 = null)));
case 4:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.ret1(arg3,
Util.ret1(arg4, arg4 = null),
ArraySeq.create(Util.ret1(arg5, arg5 = null), Util.ret1(arg6, arg6 = null)))
case 5:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.ret1(arg3,
Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg5 = null),
ArraySeq.create(Util.ret1(arg6, arg6 = null)));
case 6:
return doInvoke(Util.ret1(arg1, arg1 = null), Util.ret1(arg2, arg2 = null), Util.ret1(arg3,
Util.ret1(arg4, arg4 = null), Util.ret1(arg5, arg5 = null), Util.ret1(arg6,
null);
default:
return throwArity(6);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Objec
throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7));
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7));
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7));
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7));
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7));
case 5:
958 CHAPTER 8. JVM/CLOJURE/LANG/

return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7));

case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, null);
default:
return throwArity(7);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
Object arg8) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8));
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8));
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8));
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8));
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8));
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7, arg8));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, ArraySeq.create(arg8));
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, null);
default:
return throwArity(8);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
Object arg8, Object arg9) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, a
case 3:
8.93. RESTFN.JAVA 959

return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, arg9));
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, arg9));
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8, arg9));
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7, arg8, arg9));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, ArraySeq.create(arg8, arg9));
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ArraySeq.create(arg9));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, null);
default:
return throwArity(9);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Objec
Object arg8, Object arg9, Object arg10) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, arg9, arg10)
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, arg9, arg10)
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8, arg9, arg10)
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7, arg8, arg9, arg10)
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, ArraySeq.create(arg8, arg9, arg10)
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ArraySeq.create(arg9, arg10)
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ArraySeq.create(arg10)
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, null);
default:
return throwArity(10);
}

}
960 CHAPTER 8. JVM/CLOJURE/LANG/

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
Object arg8, Object arg9, Object arg10, Object arg11) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, a
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, a
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, a
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8, a
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7, arg8, a
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, ArraySeq.create(arg8, a
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ArraySeq.create(a
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ArraySeq.cr
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, Arra
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
default:
return throwArity(11);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12) thro
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, a
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, a
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, a
case 5:
8.93. RESTFN.JAVA 961

return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8, arg9, arg10,
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7, arg8, arg9, arg10,
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, ArraySeq.create(arg8, arg9, arg10,
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ArraySeq.create(arg9, arg10,
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ArraySeq.create(arg10,
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ArraySeq.create
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ArraySeq
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, n
default:
return throwArity(12);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Objec
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13)
throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(
ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11,
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13));
case 2:
return doInvoke(arg1, arg2,
ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg1
case 3:
return doInvoke(arg1, arg2, arg3,
ArraySeq.create(arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg
case 4:
return doInvoke(arg1, arg2, arg3, arg4,
ArraySeq.create(arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5,
ArraySeq.create(arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10, arg11, arg12, arg13));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11, arg12, arg13));
962 CHAPTER 8. JVM/CLOJURE/LANG/

case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
ArraySeq.create(arg9, arg10, arg11, arg12, arg13));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
ArraySeq.create(arg10, arg11, arg12, arg13));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg12, arg13));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg13));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
default:
return throwArity(13);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Obje
throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
arg13, arg14));
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
arg13, arg14));
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, a
arg13, arg14));
case 3:
return doInvoke(arg1, arg2, arg3,
ArraySeq.create(arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11,
case 4:
return doInvoke(arg1, arg2, arg3, arg4,
ArraySeq.create(arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5,
ArraySeq.create(arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg1
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg
case 7:
8.93. RESTFN.JAVA 963

return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,

ArraySeq.create(arg8, arg9, arg10, arg11, arg12, arg13, arg14));
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
ArraySeq.create(arg9, arg10, arg11, arg12, arg13, arg14));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
ArraySeq.create(arg10, arg11, arg12, arg13, arg14));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13, arg14));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11,
ArraySeq.create(arg12, arg13, arg14));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
ArraySeq.create(arg13, arg14));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
ArraySeq.create(arg14));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
null);
default:
return throwArity(14);
}

return doInvoke(arg1, arg2, arg3, arg4, arg5,

ArraySeq.create(arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg1
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11, arg12, arg13, arg14, ar
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
ArraySeq.create(arg9, arg10, arg11, arg12, arg13, arg14, arg15));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
ArraySeq.create(arg10, arg11, arg12, arg13, arg14, arg15));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13, arg14, arg15));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg12, arg13, arg14, arg15));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg13, arg14, arg15));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg14, arg15));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg15));
case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
arg15, null);
default:
return throwArity(15);
}

return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16));
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16));
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16));
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5,
ArraySeq.create(arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, a
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
ArraySeq.create(arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
ArraySeq.create(arg10, arg11, arg12, arg13, arg14, arg15, arg16));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13, arg14, arg15, arg16));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11,
ArraySeq.create(arg12, arg13, arg14, arg15, arg16));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
ArraySeq.create(arg13, arg14, arg15, arg16));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
ArraySeq.create(arg14, arg15, arg16));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
ArraySeq.create(arg15, arg16));
case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
arg15, ArraySeq.create(arg16));
case 16:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
arg15, arg16, null);
default:
return throwArity(16);
}

}
966 CHAPTER 8. JVM/CLOJURE/LANG/

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Obje
Object arg15, Object arg16, Object arg17) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
arg13, arg14, arg15, arg16, arg17));
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, a
arg13, arg14, arg15, arg16, arg17));
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, a
arg13, arg14, arg15, arg16, arg17));
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, a
arg13, arg14, arg15, arg16, arg
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, a
arg13, arg14, arg15, arg1
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8, a
arg13, arg14, arg15
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11, arg12, arg13, arg14, ar
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
ArraySeq.create(arg9, arg10, arg11, arg12, arg13, arg14, arg15, a
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
ArraySeq.create(arg10, arg11, arg12, arg13, arg14, arg15, arg16,
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13, arg14, arg15, arg16, arg17))
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg12, arg13, arg14, arg15, arg16, arg17));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg13, arg14, arg15, arg16, arg17));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg14, arg15, arg16, arg17));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg15, arg16, arg17));
8.93. RESTFN.JAVA 967

case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
arg15, ArraySeq.create(arg16, arg17));
case 16:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
arg15, arg16, ArraySeq.create(arg17));
case 17:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, a
arg15, arg16, arg17, null);
default:
return throwArity(17);
}

public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Objec
Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, O
Object arg15, Object arg16, Object arg17, Object arg18) throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16, arg17, arg18));
case 1:
return doInvoke(arg1, ArraySeq.create(arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16, arg17, arg18));
case 2:
return doInvoke(arg1, arg2, ArraySeq.create(arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16, arg17, arg18));
case 3:
return doInvoke(arg1, arg2, arg3, ArraySeq.create(arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16, arg17, arg18))
case 4:
return doInvoke(arg1, arg2, arg3, arg4, ArraySeq.create(arg5, arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16, arg17, a
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5, ArraySeq.create(arg6, arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg16, ar
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, ArraySeq.create(arg7, arg8, arg9, arg10,
arg13, arg14, arg15, arg
arg18));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16,
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
ArraySeq.create(arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
968 CHAPTER 8. JVM/CLOJURE/LANG/

ArraySeq.create(arg10, arg11, arg12, arg13, arg14, arg15, arg16,

case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13, arg14, arg15, arg16, arg17,
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg12, arg13, arg14, arg15, arg16, arg17, arg18))
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg13, arg14, arg15, arg16, arg17, arg18));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg14, arg15, arg16, arg17, arg18));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
ArraySeq.create(arg15, arg16, arg17, arg18));
case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
arg15, ArraySeq.create(arg16, arg17, arg18));
case 16:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
arg15, arg16, ArraySeq.create(arg17, arg18));
case 17:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg1
arg15, arg16, arg17, ArraySeq.create(arg18));
case 18:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13, arg14,
arg15, arg16, arg17, arg18, null);
default:
return throwArity(18);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

case 1:
return doInvoke(arg1,
ArraySeq.create(arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19));
case 2:
return doInvoke(arg1, arg2,
ArraySeq.create(arg3, arg4, arg5, arg6,
arg7, arg8, arg9, arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17,
arg18, arg19));
case 3:
return doInvoke(arg1, arg2, arg3,
ArraySeq.create(arg4, arg5, arg6,
arg7, arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19));
case 4:
return doInvoke(arg1, arg2, arg3, arg4,
ArraySeq.create(arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
arg19));
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5,
ArraySeq.create(arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19));
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10,
arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16, arg17,
arg18, arg19));
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8,
ArraySeq.create(arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9,
ArraySeq.create(arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17,
970 CHAPTER 8. JVM/CLOJURE/LANG/

arg18, arg19));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
arg19));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11,
ArraySeq.create(arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12,
ArraySeq.create(arg13, arg14, arg15,
arg16, arg17, arg18, arg19));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
ArraySeq.create(arg14, arg15, arg16,
arg17, arg18, arg19));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14,
ArraySeq.create(arg15, arg16, arg17,
arg18, arg19));
case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15,
ArraySeq.create(arg16, arg17, arg18,
arg19));
case 16:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16,
ArraySeq.create(arg17, arg18, arg19));
case 17:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17,
ArraySeq.create(arg18, arg19));
case 18:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
ArraySeq.create(arg19));
case 19:
8.93. RESTFN.JAVA 971

return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,

arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18, arg19,
null);
default:
return throwArity(19);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19, Object arg20)
throws Exception{
switch(getRequiredArity())
{
case 0:
return doInvoke(ArraySeq.create(arg1, arg2, arg3, arg4,
arg5, arg6, arg7, arg8, arg9, arg10,
arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19, arg20));
case 1:
return doInvoke(arg1,
ArraySeq.create(arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19, arg20));
case 2:
return doInvoke(arg1, arg2,
ArraySeq.create(arg3, arg4, arg5, arg6,
arg7, arg8, arg9, arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 3:
return doInvoke(arg1, arg2, arg3,
ArraySeq.create(arg4, arg5, arg6,
arg7, arg8, arg9, arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 4:
return doInvoke(arg1, arg2, arg3, arg4,
ArraySeq.create(arg5, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19,
arg20));
case 5:
972 CHAPTER 8. JVM/CLOJURE/LANG/

return doInvoke(arg1, arg2, arg3, arg4, arg5,

ArraySeq.create(arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19,
arg20));
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ArraySeq.create(arg7, arg8, arg9, arg10,
arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19, arg20));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ArraySeq.create(arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8,
ArraySeq.create(arg9, arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17, arg18,
arg19, arg20));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9,
ArraySeq.create(arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10,
ArraySeq.create(arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
arg19, arg20));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11,
ArraySeq.create(arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19, arg20));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12,
ArraySeq.create(arg13, arg14, arg15,
arg16, arg17, arg18, arg19, arg20));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
ArraySeq.create(arg14, arg15, arg16,
arg17, arg18, arg19, arg20));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
8.93. RESTFN.JAVA 973

arg8, arg9, arg10, arg11, arg12, arg13,

arg14,
ArraySeq.create(arg15, arg16, arg17,
arg18, arg19, arg20));
case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15,
ArraySeq.create(arg16, arg17, arg18,
arg19, arg20));
case 16:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16,
ArraySeq.create(arg17, arg18, arg19,
arg20));
case 17:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17,
ArraySeq.create(arg18, arg19, arg20));
case 18:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
ArraySeq.create(arg19, arg20));
case 19:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18, arg19,
ArraySeq.create(arg20));
case 20:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18, arg19,
arg20, null);
default:
return throwArity(20);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

switch(getRequiredArity())
{
case 0:
return doInvoke(
ontoArrayPrepend(args, arg1, arg2, arg3,
arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19, arg20));
case 1:
return doInvoke(arg1,
ontoArrayPrepend(args, arg2, arg3, arg4,
arg5, arg6, arg7, arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 2:
return doInvoke(arg1, arg2,
ontoArrayPrepend(args, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19, arg20));
case 3:
return doInvoke(arg1, arg2, arg3,
ontoArrayPrepend(args, arg4, arg5, arg6,
arg7, arg8, arg9, arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 4:
return doInvoke(arg1, arg2, arg3, arg4,
ontoArrayPrepend(args, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
arg19, arg20));
case 5:
return doInvoke(arg1, arg2, arg3, arg4, arg5,
ontoArrayPrepend(args, arg6, arg7, arg8,
arg9, arg10, arg11, arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19,
arg20));
case 6:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6,
ontoArrayPrepend(args, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19, arg20));
case 7:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
ontoArrayPrepend(args, arg8, arg9, arg10,
arg11, arg12, arg13, arg14, arg15, arg16,
arg17, arg18, arg19, arg20));
case 8:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
8.93. RESTFN.JAVA 975

arg8,
ontoArrayPrepend(args, arg9, arg10, arg11,
arg12, arg13, arg14, arg15, arg16, arg17,
arg18, arg19, arg20));
case 9:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9,
ontoArrayPrepend(args, arg10, arg11, arg12,
arg13, arg14, arg15, arg16, arg17, arg18,
arg19, arg20));
case 10:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10,
ontoArrayPrepend(args, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18, arg19,
arg20));
case 11:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11,
ontoArrayPrepend(args, arg12, arg13, arg14,
arg15, arg16, arg17, arg18, arg19, arg20));
case 12:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12,
ontoArrayPrepend(args, arg13, arg14, arg15,
arg16, arg17, arg18, arg19, arg20));
case 13:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
ontoArrayPrepend(args, arg14, arg15, arg16,
arg17, arg18, arg19, arg20));
case 14:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14,
ontoArrayPrepend(args, arg15, arg16, arg17,
arg18, arg19, arg20));
case 15:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15,
ontoArrayPrepend(args, arg16, arg17, arg18,
arg19, arg20));
case 16:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16,
ontoArrayPrepend(args, arg17, arg18, arg19,
arg20));
case 17:
976 CHAPTER 8. JVM/CLOJURE/LANG/

return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,

arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17,
ontoArrayPrepend(args, arg18, arg19,
arg20));
case 18:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18,
ontoArrayPrepend(args, arg19, arg20));
case 19:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14, arg15, arg16, arg17, arg18, arg19,
ontoArrayPrepend(args, arg20));
case 20:
return doInvoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
arg8, arg9, arg10, arg11, arg12, arg13,
arg14,arg15, arg16, arg17, arg18, arg19,
arg20, ArraySeq.create(args));
default:
return throwArity(21);
}

protected static ISeq ontoArrayPrepend(Object[] array,

Object... args){
ISeq ret = ArraySeq.create(array);
for(int i = args.length - 1; i >= 0; --i)
ret = RT.cons(args[i], ret);
return ret;
}

protected static ISeq findKey(Object key, ISeq args){

while(args != null)
{
if(key == args.first())
return args.next();
args = RT.next(args);
args = RT.next(args);
}
return null;
}

}
8.94. REVERSIBLE.JAVA 977

———-

8.94 Reversible.java

— Reversible.java —

\getchunk{Clojure Copyright}
/* rich Jan 5, 2008 */

package clojure.lang;

public interface Reversible{

ISeq rseq() throws Exception;
}

———-

8.95 RT.java

— RT.java —

\getchunk{Clojure Copyright}
/* rich Mar 25, 2006 4:28:27 PM */

package clojure.lang;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.Callable;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.net.URL;
import java.net.JarURLConnection;
import java.nio.charset.Charset;

public class RT{

static final public Boolean T =

978 CHAPTER 8. JVM/CLOJURE/LANG/

Boolean.TRUE;//Keyword.intern(Symbol.intern(null, "t"));
static final public Boolean F =
Boolean.FALSE;//Keyword.intern(Symbol.intern(null, "t"));
static final public String LOADER_SUFFIX = "__init";

//simple-symbol->class
final static IPersistentMap DEFAULT_IMPORTS = map(
// Symbol.intern("RT"), "clojure.lang.RT",
// Symbol.intern("Num"), "clojure.lang.Num",
// Symbol.intern("Symbol"), "clojure.lang.Symbol",
// Symbol.intern("Keyword"), "clojure.lang.Keyword",
// Symbol.intern("Var"), "clojure.lang.Var",
// Symbol.intern("Ref"), "clojure.lang.Ref",
// Symbol.intern("IFn"), "clojure.lang.IFn",
// Symbol.intern("IObj"), "clojure.lang.IObj",
// Symbol.intern("ISeq"), "clojure.lang.ISeq",
// Symbol.intern("IPersistentCollection"),
// "clojure.lang.IPersistentCollection",
// Symbol.intern("IPersistentMap"), "clojure.lang.IPersistentMap",
// Symbol.intern("IPersistentList"), "clojure.lang.IPersistentList",
// Symbol.intern("IPersistentVector"), "clojure.lang.IPersistentVector",
Symbol.intern("Boolean"), Boolean.class,
Symbol.intern("Byte"), Byte.class,
Symbol.intern("Character"), Character.class,
Symbol.intern("Class"), Class.class,
Symbol.intern("ClassLoader"), ClassLoader.class,
Symbol.intern("Compiler"), Compiler.class,
Symbol.intern("Double"), Double.class,
Symbol.intern("Enum"), Enum.class,
Symbol.intern("Float"), Float.class,
Symbol.intern("InheritableThreadLocal"), InheritableThreadLocal.class,
Symbol.intern("Integer"), Integer.class,
Symbol.intern("Long"), Long.class,
Symbol.intern("Math"), Math.class,
Symbol.intern("Number"), Number.class,
Symbol.intern("Object"), Object.class,
Symbol.intern("Package"), Package.class,
Symbol.intern("Process"), Process.class,
Symbol.intern("ProcessBuilder"), ProcessBuilder.class,
Symbol.intern("Runtime"), Runtime.class,
Symbol.intern("RuntimePermission"), RuntimePermission.class,
Symbol.intern("SecurityManager"), SecurityManager.class,
Symbol.intern("Short"), Short.class,
Symbol.intern("StackTraceElement"), StackTraceElement.class,
Symbol.intern("StrictMath"), StrictMath.class,
Symbol.intern("String"), String.class,
Symbol.intern("StringBuffer"), StringBuffer.class,
Symbol.intern("StringBuilder"), StringBuilder.class,
Symbol.intern("System"), System.class,
Symbol.intern("Thread"), Thread.class,
8.95. RT.JAVA 979

Symbol.intern("ThreadGroup"), ThreadGroup.class,
Symbol.intern("ThreadLocal"), ThreadLocal.class,
Symbol.intern("Throwable"), Throwable.class,
Symbol.intern("Void"), Void.class,
Symbol.intern("Appendable"), Appendable.class,
Symbol.intern("CharSequence"), CharSequence.class,
Symbol.intern("Cloneable"), Cloneable.class,
Symbol.intern("Comparable"), Comparable.class,
Symbol.intern("Iterable"), Iterable.class,
Symbol.intern("Readable"), Readable.class,
Symbol.intern("Runnable"), Runnable.class,
Symbol.intern("Callable"), Callable.class,
Symbol.intern("BigInteger"), BigInteger.class,
Symbol.intern("BigDecimal"), BigDecimal.class,
Symbol.intern("ArithmeticException"), ArithmeticException.class,
Symbol.intern("ArrayIndexOutOfBoundsException"),
ArrayIndexOutOfBoundsException.class,
Symbol.intern("ArrayStoreException"), ArrayStoreException.class,
Symbol.intern("ClassCastException"), ClassCastException.class,
Symbol.intern("ClassNotFoundException"), ClassNotFoundException.class,
Symbol.intern("CloneNotSupportedException"),
CloneNotSupportedException.class,
Symbol.intern("EnumConstantNotPresentException"),
EnumConstantNotPresentException.class,
Symbol.intern("Exception"), Exception.class,
Symbol.intern("IllegalAccessException"), IllegalAccessException.class,
Symbol.intern("IllegalArgumentException"),
IllegalArgumentException.class,
Symbol.intern("IllegalMonitorStateException"),
IllegalMonitorStateException.class,
Symbol.intern("IllegalStateException"), IllegalStateException.class,
Symbol.intern("IllegalThreadStateException"),
IllegalThreadStateException.class,
Symbol.intern("IndexOutOfBoundsException"),
IndexOutOfBoundsException.class,
Symbol.intern("InstantiationException"), InstantiationException.class,
Symbol.intern("InterruptedException"), InterruptedException.class,
Symbol.intern("NegativeArraySizeException"),
NegativeArraySizeException.class,
Symbol.intern("NoSuchFieldException"), NoSuchFieldException.class,
Symbol.intern("NoSuchMethodException"), NoSuchMethodException.class,
Symbol.intern("NullPointerException"), NullPointerException.class,
Symbol.intern("NumberFormatException"), NumberFormatException.class,
Symbol.intern("RuntimeException"), RuntimeException.class,
Symbol.intern("SecurityException"), SecurityException.class,
Symbol.intern("StringIndexOutOfBoundsException"),
StringIndexOutOfBoundsException.class,
Symbol.intern("TypeNotPresentException"),
TypeNotPresentException.class,
Symbol.intern("UnsupportedOperationException"),
980 CHAPTER 8. JVM/CLOJURE/LANG/

UnsupportedOperationException.class,
Symbol.intern("AbstractMethodError"), AbstractMethodError.class,
Symbol.intern("AssertionError"), AssertionError.class,
Symbol.intern("ClassCircularityError"), ClassCircularityError.class,
Symbol.intern("ClassFormatError"), ClassFormatError.class,
Symbol.intern("Error"), Error.class,
Symbol.intern("ExceptionInInitializerError"),
ExceptionInInitializerError.class,
Symbol.intern("IllegalAccessError"), IllegalAccessError.class,
Symbol.intern("IncompatibleClassChangeError"),
IncompatibleClassChangeError.class,
Symbol.intern("InstantiationError"), InstantiationError.class,
Symbol.intern("InternalError"), InternalError.class,
Symbol.intern("LinkageError"), LinkageError.class,
Symbol.intern("NoClassDefFoundError"), NoClassDefFoundError.class,
Symbol.intern("NoSuchFieldError"), NoSuchFieldError.class,
Symbol.intern("NoSuchMethodError"), NoSuchMethodError.class,
Symbol.intern("OutOfMemoryError"), OutOfMemoryError.class,
Symbol.intern("StackOverflowError"), StackOverflowError.class,
Symbol.intern("ThreadDeath"), ThreadDeath.class,
Symbol.intern("UnknownError"), UnknownError.class,
Symbol.intern("UnsatisfiedLinkError"), UnsatisfiedLinkError.class,
Symbol.intern("UnsupportedClassVersionError"),
UnsupportedClassVersionError.class,
Symbol.intern("VerifyError"), VerifyError.class,
Symbol.intern("VirtualMachineError"), VirtualMachineError.class,
Symbol.intern("Thread$UncaughtExceptionHandler"),
Thread.UncaughtExceptionHandler.class,
Symbol.intern("Thread$State"), Thread.State.class,
Symbol.intern("Deprecated"), Deprecated.class,
Symbol.intern("Override"), Override.class,
Symbol.intern("SuppressWarnings"), SuppressWarnings.class

// Symbol.intern("Collection"), "java.util.Collection",
// Symbol.intern("Comparator"), "java.util.Comparator",
// Symbol.intern("Enumeration"), "java.util.Enumeration",
// Symbol.intern("EventListener"), "java.util.EventListener",
// Symbol.intern("Formattable"), "java.util.Formattable",
// Symbol.intern("Iterator"), "java.util.Iterator",
// Symbol.intern("List"), "java.util.List",
// Symbol.intern("ListIterator"), "java.util.ListIterator",
// Symbol.intern("Map"), "java.util.Map",
// Symbol.intern("Map$Entry"), "java.util.Map$Entry",
// Symbol.intern("Observer"), "java.util.Observer",
// Symbol.intern("Queue"), "java.util.Queue",
// Symbol.intern("RandomAccess"), "java.util.RandomAccess",
// Symbol.intern("Set"), "java.util.Set",
// Symbol.intern("SortedMap"), "java.util.SortedMap",
// Symbol.intern("SortedSet"), "java.util.SortedSet"
);
8.95. RT.JAVA 981

// single instance of UTF-8 Charset, so as to avoid

// catching UnsupportedCharsetExceptions everywhere
static public Charset UTF8 = Charset.forName("UTF-8");

static public final Namespace CLOJURE_NS =

Namespace.findOrCreate(Symbol.intern("clojure.core"));
//static final Namespace USER_NS =
// Namespace.findOrCreate(Symbol.intern("user"));
final static public Var OUT =
Var.intern(CLOJURE_NS, Symbol.intern("*out*"),
new OutputStreamWriter(System.out))
.setDynamic();
final static public Var IN =
Var.intern(CLOJURE_NS, Symbol.intern("*in*"),
new LineNumberingPushbackReader(
new InputStreamReader(System.in)))
.setDynamic();
final static public Var ERR =
Var.intern(CLOJURE_NS, Symbol.intern("*err*"),
new PrintWriter(
new OutputStreamWriter(System.err), true))
.setDynamic();
final static Keyword TAG_KEY = Keyword.intern(null, "tag");
final static public Var AGENT =
Var.intern(CLOJURE_NS, Symbol.intern("*agent*"), null)
.setDynamic();
final static public Var READEVAL =
Var.intern(CLOJURE_NS, Symbol.intern("*read-eval*"), T)
.setDynamic();
final static public Var ASSERT =
Var.intern(CLOJURE_NS, Symbol.intern("*assert*"), T)
.setDynamic();
final static public Var MATH_CONTEXT =
Var.intern(CLOJURE_NS, Symbol.intern("*math-context*"), null)
.setDynamic();
static Keyword LINE_KEY = Keyword.intern(null, "line");
static Keyword FILE_KEY = Keyword.intern(null, "file");
static Keyword DECLARED_KEY = Keyword.intern(null, "declared");
static Keyword DOC_KEY = Keyword.intern(null, "doc");
final static public Var USE_CONTEXT_CLASSLOADER =
Var.intern(CLOJURE_NS,
Symbol.intern("*use-context-classloader*"), T)
.setDynamic();
//final static public Var CURRENT_MODULE =
// Var.intern(Symbol.intern("clojure.core", "current-module"),
// Module.findOrCreateModule("clojure/user"));

final static Symbol LOAD_FILE = Symbol.intern("load-file");

final static Symbol IN_NAMESPACE = Symbol.intern("in-ns");
982 CHAPTER 8. JVM/CLOJURE/LANG/

final static Symbol NAMESPACE = Symbol.intern("ns");

static final Symbol IDENTICAL = Symbol.intern("identical?");
final static Var CMD_LINE_ARGS =
Var.intern(CLOJURE_NS,
Symbol.intern("*command-line-args*"), null)
.setDynamic();
//symbol
final public static Var CURRENT_NS =
Var.intern(CLOJURE_NS, Symbol.intern("*ns*"), CLOJURE_NS)
.setDynamic();

final static Var FLUSH_ON_NEWLINE =

Var.intern(CLOJURE_NS, Symbol.intern("*flush-on-newline*"), T)
.setDynamic();
final static Var PRINT_META =
Var.intern(CLOJURE_NS, Symbol.intern("*print-meta*"), F)
.setDynamic();
final static Var PRINT_READABLY =
Var.intern(CLOJURE_NS, Symbol.intern("*print-readably*"), T)
.setDynamic();
final static Var PRINT_DUP =
Var.intern(CLOJURE_NS, Symbol.intern("*print-dup*"), F)
.setDynamic();
final static Var WARN_ON_REFLECTION =
Var.intern(CLOJURE_NS, Symbol.intern("*warn-on-reflection*"), F)
.setDynamic();
final static Var ALLOW_UNRESOLVED_VARS =
Var.intern(CLOJURE_NS,
Symbol.intern("*allow-unresolved-vars*"), F)
.setDynamic();

final static Var IN_NS_VAR =

Var.intern(CLOJURE_NS, Symbol.intern("in-ns"), F);
final static Var NS_VAR =
Var.intern(CLOJURE_NS, Symbol.intern("ns"), F);
static final Var PRINT_INITIALIZED =
Var.intern(CLOJURE_NS, Symbol.intern("print-initialized"));
static final Var PR_ON =
Var.intern(CLOJURE_NS, Symbol.intern("pr-on"));
//final static Var IMPORTS =
// Var.intern(CLOJURE_NS, Symbol.intern("*imports*"),
// DEFAULT_IMPORTS);
final static IFn inNamespace = new AFn(){
public Object invoke(Object arg1) throws Exception{
Symbol nsname = (Symbol) arg1;
Namespace ns = Namespace.findOrCreate(nsname);
CURRENT_NS.set(ns);
return ns;
}
};
8.95. RT.JAVA 983

final static IFn bootNamespace = new AFn(){

public Object invoke(Object __form,
Object __env,Object arg1)
throws Exception{
Symbol nsname = (Symbol) arg1;
Namespace ns = Namespace.findOrCreate(nsname);
CURRENT_NS.set(ns);
return ns;
}
};

public static List<String> processCommandLine(String[] args){

List<String> arglist = Arrays.asList(args);
int split = arglist.indexOf("--");
if(split >= 0) {
CMD_LINE_ARGS.bindRoot(
RT.seq(arglist.subList(split + 1, args.length)));
return arglist.subList(0, split);
}
return arglist;
}

// duck typing stderr plays nice with e.g. swank

public static PrintWriter errPrintWriter(){
Writer w = (Writer) ERR.deref();
if (w instanceof PrintWriter) {
return (PrintWriter) w;
} else {
return new PrintWriter(w);
}
}

static public final Object[] EMPTY_ARRAY = new Object[]{};

static public final Comparator DEFAULT_COMPARATOR =
new DefaultComparator();

private static final class DefaultComparator

implements Comparator, Serializable {
public int compare(Object o1, Object o2){
return Util.compare(o1, o2);
}

private Object readResolve() throws ObjectStreamException {

// ensures that we aren’t hanging onto a new default
// comparator for every sorted set, etc., we deserialize
return DEFAULT_COMPARATOR;
}
}
984 CHAPTER 8. JVM/CLOJURE/LANG/

static AtomicInteger id = new AtomicInteger(1);

static public void addURL(Object url) throws Exception{

URL u =
(url instanceof String) ? (new URL((String) url)) : (URL) url;
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
if(ccl instanceof DynamicClassLoader)
((DynamicClassLoader)ccl).addURL(u);
else
throw new IllegalAccessError(
"Context classloader is not a DynamicClassLoader");
}

static{
Keyword arglistskw = Keyword.intern(null, "arglists");
Symbol namesym = Symbol.intern("name");
OUT.setTag(Symbol.intern("java.io.Writer"));
CURRENT_NS.setTag(Symbol.intern("clojure.lang.Namespace"));
AGENT.setMeta(map(DOC_KEY,
"The agent currently running an action on "+
"this thread, else nil"));
AGENT.setTag(Symbol.intern("clojure.lang.Agent"));
MATH_CONTEXT.setTag(Symbol.intern("java.math.MathContext"));
Var nv = Var.intern(CLOJURE_NS, NAMESPACE, bootNamespace);
nv.setMacro();
Var v;
v = Var.intern(CLOJURE_NS, IN_NAMESPACE, inNamespace);
v.setMeta(map(DOC_KEY,
"Sets *ns* to the namespace named by the symbol, "+
"creating it if needed.",
arglistskw, list(vector(namesym))));
v = Var.intern(CLOJURE_NS, LOAD_FILE,
new AFn(){
public Object invoke(Object arg1) throws Exception{
return Compiler.loadFile((String) arg1);
}
});
v.setMeta(map(DOC_KEY,
"Sequentially read and evaluate the set of "+
"forms contained in the file.",
arglistskw, list(vector(namesym))));
try {
doInit();
}
catch(Exception e) {
throw new RuntimeException(e);
}
}
8.95. RT.JAVA 985

static public Var var(String ns, String name){

return Var.intern(Namespace.findOrCreate(Symbol.intern(null, ns)), Symbol.intern(null, name));
}

static public Var var(String ns, String name, Object init){

return
Var.intern(
Namespace.findOrCreate(Symbol.intern(null, ns)),
Symbol.intern(null, name), init);
}

public static void loadResourceScript(String name)

throws Exception{
loadResourceScript(name, true);
}

public static void maybeLoadResourceScript(String name)

throws Exception{
loadResourceScript(name, false);
}

public static void loadResourceScript(String name,

boolean failIfNotFound)
throws Exception{
loadResourceScript(RT.class, name, failIfNotFound);
}

public static void loadResourceScript(Class c, String name)

throws Exception{
loadResourceScript(c, name, true);
}

public static void loadResourceScript(Class c,

String name,
boolean failIfNotFound)
throws Exception{
int slash = name.lastIndexOf(’/’);
String file = slash >= 0 ? name.substring(slash + 1) : name;
InputStream ins = baseLoader().getResourceAsStream(name);
if(ins != null) {
try {
Compiler.load(new InputStreamReader(ins, UTF8), name, file);
}
finally {
ins.close();
}
}
else if(failIfNotFound) {
throw new FileNotFoundException(
"Could not locate Clojure resource on classpath: " + name);
986 CHAPTER 8. JVM/CLOJURE/LANG/

}
}

static public void init() throws Exception{

RT.errPrintWriter().println(
"No need to call RT.init() anymore");
}

static public long lastModified(URL url, String libfile)

throws Exception{
if(url.getProtocol().equals("jar")) {
return
((JarURLConnection) url.openConnection())
.getJarFile()
.getEntry(libfile)
.getTime();
}
else {
return url.openConnection().getLastModified();
}
}

static void compile(String cljfile) throws Exception{

InputStream ins = baseLoader().getResourceAsStream(cljfile);
if(ins != null) {
try {
Compiler.compile(
new InputStreamReader(ins, UTF8), cljfile,
cljfile.substring(1 + cljfile.lastIndexOf("/")));
}
finally {
ins.close();
}

}
else
throw new FileNotFoundException(
"Could not locate Clojure resource on classpath: " + cljfile);
}

static public void load(String scriptbase) throws Exception{

load(scriptbase, true);
}

static public void load(String scriptbase, boolean failIfNotFound)

throws Exception{
String classfile = scriptbase + LOADER_SUFFIX + ".class";
String cljfile = scriptbase + ".clj";
URL classURL = baseLoader().getResource(classfile);
URL cljURL = baseLoader().getResource(cljfile);
8.95. RT.JAVA 987

boolean loaded = false;

if((classURL != null &&

(cljURL == null
|| lastModified(classURL, classfile) >
lastModified(cljURL, cljfile)))
|| classURL == null) {
try {
Var.pushThreadBindings(
RT.map(CURRENT_NS, CURRENT_NS.deref(),
WARN_ON_REFLECTION, WARN_ON_REFLECTION.deref()));
loaded =
(loadClassForName(scriptbase.replace(’/’, ’.’) +
LOADER_SUFFIX) != null);
}
finally {
Var.popThreadBindings();
}
}
if(!loaded && cljURL != null) {
if(booleanCast(Compiler.COMPILE_FILES.deref()))
compile(cljfile);
else
loadResourceScript(RT.class, cljfile);
}
else if(!loaded && failIfNotFound)
throw new FileNotFoundException(String.format(
"Could not locate %s or %s on classpath: ",
classfile, cljfile));
}

static void doInit() throws Exception{

load("clojure/core");

Var.pushThreadBindings(
RT.map(CURRENT_NS, CURRENT_NS.deref(),
WARN_ON_REFLECTION, WARN_ON_REFLECTION.deref()));
try {
Symbol USER = Symbol.intern("user");
Symbol CLOJURE = Symbol.intern("clojure.core");

Var in_ns = var("clojure.core", "in-ns");

Var refer = var("clojure.core", "refer");
in_ns.invoke(USER);
refer.invoke(CLOJURE);
maybeLoadResourceScript("user.clj");
}
finally {
Var.popThreadBindings();
}
988 CHAPTER 8. JVM/CLOJURE/LANG/

static public int nextID(){

return id.getAndIncrement();
}

////////////// Collections support /////////////////////////////////

static public ISeq seq(Object coll){

if(coll instanceof ASeq)
return (ASeq) coll;
else if(coll instanceof LazySeq)
return ((LazySeq) coll).seq();
else
return seqFrom(coll);
}

static ISeq seqFrom(Object coll){

if(coll instanceof Seqable)
return ((Seqable) coll).seq();
else if(coll == null)
return null;
else if(coll instanceof Iterable)
return IteratorSeq.create(((Iterable) coll).iterator());
else if(coll.getClass().isArray())
return ArraySeq.createFromObject(coll);
else if(coll instanceof CharSequence)
return StringSeq.create((CharSequence) coll);
else if(coll instanceof Map)
return seq(((Map) coll).entrySet());
else {
Class c = coll.getClass();
Class sc = c.getSuperclass();
throw new IllegalArgumentException(
"Don’t know how to create ISeq from: " + c.getName());
}
}

static public ISeq keys(Object coll){

return APersistentMap.KeySeq.create(seq(coll));
}

static public ISeq vals(Object coll){

return APersistentMap.ValSeq.create(seq(coll));
}

static public IPersistentMap meta(Object x){

if(x instanceof IMeta)
return ((IMeta) x).meta();
8.95. RT.JAVA 989

return null;
}

public static int count(Object o){

if(o instanceof Counted)
return ((Counted) o).count();
return countFrom(Util.ret1(o, o = null));
}

static int countFrom(Object o){

if(o == null)
return 0;
else if(o instanceof IPersistentCollection) {
ISeq s = seq(o);
o = null;
int i = 0;
for(; s != null; s = s.next()) {
if(s instanceof Counted)
return i + s.count();
i++;
}
return i;
}
else if(o instanceof CharSequence)
return ((CharSequence) o).length();
else if(o instanceof Collection)
return ((Collection) o).size();
else if(o instanceof Map)
return ((Map) o).size();
else if(o.getClass().isArray())
return Array.getLength(o);

throw new UnsupportedOperationException(

"count not supported on this type: " +
o.getClass().getSimpleName());
}

static public IPersistentCollection conj(IPersistentCollection coll,

Object x){
if(coll == null)
return new PersistentList(x);
return coll.cons(x);
}

static public ISeq cons(Object x, Object coll){

//ISeq y = seq(coll);
if(coll == null)
return new PersistentList(x);
else if(coll instanceof ISeq)
return new Cons(x, (ISeq) coll);
990 CHAPTER 8. JVM/CLOJURE/LANG/

else
return new Cons(x, seq(coll));
}

static public Object first(Object x){

if(x instanceof ISeq)
return ((ISeq) x).first();
ISeq seq = seq(x);
if(seq == null)
return null;
return seq.first();
}

static public Object second(Object x){

return first(next(x));
}

static public Object third(Object x){

return first(next(next(x)));
}

static public Object fourth(Object x){

return first(next(next(next(x))));
}

static public ISeq next(Object x){

if(x instanceof ISeq)
return ((ISeq) x).next();
ISeq seq = seq(x);
if(seq == null)
return null;
return seq.next();
}

static public ISeq more(Object x){

if(x instanceof ISeq)
return ((ISeq) x).more();
ISeq seq = seq(x);
if(seq == null)
return PersistentList.EMPTY;
return seq.more();
}

//static public Seqable more(Object x){

// Seqable ret = null;
// if(x instanceof ISeq)
// ret = ((ISeq) x).more();
// else
// {
// ISeq seq = seq(x);
8.95. RT.JAVA 991

// if(seq == null)
// ret = PersistentList.EMPTY;
// else
// ret = seq.more();
// }
// if(ret == null)
// ret = PersistentList.EMPTY;
// return ret;
//}

static public Object peek(Object x){

if(x == null)
return null;
return ((IPersistentStack) x).peek();
}

static public Object pop(Object x){

if(x == null)
return null;
return ((IPersistentStack) x).pop();
}

static public Object get(Object coll, Object key){

if(coll instanceof ILookup)
return ((ILookup) coll).valAt(key);
return getFrom(coll, key);
}

static Object getFrom(Object coll, Object key){

if(coll == null)
return null;
else if(coll instanceof Map) {
Map m = (Map) coll;
return m.get(key);
}
else if(coll instanceof IPersistentSet) {
IPersistentSet set = (IPersistentSet) coll;
return set.get(key);
}
else if(key instanceof Number &&
(coll instanceof String ||
coll.getClass().isArray())) {
int n = ((Number) key).intValue();
if(n >= 0 && n < count(coll))
return nth(coll, n);
return null;
}

return null;
}
992 CHAPTER 8. JVM/CLOJURE/LANG/

static public Object get(Object coll, Object key, Object notFound){

if(coll instanceof ILookup)
return ((ILookup) coll).valAt(key, notFound);
return getFrom(coll, key, notFound);
}

static Object getFrom(Object coll, Object key, Object notFound){

if(coll == null)
return notFound;
else if(coll instanceof Map) {
Map m = (Map) coll;
if(m.containsKey(key))
return m.get(key);
return notFound;
}
else if(coll instanceof IPersistentSet) {
IPersistentSet set = (IPersistentSet) coll;
if(set.contains(key))
return set.get(key);
return notFound;
}
else if(key instanceof Number &&
(coll instanceof String ||
coll.getClass().isArray())) {
int n = ((Number) key).intValue();
return n >= 0 && n < count(coll) ? nth(coll, n) : notFound;
}
return notFound;

static public Associative assoc(Object coll, Object key, Object val){

if(coll == null)
return new PersistentArrayMap(new Object[]{key, val});
return ((Associative) coll).assoc(key, val);
}

static public Object contains(Object coll, Object key){

if(coll == null)
return F;
else if(coll instanceof Associative)
return ((Associative) coll).containsKey(key) ? T : F;
else if(coll instanceof IPersistentSet)
return ((IPersistentSet) coll).contains(key) ? T : F;
else if(coll instanceof Map) {
Map m = (Map) coll;
return m.containsKey(key) ? T : F;
}
else if(key instanceof Number &&
8.95. RT.JAVA 993

(coll instanceof String ||

coll.getClass().isArray())) {
int n = ((Number) key).intValue();
return n >= 0 && n < count(coll);
}
return F;
}

static public Object find(Object coll, Object key){

if(coll == null)
return null;
else if(coll instanceof Associative)
return ((Associative) coll).entryAt(key);
else {
Map m = (Map) coll;
if(m.containsKey(key))
return new MapEntry(key, m.get(key));
return null;
}
}

//takes a seq of key,val,key,val

//returns tail starting at val of matching key if found, else null

static public ISeq findKey(Keyword key, ISeq keyvals)
throws Exception{
while(keyvals != null) {
ISeq r = keyvals.next();
if(r == null)
throw new Exception("Malformed keyword argslist");
if(keyvals.first() == key)
return r;
keyvals = r.next();
}
return null;
}

static public Object dissoc(Object coll, Object key)

throws Exception{
if(coll == null)
return null;
return ((IPersistentMap) coll).without(key);
}

static public Object nth(Object coll, int n){

if(coll instanceof Indexed)
return ((Indexed) coll).nth(n);
return nthFrom(Util.ret1(coll, coll = null), n);
}
994 CHAPTER 8. JVM/CLOJURE/LANG/

static Object nthFrom(Object coll, int n){

if(coll == null)
return null;
else if(coll instanceof CharSequence)
return Character.valueOf(((CharSequence) coll).charAt(n));
else if(coll.getClass().isArray())
return Reflector.prepRet(coll.getClass().getComponentType(),
Array.get(coll, n));
else if(coll instanceof RandomAccess)
return ((List) coll).get(n);
else if(coll instanceof Matcher)
return ((Matcher) coll).group(n);

else if(coll instanceof Map.Entry) {

Map.Entry e = (Map.Entry) coll;
if(n == 0)
return e.getKey();
else if(n == 1)
return e.getValue();
throw new IndexOutOfBoundsException();
}

else if(coll instanceof Sequential) {

ISeq seq = RT.seq(coll);
coll = null;
for(int i = 0; i <= n && seq != null; ++i, seq = seq.next()) {
if(i == n)
return seq.first();
}
throw new IndexOutOfBoundsException();
}
else
throw new UnsupportedOperationException(
"nth not supported on this type: " +
coll.getClass().getSimpleName());
}

static public Object nth(Object coll, int n, Object notFound){

if(coll instanceof Indexed) {
Indexed v = (Indexed) coll;
return v.nth(n, notFound);
}
return nthFrom(coll, n, notFound);
}

static Object nthFrom(Object coll, int n, Object notFound){

if(coll == null)
return notFound;
else if(n < 0)
return notFound;
8.95. RT.JAVA 995

else if(coll instanceof CharSequence) {

CharSequence s = (CharSequence) coll;
if(n < s.length())
return Character.valueOf(s.charAt(n));
return notFound;
}
else if(coll.getClass().isArray()) {
if(n < Array.getLength(coll))
return
Reflector.prepRet(coll.getClass().getComponentType(),
Array.get(coll, n));
return notFound;
}
else if(coll instanceof RandomAccess) {
List list = (List) coll;
if(n < list.size())
return list.get(n);
return notFound;
}
else if(coll instanceof Matcher) {
Matcher m = (Matcher) coll;
if(n < m.groupCount())
return m.group(n);
return notFound;
}
else if(coll instanceof Map.Entry) {
Map.Entry e = (Map.Entry) coll;
if(n == 0)
return e.getKey();
else if(n == 1)
return e.getValue();
return notFound;
}
else if(coll instanceof Sequential) {
ISeq seq = RT.seq(coll);
coll = null;
for(int i = 0;
i <= n && seq != null;
++i, seq = seq.next()) {
if(i == n)
return seq.first();
}
return notFound;
}
else
throw new UnsupportedOperationException(
"nth not supported on this type: " +
coll.getClass().getSimpleName());
}
996 CHAPTER 8. JVM/CLOJURE/LANG/

static public Object assocN(int n, Object val, Object coll){

if(coll == null)
return null;
else if(coll instanceof IPersistentVector)
return ((IPersistentVector) coll).assocN(n, val);
else if(coll instanceof Object[]) {
//hmm... this is not persistent
Object[] array = ((Object[]) coll);
array[n] = val;
return array;
}
else
return null;
}

static boolean hasTag(Object o, Object tag){

return (char) n;
}

static public boolean booleanCast(Object x){

if(x instanceof Boolean)
return ((Boolean) x).booleanValue();
return x != null;
}

static public boolean booleanCast(boolean x){

return x;
}

static public byte byteCast(Object x){

if(x instanceof Byte)
return ((Byte) x).byteValue();
long n = longCast(x);
if(n < Byte.MIN_VALUE || n > Byte.MAX_VALUE)
throw new IllegalArgumentException(
"Value out of range for byte: " + x);

return (byte) n;
}

static public short shortCast(Object x){

if(x instanceof Short)
return ((Short) x).shortValue();
long n = longCast(x);
998 CHAPTER 8. JVM/CLOJURE/LANG/

if(n < Short.MIN_VALUE || n > Short.MAX_VALUE)

static public float floatCast(Object x){

if(x instanceof Float)
return ((Float) x).floatValue();

double n = ((Number) x).doubleValue();

if(n < -Float.MAX_VALUE || n > Float.MAX_VALUE)
throw new IllegalArgumentException(
"Value out of range for float: " + x);

return (float) n;

static public float floatCast(int x){

return x;
}

static public float floatCast(float x){

return x;
}

static public float floatCast(long x){

return x;
}

static public float floatCast(double x){

1004 CHAPTER 8. JVM/CLOJURE/LANG/

static public ISeq list(){

return null;
}

static public ISeq list(Object arg1){

return new PersistentList(arg1);
}
1006 CHAPTER 8. JVM/CLOJURE/LANG/

static public ISeq list(Object arg1, Object arg2){

return listStar(arg1, arg2, null);
}

static public ISeq list(Object arg1, Object arg2, Object arg3){

return listStar(arg1, arg2, arg3, null);
}

static public ISeq list(Object arg1, Object arg2, Object arg3,

Object arg4){
return listStar(arg1, arg2, arg3, arg4, null);
}

static public ISeq list(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5){
return listStar(arg1, arg2, arg3, arg4, arg5, null);
}

static public ISeq listStar(Object arg1, ISeq rest){

return (ISeq) cons(arg1, rest);
}

static public ISeq listStar(Object arg1, Object arg2, ISeq rest){

return (ISeq) cons(arg1, cons(arg2, rest));
}

static public ISeq listStar(Object arg1, Object arg2, Object arg3,

ISeq rest){
return (ISeq) cons(arg1, cons(arg2, cons(arg3, rest)));
}

static public ISeq listStar(Object arg1, Object arg2, Object arg3,

Object arg4, ISeq rest){
return
(ISeq) cons(arg1, cons(arg2, cons(arg3, cons(arg4, rest))));
}

static public ISeq listStar(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, ISeq rest){
return
(ISeq) cons(arg1,
cons(arg2,
cons(arg3,
cons(arg4,
cons(arg5, rest)))));
}

static public ISeq arrayToList(Object[] a) throws Exception{

ISeq ret = null;
8.95. RT.JAVA 1007

for(int i = a.length - 1; i >= 0; --i)

ret = (ISeq) cons(a[i], ret);
return ret;
}

static public Object[] object_array(Object sizeOrSeq){

if(sizeOrSeq instanceof Number)
return new Object[((Number) sizeOrSeq).intValue()];
else
{
ISeq s = RT.seq(sizeOrSeq);
int size = RT.count(s);
Object[] ret = new Object[size];
for(int i = 0; i < size && s != null; i++, s = s.next())
ret[i] = s.first();
return ret;
}
}

static public Object[] toArray(Object coll) throws Exception{

if(coll == null)
return EMPTY_ARRAY;
else if(coll instanceof Object[])
return (Object[]) coll;
else if(coll instanceof Collection)
return ((Collection) coll).toArray();
else if(coll instanceof Map)
return ((Map) coll).entrySet().toArray();
else if(coll instanceof String) {
char[] chars = ((String) coll).toCharArray();
Object[] ret = new Object[chars.length];
for(int i = 0; i < chars.length; i++)
ret[i] = chars[i];
return ret;
}
else if(coll.getClass().isArray()) {
ISeq s = (seq(coll));
Object[] ret = new Object[count(s)];
for(int i = 0; i < ret.length; i++, s = s.next())
ret[i] = s.first();
return ret;
}
else
throw new Exception("Unable to convert: " +
coll.getClass() + " to Object[]");
}

static public Object[] seqToArray(ISeq seq){

int len = length(seq);
Object[] ret = new Object[len];
1008 CHAPTER 8. JVM/CLOJURE/LANG/

for(int i = 0; seq != null; ++i, seq = seq.next())

ret[i] = seq.first();
return ret;
}

static public Object seqToTypedArray(ISeq seq) throws Exception{

Class type = (seq != null) ? seq.first().getClass() : Object.class;
return seqToTypedArray(type, seq);
}

static public Object seqToTypedArray(Class type, ISeq seq)

throws Exception{
Object ret = Array.newInstance(type, length(seq));
if(type == Integer.TYPE){
for(int i = 0; seq != null; ++i, seq=seq.next()){
Array.set(ret, i, intCast(seq.first()));
}
} else if(type == Byte.TYPE) {
for(int i = 0; seq != null; ++i, seq=seq.next()){
Array.set(ret, i, byteCast(seq.first()));
}
} else if(type == Float.TYPE) {
for(int i = 0; seq != null; ++i, seq=seq.next()){
Array.set(ret, i, floatCast(seq.first()));
}
} else if(type == Short.TYPE) {
for(int i = 0; seq != null; ++i, seq=seq.next()){
Array.set(ret, i, shortCast(seq.first()));
}
} else if(type == Character.TYPE) {
for(int i = 0; seq != null; ++i, seq=seq.next()){
Array.set(ret, i, charCast(seq.first()));
}
} else {
for(int i = 0; seq != null; ++i, seq=seq.next()){
Array.set(ret, i, seq.first());
}
}
return ret;
}

static public int length(ISeq list){

int i = 0;
for(ISeq c = list; c != null; c = c.next()) {
i++;
}
return i;
}

static public int boundedLength(ISeq list, int limit)

8.95. RT.JAVA 1009

throws Exception{
int i = 0;
for(ISeq c = list; c != null && i <= limit; c = c.next()) {
i++;
}
return i;
}

//// reader support ////

static Character readRet(int ret){

if(ret == -1)
return null;
return box((char) ret);
}

static public Character readChar(Reader r) throws Exception{

int ret = r.read();
return readRet(ret);
}

static public Character peekChar(Reader r) throws Exception{

int ret;
if(r instanceof PushbackReader) {
ret = r.read();
((PushbackReader) r).unread(ret);
}
else {
r.mark(1);
ret = r.read();
r.reset();
}

return readRet(ret);
}

static public int getLineNumber(Reader r){

if(r instanceof LineNumberingPushbackReader)
return ((LineNumberingPushbackReader) r).getLineNumber();
return 0;
}

static public LineNumberingPushbackReader

getLineNumberingReader(Reader r){
if(isLineNumberingReader(r))
return (LineNumberingPushbackReader) r;
return new LineNumberingPushbackReader(r);
}

static public boolean isLineNumberingReader(Reader r){

1010 CHAPTER 8. JVM/CLOJURE/LANG/

return r instanceof LineNumberingPushbackReader;

}

static public String resolveClassNameInContext(String className){

//todo - look up in context var
return className;
}

static public boolean suppressRead(){

//todo - look up in suppress-read var
return false;
}

static public String printString(Object x){

try {
StringWriter sw = new StringWriter();
print(x, sw);
return sw.toString();
}
catch(Exception e) {
throw new RuntimeException(e);
}
}

static public Object readString(String s){

PushbackReader r = new PushbackReader(new StringReader(s));
try {
return LispReader.read(r, true, null, false);
}
catch(Exception e) {
throw new RuntimeException(e);
}
}

static public void print(Object x, Writer w) throws Exception{

//call multimethod
if(PRINT_INITIALIZED.isBound() &&
RT.booleanCast(PRINT_INITIALIZED.deref()))
PR_ON.invoke(x, w);
//*
else {
boolean readably = booleanCast(PRINT_READABLY.deref());
if(x instanceof Obj) {
Obj o = (Obj) x;
if(RT.count(o.meta()) > 0 &&
((readably && booleanCast(PRINT_META.deref()))
|| booleanCast(PRINT_DUP.deref()))) {
IPersistentMap meta = o.meta();
w.write("#^");
if(meta.count() == 1 && meta.containsKey(TAG_KEY))
8.95. RT.JAVA 1011

print(meta.valAt(TAG_KEY), w);
else
print(meta, w);
w.write(’ ’);
}
}
if(x == null)
w.write("nil");
else if(x instanceof ISeq || x instanceof IPersistentList) {
w.write(’(’);
printInnerSeq(seq(x), w);
w.write(’)’);
}
else if(x instanceof String) {
String s = (String) x;
if(!readably)
w.write(s);
else {
w.write(’"’);
//w.write(x.toString());
for(int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch(c) {
case ’\n’:
w.write("\\n");
break;
case ’\t’:
w.write("\\t");
break;
case ’\r’:
w.write("\\r");
break;
case ’"’:
w.write("\\\"");
break;
case ’\\’:
w.write("\\\\");
break;
case ’\f’:
w.write("\\f");
break;
case ’\b’:
w.write("\\b");
break;
default:
w.write(c);
}
}
w.write(’"’);
}
1012 CHAPTER 8. JVM/CLOJURE/LANG/

}
else if(x instanceof IPersistentMap) {
w.write(’{’);
for(ISeq s = seq(x); s != null; s = s.next()) {
IMapEntry e = (IMapEntry) s.first();
print(e.key(), w);
w.write(’ ’);
print(e.val(), w);
if(s.next() != null)
w.write(", ");
}
w.write(’}’);
}
else if(x instanceof IPersistentVector) {
IPersistentVector a = (IPersistentVector) x;
w.write(’[’);
for(int i = 0; i < a.count(); i++) {
print(a.nth(i), w);
if(i < a.count() - 1)
w.write(’ ’);
}
w.write(’]’);
}
else if(x instanceof IPersistentSet) {
w.write("#{");
for(ISeq s = seq(x); s != null; s = s.next()) {
print(s.first(), w);
if(s.next() != null)
w.write(" ");
}
w.write(’}’);
}
else if(x instanceof Character) {
char c = ((Character) x).charValue();
if(!readably)
w.write(c);
else {
w.write(’\\’);
switch(c) {
case ’\n’:
w.write("newline");
break;
case ’\t’:
w.write("tab");
break;
case ’ ’:
w.write("space");
break;
case ’\b’:
w.write("backspace");
8.95. RT.JAVA 1013

break;
case ’\f’:
w.write("formfeed");
break;
case ’\r’:
w.write("return");
break;
default:
w.write(c);
}
}
}
else if(x instanceof Class) {
w.write("#=");
w.write(((Class) x).getName());
}
else if(x instanceof BigDecimal && readably) {
w.write(x.toString());
w.write(’M’);
}
else if(x instanceof BigInt && readably) {
w.write(x.toString());
w.write(’N’);
}
else if(x instanceof BigInteger && readably) {
w.write(x.toString());
w.write("BIGINT");
}
else if(x instanceof Var) {
Var v = (Var) x;
w.write("#=(var " + v.ns.name + "/" + v.sym + ")");
}
else if(x instanceof Pattern) {
Pattern p = (Pattern) x;
w.write("#\"" + p.pattern() + "\"");
}
else w.write(x.toString());
}
//*/
}

private static void printInnerSeq(ISeq x, Writer w)

throws Exception{
for(ISeq s = x; s != null; s = s.next()) {
print(s.first(), w);
if(s.next() != null)
w.write(’ ’);
}
}
1014 CHAPTER 8. JVM/CLOJURE/LANG/

static public void formatAesthetic(Writer w, Object obj)

throws IOException{
if(obj == null)
w.write("null");
else
w.write(obj.toString());
}

static public void formatStandard(Writer w, Object obj)

throws IOException{
if(obj == null)
w.write("null");
else if(obj instanceof String) {
w.write(’"’);
w.write((String) obj);
w.write(’"’);
}
else if(obj instanceof Character) {
w.write(’\\’);
char c = ((Character) obj).charValue();
switch(c) {
case ’\n’:
w.write("newline");
break;
case ’\t’:
w.write("tab");
break;
case ’ ’:
w.write("space");
break;
case ’\b’:
w.write("backspace");
break;
case ’\f’:
w.write("formfeed");
break;
default:
w.write(c);
}
}
else
w.write(obj.toString());
}

static public Object format(Object o, String s, Object... args)

throws Exception{
Writer w;
if(o == null)
w = new StringWriter();
else if(Util.equals(o, T))
8.95. RT.JAVA 1015

w = (Writer) OUT.deref();
else
w = (Writer) o;
doFormat(w, s, ArraySeq.create(args));
if(o == null)
return w.toString();
return null;
}

static public ISeq doFormat(Writer w, String s, ISeq args)

throws Exception{
for(int i = 0; i < s.length();) {
char c = s.charAt(i++);
switch(Character.toLowerCase(c)) {
case ’~’:
char d = s.charAt(i++);
switch(Character.toLowerCase(d)) {
case ’%’:
w.write(’\n’);
break;
case ’t’:
w.write(’\t’);
break;
case ’a’:
if(args == null)
throw new IllegalArgumentException(
"Missing argument");
RT.formatAesthetic(w, RT.first(args));
args = RT.next(args);
break;
case ’s’:
if(args == null)
throw new IllegalArgumentException(
"Missing argument");
RT.formatStandard(w, RT.first(args));
args = RT.next(args);
break;
case ’{’:
int j = s.indexOf("~}", i); //note - does not nest
if(j == -1)
throw new IllegalArgumentException("Missing ~}");
String subs = s.substring(i, j);
for(ISeq sargs = RT.seq(RT.first(args)); sargs != null;)
sargs = doFormat(w, subs, sargs);
args = RT.next(args);
i = j + 2; //skip ~}
break;
case ’^’:
if(args == null)
return null;
1016 CHAPTER 8. JVM/CLOJURE/LANG/

break;
case ’~’:
w.write(’~’);
break;
default:
throw new IllegalArgumentException(
"Unsupported ~ directive: " + d);
}
break;
default:
w.write(c);
}
}
return args;
}
///////////////////////////////// values //////////////////////////

static public Object[] setValues(Object... vals){

//ThreadLocalData.setValues(vals);
if(vals.length > 0)
return vals;//[0];
return null;
}

static public ClassLoader makeClassLoader(){

return (ClassLoader) AccessController
.doPrivileged(new PrivilegedAction(){
public Object run(){
try{
Var.pushThreadBindings(
RT.map(USE_CONTEXT_CLASSLOADER, RT.T));
// getRootClassLoader();
return new DynamicClassLoader(baseLoader());
}
finally{
Var.popThreadBindings();
}
}
});
}

static public ClassLoader baseLoader(){

if(Compiler.LOADER.isBound())
return (ClassLoader) Compiler.LOADER.deref();
else if(booleanCast(USE_CONTEXT_CLASSLOADER.deref()))
return Thread.currentThread().getContextClassLoader();
return Compiler.class.getClassLoader();
}
8.95. RT.JAVA 1017

static public Class classForName(String name)

throws ClassNotFoundException{

return Class.forName(name, true, baseLoader());

}

static public Class loadClassForName(String name)

throws ClassNotFoundException{
try
{
Class.forName(name, false, baseLoader());
}
catch(ClassNotFoundException e)
{
return null;
}
return Class.forName(name, true, baseLoader());
}

static public float aget(float[] xs, int i){

return xs[i];
}

static public float aset(float[] xs, int i, float v){

xs[i] = v;
return v;
}

static public int alength(float[] xs){

return xs.length;
}

static public float[] aclone(float[] xs){

return xs.clone();
}

static public double aget(double[] xs, int i){

return xs[i];
}

static public double aset(double[] xs, int i, double v){

xs[i] = v;
return v;
}

static public int alength(double[] xs){

return xs.length;
}

static public double[] aclone(double[] xs){

static public Object[] aclone(Object[] xs){

return xs.clone();
}

———-

8.96 Script.java

— Script.java —

\getchunk{Clojure Copyright}
/* rich Oct 18, 2007 */

package clojure.lang;

import clojure.main;

public class Script {

public static void main(String[] args) throws Exception{

main.legacy_script(args);
}
}

———-
8.97. SEQENUMERATION.JAVA 1021

8.97 SeqEnumeration.java

— SeqEnumeration.java —

\getchunk{Clojure Copyright}
/* rich Mar 3, 2008 */

package clojure.lang;

import java.util.Enumeration;

public class SeqEnumeration implements Enumeration{

ISeq seq;

public SeqEnumeration(ISeq seq){

this.seq = seq;
}

public boolean hasMoreElements(){

return seq != null;
}

public Object nextElement(){

Object ret = RT.first(seq);
seq = RT.next(seq);
return ret;
}
}

———-

8.98 SeqIterator.java

— SeqIterator.java —

\getchunk{Clojure Copyright}
/* rich Jun 19, 2007 */

package clojure.lang;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class SeqIterator implements Iterator{

1022 CHAPTER 8. JVM/CLOJURE/LANG/

ISeq seq;

public SeqIterator(ISeq seq){

this.seq = seq;
}

public boolean hasNext(){

return seq != null;
}

public Object next() throws NoSuchElementException {

if(seq == null)
throw new NoSuchElementException();
Object ret = RT.first(seq);
seq = RT.next(seq);
return ret;
}

public void remove(){

throw new UnsupportedOperationException();
}
}

———-

8.99 Seqable.java

— Seqable.java —

\getchunk{Clojure Copyright}
/* rich Jan 28, 2009 */

package clojure.lang;

public interface Seqable {

ISeq seq();
}

———-

8.100 Sequential.java

— Sequential.java —
8.101. SETTABLE.JAVA 1023

\getchunk{Clojure Copyright}
package clojure.lang;

public interface Sequential {

}

———-

8.101 Settable.java

— Settable.java —

\getchunk{Clojure Copyright}
/* rich Dec 31, 2008 */

package clojure.lang;

public interface Settable {

Object doSet(Object val) throws Exception;
Object doReset(Object val) throws Exception;
}

———-

8.102 Sorted.java

— Sorted.java —

\getchunk{Clojure Copyright}
/* rich Apr 15, 2008 */

package clojure.lang;

import java.util.Comparator;

public interface Sorted{

Comparator comparator();

Object entryKey(Object entry);

ISeq seq(boolean ascending);

ISeq seqFrom(Object key, boolean ascending);

}
1024 CHAPTER 8. JVM/CLOJURE/LANG/

———-

8.103 StringSeq.java

— StringSeq.java —

\getchunk{Clojure Copyright}
/* rich Dec 6, 2007 */

package clojure.lang;

public class StringSeq extends ASeq implements IndexedSeq{

public final CharSequence s;
public final int i;

static public StringSeq create(CharSequence s){

if(s.length() == 0)
return null;
return new StringSeq(null, s, 0);
}

StringSeq(IPersistentMap meta, CharSequence s, int i){

super(meta);
this.s = s;
this.i = i;
}

public Obj withMeta(IPersistentMap meta){

if(meta == meta())
return this;
return new StringSeq(meta, s, i);
}

public Object first(){

return Character.valueOf(s.charAt(i));
}

public ISeq next(){

if(i + 1 < s.length())
return new StringSeq(_meta, s, i + 1);
return null;
}

public int index(){

return i;
}
8.104. SYMBOL.JAVA 1025

public int count(){

return s.length() - i;
}
}

———-

8.104 Symbol.java

— Symbol.java —

\getchunk{Clojure Copyright}
/* rich Mar 25, 2006 11:42:47 AM */

package clojure.lang;

import java.io.Serializable;
import java.io.ObjectStreamException;

public class Symbol

extends AFn implements IObj, Comparable, Named, Serializable{
//these must be interned strings!
final String ns;
final String name;
final int hash;
final IPersistentMap _meta;

public String toString(){

if(ns != null)
return ns + "/" + name;
return name;
}

public String getNamespace(){

return ns;
}

public String getName(){

return name;
}

// the create thunks preserve binary compatibility with code compiled

// against earlier version of Clojure and can be removed (at some point).
static public Symbol create(String ns, String name) {
return Symbol.intern(ns, name);
}
1026 CHAPTER 8. JVM/CLOJURE/LANG/

static public Symbol create(String nsname) {

return Symbol.intern(nsname);
}

static public Symbol intern(String ns, String name){

return new Symbol(ns == null ? null : ns.intern(), name.intern());
}

static public Symbol intern(String nsname){

int i = nsname.lastIndexOf(’/’);
if(i == -1 || nsname.equals("/"))
return new Symbol(null, nsname.intern());
else
return
new Symbol(nsname.substring(0, i).intern(),
nsname.substring(i + 1).intern());
}

private Symbol(String ns_interned, String name_interned){

this.name = name_interned;
this.ns = ns_interned;
this.hash = Util.hashCombine(name.hashCode(), Util.hash(ns));
this._meta = null;
}

public boolean equals(Object o){

if(this == o)
return true;
if(!(o instanceof Symbol))
return false;

Symbol symbol = (Symbol) o;

//identity compares intended, names are interned

return name == symbol.name && ns == symbol.ns;
}

public int hashCode(){

return hash;
}

public IObj withMeta(IPersistentMap meta){

return new Symbol(meta, ns, name);
}

private Symbol(IPersistentMap meta, String ns, String name){

this.name = name;
this.ns = ns;
this._meta = meta;
8.105. TRANSACTIONALHASHMAP.JAVA 1027

this.hash = Util.hashCombine(name.hashCode(), Util.hash(ns));

}

public int compareTo(Object o){

Symbol s = (Symbol) o;
if(this.equals(o))
return 0;
if(this.ns == null && s.ns != null)
return -1;
if(this.ns != null)
{
if(s.ns == null)
return 1;
int nsc = this.ns.compareTo(s.ns);
if(nsc != 0)
return nsc;
}
return this.name.compareTo(s.name);
}

private Object readResolve() throws ObjectStreamException{

return intern(ns, name);
}

public Object invoke(Object obj) throws Exception{

return RT.get(obj, this);
}

public Object invoke(Object obj, Object notFound)

throws Exception{
return RT.get(obj, this, notFound);
}

public IPersistentMap meta(){

return _meta;
}
}

———-

8.105 TransactionalHashMap.java

— TransactionalHashMap.java —

\getchunk{Clojure Copyright}
/* rich Jul 31, 2008 */
1028 CHAPTER 8. JVM/CLOJURE/LANG/

package clojure.lang;

import java.util.concurrent.ConcurrentMap;
import java.util.*;

public class TransactionalHashMap<K, V>

extends AbstractMap<K, V> implements ConcurrentMap<K, V>{
final Ref[] bins;

IPersistentMap mapAt(int bin){

return (IPersistentMap) bins[bin].deref();
}

final int binFor(Object k){

//spread hashes, a la Cliff Click
int h = k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
h ^= (h >>> 7) ^ (h >>> 4);
return h % bins.length;
// return k.hashCode() % bins.length;
}

Entry entryAt(Object k){

return mapAt(binFor(k)).entryAt(k);
}

public TransactionalHashMap() throws Exception{

this(421);
}

public TransactionalHashMap(int nBins) throws Exception{

bins = new Ref[nBins];
for(int i = 0; i < nBins; i++)
bins[i] = new Ref(PersistentHashMap.EMPTY);
}

public TransactionalHashMap(Map<? extends K, ? extends V> m)

throws Exception{
this(m.size());
putAll(m);
}

public int size(){

int n = 0;
for(int i = 0; i < bins.length; i++)
{
n += mapAt(i).count();
}
return n;
}
8.105. TRANSACTIONALHASHMAP.JAVA 1029

public boolean isEmpty(){

return size() == 0;
}

public boolean containsKey(Object k){

return entryAt(k) != null;
}

public V get(Object k){

Entry e = entryAt(k);
if(e != null)
return (V) e.getValue();
return null;
}

public V put(K k, V v){

Ref r = bins[binFor(k)];
IPersistentMap map = (IPersistentMap) r.deref();
Object ret = map.valAt(k);
r.set(map.assoc(k, v));
return (V) ret;
}

public V remove(Object k){

Ref r = bins[binFor(k)];
IPersistentMap map = (IPersistentMap) r.deref();
Object ret = map.valAt(k);
//checked exceptions are a bad idea, especially in an interface
try
{
r.set(map.without(k));
}
catch(Exception e)
{
throw new RuntimeException(e);
}
return (V) ret;
}

public void putAll(Map<? extends K, ? extends V> map){

for(Iterator i = map.entrySet().iterator(); i.hasNext();)
{
Entry<K, V> e = (Entry) i.next();
put(e.getKey(), e.getValue());
}
}

public void clear(){

for(int i = 0; i < bins.length; i++)
1030 CHAPTER 8. JVM/CLOJURE/LANG/

{
Ref r = bins[i];
IPersistentMap map = (IPersistentMap) r.deref();
if(map.count() > 0)
{
r.set(PersistentHashMap.EMPTY);
}
}
}

public Set<Entry<K, V>> entrySet(){

final ArrayList<Map.Entry<K, V>> entries =
new ArrayList(bins.length);
for(int i = 0; i < bins.length; i++)
{
IPersistentMap map = mapAt(i);
if(map.count() > 0)
entries.addAll((Collection) RT.seq(map));
}
return new AbstractSet<Entry<K, V>>(){
public Iterator iterator(){
return Collections.unmodifiableList(entries).iterator();
}

public int size(){

return entries.size();
}
};
}

public V putIfAbsent(K k, V v){

Ref r = bins[binFor(k)];
IPersistentMap map = (IPersistentMap) r.deref();
Entry e = map.entryAt(k);
if(e == null)
{
r.set(map.assoc(k, v));
return null;
}
else
return (V) e.getValue();
}

public boolean remove(Object k, Object v){

Ref r = bins[binFor(k)];
IPersistentMap map = (IPersistentMap) r.deref();
Entry e = map.entryAt(k);
if(e != null && e.getValue().equals(v))
{
//checked exceptions are a bad idea, especially
8.106. UTIL.JAVA 1031

//in an interface
try
{
r.set(map.without(k));
}
catch(Exception ex)
{
throw new RuntimeException(ex);
}
return true;
}
return false;
}

public boolean replace(K k, V oldv, V newv){

Ref r = bins[binFor(k)];
IPersistentMap map = (IPersistentMap) r.deref();
Entry e = map.entryAt(k);
if(e != null && e.getValue().equals(oldv))
{
r.set(map.assoc(k, newv));
return true;
}
return false;
}

public V replace(K k, V v){

Ref r = bins[binFor(k)];
IPersistentMap map = (IPersistentMap) r.deref();
Entry e = map.entryAt(k);
if(e != null)
{
r.set(map.assoc(k, v));
return (V) e.getValue();
}
return null;
}

———-

8.106 Util.java

— Util.java —

\getchunk{Clojure Copyright}
1032 CHAPTER 8. JVM/CLOJURE/LANG/

/* rich Apr 19, 2008 */

static public ISeq ret1(ISeq ret, Object nil){

return ret;
}

static public <K,V> void

clearCache(ReferenceQueue rq,
ConcurrentHashMap<K, SoftReference<V>> cache){
//cleanup any dead entries
if(rq.poll() != null)
{
while(rq.poll() != null)
;
for(Map.Entry<K, SoftReference<V>> e : cache.entrySet())
{
if(e.getValue().get() == null)
cache.remove(e.getKey(), e.getValue());
}
}
}
}

———-

8.107 Var.java

— Var.java —

\getchunk{Clojure Copyright}
/* rich Jul 31, 2007 */

package clojure.lang;

import java.util.concurrent.atomic.AtomicBoolean;
8.107. VAR.JAVA 1035

public final class Var extends ARef implements IFn, IRef, Settable{

static class TBox{

volatile Object val;

final Thread thread;

public TBox(Thread t, Object val){

this.thread = t;
this.val = val;
}
}

static public class Unbound extends AFn{

final public Var v;

public Unbound(Var v){

this.v = v;
}

public String toString(){

return "Unbound: " + v;
}

public Object throwArity(int n){

throw new IllegalStateException(
"Attempting to call unbound fn: " + v);
}
}

static class Frame{

//Var->TBox
Associative bindings;
//Var->val
// Associative frameBindings;
Frame prev;

public Frame(){
this(PersistentHashMap.EMPTY, null);
}

public Frame(Associative bindings, Frame prev){

// this.frameBindings = frameBindings;
this.bindings = bindings;
this.prev = prev;
}
}
1036 CHAPTER 8. JVM/CLOJURE/LANG/

static final ThreadLocal<Frame> dvals = new ThreadLocal<Frame>(){

protected Frame initialValue(){

return new Frame();
}
};

static public volatile int rev = 0;

static Keyword privateKey = Keyword.intern(null, "private");

static IPersistentMap privateMeta =
new PersistentArrayMap(new Object[]{privateKey, Boolean.TRUE});
static Keyword macroKey = Keyword.intern(null, "macro");
static Keyword nameKey = Keyword.intern(null, "name");
static Keyword nsKey = Keyword.intern(null, "ns");
//static Keyword tagKey = Keyword.intern(null, "tag");

private volatile Object root;

volatile boolean dynamic = false;

transient final AtomicBoolean threadBound;
public final Symbol sym;
public final Namespace ns;

//IPersistentMap _meta;

public static Object getThreadBindingFrame(){

Frame f = dvals.get();
if(f != null)
return f;
return new Frame();
}

public static void resetThreadBindingFrame(Object frame){

dvals.set((Frame) frame);
}

public Var setDynamic(){

this.dynamic = true;
return this;
}

public Var setDynamic(boolean b){

this.dynamic = b;
return this;
}

public final boolean isDynamic(){

return dynamic;
}
8.107. VAR.JAVA 1037

public static Var intern(Namespace ns, Symbol sym, Object root){

return intern(ns, sym, root, true);
}

public static Var intern(Namespace ns,

Symbol sym,
Object root,
boolean replaceRoot){
Var dvout = ns.intern(sym);
if(!dvout.hasRoot() || replaceRoot)
dvout.bindRoot(root);
return dvout;
}

public String toString(){

if(ns != null)
return "#’" + ns.name + "/" + sym;
return "#<Var: " + (sym != null
? sym.toString()
: "--unnamed--") + ">";
}

public static Var find(Symbol nsQualifiedSym){

if(nsQualifiedSym.ns == null)
throw new IllegalArgumentException(
"Symbol must be namespace-qualified");
Namespace ns = Namespace.find(Symbol.intern(nsQualifiedSym.ns));
if(ns == null)
throw new IllegalArgumentException(
"No such namespace: " + nsQualifiedSym.ns);
return ns.findInternedVar(Symbol.intern(nsQualifiedSym.name));
}

public static Var intern(Symbol nsName, Symbol sym){

Namespace ns = Namespace.findOrCreate(nsName);
return intern(ns, sym);
}

public static Var internPrivate(String nsName, String sym){

Namespace ns = Namespace.findOrCreate(Symbol.intern(nsName));
Var ret = intern(ns, Symbol.intern(sym));
ret.setMeta(privateMeta);
return ret;
}

public static Var intern(Namespace ns, Symbol sym){

return ns.intern(sym);
}
1038 CHAPTER 8. JVM/CLOJURE/LANG/

public static Var create(){

return new Var(null, null);
}

public static Var create(Object root){

return new Var(null, null, root);
}

Var(Namespace ns, Symbol sym){

this.ns = ns;
this.sym = sym;
this.threadBound = new AtomicBoolean(false);
this.root = new Unbound(this);
setMeta(PersistentHashMap.EMPTY);
}

Var(Namespace ns, Symbol sym, Object root){

this(ns, sym);
this.root = root;
++rev;
}

public boolean isBound(){

return
hasRoot() ||
(threadBound.get() && dvals.get().bindings.containsKey(this));
}

final public Object get(){

if(!threadBound.get())
return root;
return deref();
}

final public Object deref(){

TBox b = getThreadBinding();
if(b != null)
return b.val;
return root;
}

public void setValidator(IFn vf){

if(hasRoot())
validate(vf, root);
validator = vf;
}

public Object alter(IFn fn, ISeq args) throws Exception{

8.107. VAR.JAVA 1039

set(fn.applyTo(RT.cons(deref(), args)));
return this;
}

public Object set(Object val){

validate(getValidator(), val);
TBox b = getThreadBinding();
if(b != null)
{
if(Thread.currentThread() != b.thread)
throw new IllegalStateException(String.format(
"Can’t set!: %s from non-binding thread", sym));
return (b.val = val);
}
throw new IllegalStateException(String.format(
"Can’t change/establish root binding of: %s with set", sym));
}

public Object doSet(Object val) throws Exception {

return set(val);
}

public Object doReset(Object val) throws Exception {

bindRoot(val);
return val;
}

public void setMeta(IPersistentMap m) {

//ensure these basis keys
resetMeta(m.assoc(nameKey, sym).assoc(nsKey, ns));
}

public void setMacro() {

try
{
alterMeta(assoc, RT.list(macroKey, RT.T));
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}

public boolean isMacro(){

return RT.booleanCast(meta().valAt(macroKey));
}

//public void setExported(boolean state){

// _meta = _meta.assoc(privateKey, state);
//}
1040 CHAPTER 8. JVM/CLOJURE/LANG/

public boolean isPublic(){

return !RT.booleanCast(meta().valAt(privateKey));
}

final public Object getRawRoot(){

return root;
}

public Object getTag(){

return meta().valAt(RT.TAG_KEY);
}

final public boolean hasRoot(){

return !(root instanceof Unbound);
}

//binding root always clears macro flag

synchronized public void bindRoot(Object root){
validate(getValidator(), root);
Object oldroot = this.root;
this.root = root;
++rev;
try
{
alterMeta(dissoc, RT.list(macroKey));
}
catch (Exception e)
{
throw new RuntimeException(e);
}
notifyWatches(oldroot,this.root);
}

synchronized void swapRoot(Object root){

validate(getValidator(), root);
Object oldroot = this.root;
this.root = root;
++rev;
8.107. VAR.JAVA 1041

notifyWatches(oldroot,root);
}

synchronized public void unbindRoot(){

this.root = new Unbound(this);
++rev;
}

synchronized public void commuteRoot(IFn fn) throws Exception{

Object newRoot = fn.invoke(root);
validate(getValidator(), newRoot);
Object oldroot = root;
this.root = newRoot;
++rev;
notifyWatches(oldroot,newRoot);
}

synchronized public Object alterRoot(IFn fn, ISeq args)

throws Exception{
Object newRoot = fn.applyTo(RT.cons(root, args));
validate(getValidator(), newRoot);
Object oldroot = root;
this.root = newRoot;
++rev;
notifyWatches(oldroot,newRoot);
return newRoot;
}

public static void pushThreadBindings(Associative bindings){

Frame f = dvals.get();
Associative bmap = f.bindings;
for(ISeq bs = bindings.seq(); bs != null; bs = bs.next())
{
IMapEntry e = (IMapEntry) bs.first();
Var v = (Var) e.key();
if(!v.dynamic)
throw new IllegalStateException(String.format(
"Can’t dynamically bind non-dynamic var: %s/%s",
v.ns, v.sym));
v.validate(v.getValidator(), e.val());
v.threadBound.set(true);
bmap =
bmap.assoc(v, new TBox(Thread.currentThread(), e.val()));
}
dvals.set(new Frame(bmap, f));
}

public static void popThreadBindings(){

Frame f = dvals.get();
if(f.prev == null)
1042 CHAPTER 8. JVM/CLOJURE/LANG/

throw new IllegalStateException("Pop without matching push");

dvals.set(f.prev);
}

public static Associative getThreadBindings(){

Frame f = dvals.get();
IPersistentMap ret = PersistentHashMap.EMPTY;
for(ISeq bs = f.bindings.seq(); bs != null; bs = bs.next())
{
IMapEntry e = (IMapEntry) bs.first();
Var v = (Var) e.key();
TBox b = (TBox) e.val();
ret = ret.assoc(v, b.val);
}
return ret;
}

public final TBox getThreadBinding(){

if(threadBound.get())
{
IMapEntry e = dvals.get().bindings.entryAt(this);
if(e != null)
return (TBox) e.val();
}
return null;
}

final public IFn fn(){

return (IFn) deref();
}

public Object call() throws Exception{

return invoke();
}

public void run(){

try
{
invoke();
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}

public Object invoke()

throws Exception{
return fn().invoke();
}
8.107. VAR.JAVA 1043

public Object invoke(Object arg1)

throws Exception{
return fn().invoke(arg1);
}

public Object invoke(Object arg1, Object arg2)

throws Exception{
return fn().invoke(arg1, arg2);
}

public Object invoke(Object arg1, Object arg2, Object arg3)

throws Exception{
return fn().invoke(arg1, arg2, arg3);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8)
throws Exception{
return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
1044 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg7, Object arg8, Object arg9)

throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
8.107. VAR.JAVA 1045

Object arg10, Object arg11, Object arg12,

Object arg13, Object arg14)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15,
arg16);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
1046 CHAPTER 8. JVM/CLOJURE/LANG/

Object arg16, Object arg17, Object arg18)

throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

Object arg4, Object arg5, Object arg6,
Object arg7, Object arg8, Object arg9,
Object arg10, Object arg11, Object arg12,
Object arg13, Object arg14, Object arg15,
Object arg16, Object arg17, Object arg18,
Object arg19)
throws Exception{
return
fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
arg10, arg11, arg12, arg13, arg14, arg15,
arg16, arg17, arg18, arg19);
}

public Object invoke(Object arg1, Object arg2, Object arg3,

public Object applyTo(ISeq arglist) throws Exception{

return AFn.applyToHelper(this, arglist);
}

static IFn assoc = new AFn(){

@Override
public Object invoke(Object m, Object k, Object v) throws Exception {
return RT.assoc(m, k, v);
}
};
static IFn dissoc = new AFn() {
@Override
public Object invoke(Object c, Object k) throws Exception {
return RT.dissoc(c, k);
}
};
}

———-

8.108 XMLHandler.java

— XMLHandler.java —

\getchunk{Clojure Copyright}
/* rich Dec 17, 2007 */

package clojure.lang;

import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class XMLHandler extends DefaultHandler{

ContentHandler h;

public XMLHandler(ContentHandler h){

this.h = h;
}

public void setDocumentLocator(Locator locator){

h.setDocumentLocator(locator);
}
1048 CHAPTER 8. JVM/CLOJURE/LANG/

public void startDocument() throws SAXException{

h.startDocument();
}

public void endDocument() throws SAXException{

h.endDocument();
}

public void startPrefixMapping(String prefix, String uri)

throws SAXException{
h.startPrefixMapping(prefix, uri);
}

public void endPrefixMapping(String prefix)

throws SAXException{
h.endPrefixMapping(prefix);
}

public void startElement(String uri,

String localName,
String qName,
Attributes atts)
throws SAXException{
h.startElement(uri, localName, qName, atts);
}

public void endElement(String uri, String localName, String qName)

throws SAXException{
h.endElement(uri, localName, qName);
}

public void characters(char ch[], int start, int length)

throws SAXException{
h.characters(ch, start, length);
}

public void ignorableWhitespace(char ch[], int start, int length)

throws SAXException{
h.ignorableWhitespace(ch, start, length);
}

public void processingInstruction(String target, String data)

throws SAXException{
h.processingInstruction(target, data);
}

public void skippedEntity(String name) throws SAXException{

h.skippedEntity(name);
}
8.109. CLOJURE.JAVA 1049

/*
public static void main(String[] args){
try
{
ContentHandler dummy = new DefaultHandler();
SAXParserFactory f = SAXParserFactory.newInstance();
//f.setNamespaceAware(true);
SAXParser p = f.newSAXParser();
p.parse("http://arstechnica.com/journals.rssx",
new XMLHandler(dummy));
}
catch(Exception e)
{
e.printStackTrace();
}
}
//*/
}

———-

8.109 clojure.java

— clojure.java —

———-
1050 CHAPTER 8. JVM/CLOJURE/LANG/
Chapter 9

jvm/clojure

9.1 main.java

— main.java —
\getchunk{Clojure Copyright}
package clojure;

import clojure.lang.Symbol;
import clojure.lang.Var;
import clojure.lang.RT;

public class main{

final static private Symbol CLOJURE_MAIN =

Symbol.intern("clojure.main");
final static private Var REQUIRE =
RT.var("clojure.core", "require");
final static private Var LEGACY_REPL =
RT.var("clojure.main", "legacy-repl");
final static private Var LEGACY_SCRIPT =
RT.var("clojure.main", "legacy-script");
final static private Var MAIN =
RT.var("clojure.main", "main");

public static void legacy_repl(String[] args) throws Exception{

REQUIRE.invoke(CLOJURE_MAIN);
LEGACY_REPL.invoke(RT.seq(args));
}

public static void legacy_script(String[] args) throws Exception{

REQUIRE.invoke(CLOJURE_MAIN);

1051
1052 CHAPTER 9. JVM/CLOJURE

LEGACY_SCRIPT.invoke(RT.seq(args));
}

public static void main(String[] args) throws Exception{

REQUIRE.invoke(CLOJURE_MAIN);
MAIN.applyTo(RT.seq(args));
}
}

———-
Chapter 10

clj/clojure/

10.1 core.clj

— core.clj —

———-

10.2 core/protocols.clj

— core/protocols.clj —

———-

10.3 main.clj

— main.clj —

———-

1053
1054 CHAPTER 10. CLJ/CLOJURE/

10.4 set.clj

— set.clj —

———-

10.5 xml.clj

— xml.clj —

———-

10.6 zip.clj

— zip.clj —

———-

10.7 inspector.clj

— inspector.clj —

———-

10.8 walk.clj

— walk.clj —

———-
10.9. STACKTRACE.CLJ 1055

10.9 stacktrace.clj

— stacktrace.clj —

———-

10.10 template.clj

— template.clj —

———-

10.11 test.clj

— test.clj —

———-

10.12 test/tap.clj

— test/tap.clj —

———-

10.13 test/junit.clj

— test/junit.clj —

———-
1056 CHAPTER 10. CLJ/CLOJURE/

10.14 pprint.clj

— pprint.clj —

———-

10.15 java/io.clj

— java/io.clj —

———-

10.16 repl.clj

— repl.clj —

———-

10.17 java/browse.clj

— java/browse.clj —

———-

10.18 java/javadoc.clj

— java/javadoc.clj —

———-
10.19. JAVA/SHELL.CLJ 1057

10.19 java/shell.clj

— java/shell.clj —

———-

10.20 java/browse-ui.clj

— java/browse-ui.clj —

———-

10.21 string.clj

— string.clj —

———-

10.22 data.clj

— data.clj —

———-

10.23 clj/clojre/reflect.clj

— clj/clojre/reflect.clj —
1058 CHAPTER 10. CLJ/CLOJURE/

\getchunk{Clojure Copyright}
(ns ^{:author "Stuart Halloway"
:added "1.3"
:doc "Reflection on Host Types
Alpha - subject to change.

Two main entry points:

* type-reflect reflects on something that implements TypeReference.

* reflect (for REPL use) reflects on the class of an instance, or
on a class if passed a class

Key features:

* Exposes the read side of reflection as pure data. Reflecting

on a type returns a map with keys :bases, :flags, and :members.

* Canonicalizes class names as Clojure symbols. Types can extend

to the TypeReference protocol to indicate that they can be
unambiguously resolved as a type name. The canonical format
requires one non-Java-ish convention: array brackets are <>
instead of [] so they can be part of a Clojure symbol.

* Pluggable Reflectors for different implementations. The default

JavaReflector is good when you have a class in hand, or use
the AsmReflector for \"hands off\" reflection without forcing
classes to load.

Platform implementers must:

* Create an implementation of Reflector.

* Create one or more implementations of TypeReference.
* def default-reflector to be an instance that satisfies Reflector."}
clojure.reflect
(:require [clojure.set :as set]))

(defprotocol Reflector
"Protocol for reflection implementers."
(do-reflect [reflector typeref]))

(defprotocol TypeReference
"A TypeReference can be unambiguously converted to a type name on
the host platform.

All typerefs are normalized into symbols. If you need to

normalize a typeref yourself, call typesym."
(typename [o] "Returns Java name as returned by ASM getClassName,
e.g. byte[], java.lang.String[]"))

(declare default-reflector)
10.23. CLJ/CLOJRE/REFLECT.CLJ 1059

(defn type-reflect
"Alpha - subject to change.
Reflect on a typeref, returning a map with :bases, :flags, and
:members. In the discussion below, names are always Clojure symbols.

:bases a set of names of the type’s bases

:flags a set of keywords naming the boolean attributes
of the type.
:members a set of the type’s members. Each membrer is a map
and can be a constructor, method, or field.

Keys common to all members:

:name name of the type
:declaring-class name of the declarer
:flags keyword naming boolean attributes of the member

Keys specific to constructors:

:parameter-types vector of parameter type names
:exception-types vector of exception type names

Key specific to methods:

:parameter-types vector of parameter type names
:exception-types vector of exception type names
:return-type return type name

Keys specific to fields:

:type type name

Options:

:ancestors in addition to the keys described above, also

include an :ancestors key with the entire set of
ancestors, and add all ancestor members to
:members.
:reflector implementation to use. Defaults to JavaReflector,
AsmReflector is also an option."
{:added "1.3"}
[typeref & options]
(let [{:keys [ancestors reflector]}
(merge {:reflector default-reflector}
(apply hash-map options))
refl (partial do-reflect reflector)
result (refl typeref)]
;; could make simpler loop of two args: names an
(if ancestors
(let [make-ancestor-map (fn [names]
(zipmap names (map refl names)))]
(loop [reflections (make-ancestor-map (:bases result))]
(let [ancestors-visited (set (keys reflections))
1060 CHAPTER 10. CLJ/CLOJURE/

ancestors-to-visit
(set/difference (set (mapcat :bases (vals reflections)))
ancestors-visited)]
(if (seq ancestors-to-visit)
(recur
(merge reflections
(make-ancestor-map ancestors-to-visit)))
(apply merge-with into result
{:ancestors ancestors-visited}
(map #(select-keys % [:members]) (vals reflections)))))))
result)))

(defn reflect
"Alpha - subject to change.
Reflect on the type of obj (or obj itself if obj is a class).
Return value and options are the same as for type-reflect. "
{:added "1.3"}
[obj & options]
(apply type-reflect (if (class? obj) obj (class obj)) options))

(load "reflect/java")

———-

10.23.1 reflect/java.clj

— reflect/java.clj —

\getchunk{Clojure Copyright}
(in-ns ’clojure.reflect)

(require ’[clojure.set :as set]

’[clojure.string :as str])
(import ’[clojure.asm ClassReader ClassVisitor Type]
’[java.lang.reflect Modifier]
java.io.InputStream)

(extend-protocol TypeReference
clojure.lang.Symbol
(typename [s] (str/replace (str s) "<>" "[]"))

Class
;; neither .getName not .getSimpleName returns the right thing,
;; so best to delegate to Type
(typename
[c]
(typename (Type/getType c)))
10.23. CLJ/CLOJRE/REFLECT.CLJ 1061

Type
(typename
[t]
(-> (.getClassName t))))

(defn- typesym
"Given a typeref, create a legal Clojure symbol version of the
type’s name."
[t]
(-> (typename t)
(str/replace "[]" "<>")
(symbol)))

(defn- resource-name
"Given a typeref, return implied resource name. Used by Reflectors
such as ASM that need to find and read classbytes from files."
[typeref]
(-> (typename typeref)
(str/replace "." "/")
(str ".class")))

(defn- access-flag
[[name flag & contexts]]
{:name name :flag flag :contexts (set (map keyword contexts))})

(defn- field-descriptor->class-symbol
"Convert a Java field descriptor to a Clojure class symbol. Field
descriptors are described in section 4.3.2 of the JVM spec, 2nd ed.:
http://java.sun.com/docs/books/jvms/second_edition/html/
ClassFile.doc.html#14152"
[^String d]
{:pre [(string? d)]}
(typesym (Type/getType d)))

(defn- internal-name->class-symbol
"Convert a Java internal name to a Clojure class symbol. Internal
names uses slashes instead of dots, e.g. java/lang/String. See
Section 4.2 of the JVM spec, 2nd ed.:

http://java.sun.com/docs/books/jvms/second_edition/html/
ClassFile.doc.html#14757"
[d]
{:pre [(string? d)]}
(typesym (Type/getObjectType d)))

(def ^{:doc "The Java access bitflags, along with their friendly
names and the kinds of objects to which they can apply."}
flag-descriptors
(vec
(map access-flag
1062 CHAPTER 10. CLJ/CLOJURE/

[[:public 0x0001 :class :field :method]

[:private 0x002 :class :field :method]
[:protected 0x0004 :class :field :method]
[:static 0x0008 :field :method]
[:final 0x0010 :class :field :method]
;; :super is ancient history and is unfindable (?) by
;; reflection. skip it
#_[:super 0x0020 :class]
[:synchronized 0x0020 :method]
[:volatile 0x0040 :field]
[:bridge 0x0040 :method]
[:varargs 0x0080 :method]
[:transient 0x0080 :field]
[:native 0x0100 :method]
[:interface 0x0200 :class]
[:abstract 0x0400 :class :method]
[:strict 0x0800 :method]
[:synthetic 0x1000 :class :field :method]
[:annotation 0x2000 :class]
[:enum 0x4000 :class :field :inner]])))

(defn- parse-flags
"Convert reflection bitflags into a set of keywords."
[flags context]
(reduce
(fn [result fd]
(if (and (get (:contexts fd) context)
(not (zero? (bit-and flags (:flag fd)))))
(conj result (:name fd))
result))
#{}
flag-descriptors))

(defrecord Constructor
[name declaring-class parameter-types exception-types flags])

(defn- constructor->map
[^java.lang.reflect.Constructor constructor]
(Constructor.
(symbol (.getName constructor))
(typesym (.getDeclaringClass constructor))
(vec (map typesym (.getParameterTypes constructor)))
(vec (map typesym (.getExceptionTypes constructor)))
(parse-flags (.getModifiers constructor) :method)))

(defn- declared-constructors
"Return a set of the declared constructors of class as a Clojure map."
[^Class cls]
(set (map
constructor->map
10.23. CLJ/CLOJRE/REFLECT.CLJ 1063

(.getDeclaredConstructors cls))))

(defrecord Method
[name return-type declaring-class parameter-types
exception-types flags])

(defn- method->map
[^java.lang.reflect.Method method]
(Method.
(symbol (.getName method))
(typesym (.getReturnType method))
(typesym (.getDeclaringClass method))
(vec (map typesym (.getParameterTypes method)))
(vec (map typesym (.getExceptionTypes method)))
(parse-flags (.getModifiers method) :method)))

(defn- declared-methods
"Return a set of the declared constructors of class as a Clojure map."
[^Class cls]
(set (map
method->map
(.getDeclaredMethods cls))))

(defrecord Field
[name type declaring-class flags])

(defn- field->map
[^java.lang.reflect.Field field]
(Field.
(symbol (.getName field))
(typesym (.getType field))
(typesym (.getDeclaringClass field))
(parse-flags (.getModifiers field) :field)))

(defn- declared-fields
"Return a set of the declared fields of class as a Clojure map."
[^Class cls]
(set (map
field->map
(.getDeclaredFields cls))))

(deftype JavaReflector [classloader]

Reflector
(do-reflect [_ typeref]
(let [cls (Class/forName (typename typeref) false classloader)]
{:bases (not-empty (set (map typesym (bases cls))))
:flags (parse-flags (.getModifiers cls) :class)
:members (set/union (declared-fields cls)
(declared-methods cls)
(declared-constructors cls))})))
1064 CHAPTER 10. CLJ/CLOJURE/

(def ^:private default-reflector

(JavaReflector. (.getContextClassLoader (Thread/currentThread))))

(defn- parse-method-descriptor
[^String md]
{:parameter-types (vec (map typesym (Type/getArgumentTypes md)))
:return-type (typesym (Type/getReturnType md))})

(defprotocol ClassResolver
(^InputStream resolve-class [this name]
"Given a class name, return that typeref’s class bytes
as an InputStream."))

(extend-protocol ClassResolver
clojure.lang.Fn
(resolve-class [this typeref] (this typeref))

ClassLoader
(resolve-class [this typeref]
(.getResourceAsStream this (resource-name typeref))))

(deftype AsmReflector [class-resolver]

Reflector
(do-reflect [_ typeref]
(with-open [is (resolve-class class-resolver typeref)]
(let [class-symbol (typesym typeref)
r (ClassReader. is)
result (atom {:bases #{} :flags #{} :members #{}})]
(.accept
r
(reify
ClassVisitor
(visit [_ version access name signature superName interfaces]
(let [flags (parse-flags access :class)
;; ignore java.lang.Object on interfaces to match reflection
superName (if (and (flags :interface)
(= superName "java/lang/Object"))
nil
superName)
bases (->> (cons superName interfaces)
(remove nil?)
(map internal-name->class-symbol)
(map symbol)
(set)
(not-empty))]
(swap! result merge {:bases bases
:flags flags})))
(visitSource [_ name debug])
(visitInnerClass [_ name outerName innerName access])
10.23. CLJ/CLOJRE/REFLECT.CLJ 1065

(visitField [_ access name desc signature value]

(swap! result update-in [:members] (fnil conj #{})
(Field. (symbol name)
(field-descriptor->class-symbol desc)
class-symbol
(parse-flags access :field)))
nil)
(visitMethod [_ access name desc signature exceptions]
(when-not (= name "<clinit>")
(let [constructor? (= name "<init>")]
(swap! result update-in
[:members] (fnil conj #{})
(let [{:keys
[parameter-types return-type]}
(parse-method-descriptor desc)
flags
(parse-flags access :method)]
(if constructor?
(Constructor. class-symbol
class-symbol
parameter-types
(vec
(map
internal-name->class-symbol
exceptions))
flags)
(Method. (symbol name)
return-type
class-symbol
parameter-types
(vec
(map
internal-name->class-symbol
exceptions))
flags))))))
nil)
(visitEnd [_])
) 0)
@result))))

———-
1066 CHAPTER 10. CLJ/CLOJURE/
Chapter 11

Copyright and Licenses

— Clojure License —

Eclipse Public License - v 1.0

THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE

PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF
THE PROGRAM CONSTITUTES RECIPIENT’S ACCEPTANCE OF THIS AGREEMENT.

1. DEFINITIONS

"Contribution" means:

a) in the case of the initial Contributor, the initial code and

documentation distributed under this Agreement, and

b) in the case of each subsequent Contributor:

i) changes to the Program, and

ii) additions to the Program;

where such changes and/or additions to the Program originate from and
are distributed by that particular Contributor. A Contribution
’originates’ from a Contributor if it was added to the Program by such
Contributor itself or anyone acting on such Contributor’s
behalf. Contributions do not include additions to the Program which:
(i) are separate modules of software distributed in conjunction with
the Program under their own license agreement, and (ii) are not
derivative works of the Program.

"Contributor" means any person or entity that distributes the Program.

1067
1068 CHAPTER 11. COPYRIGHT AND LICENSES

"Licensed Patents" mean patent claims licensable by a Contributor

which are necessarily infringed by the use or sale of its Contribution
alone or when combined with the Program.

"Program" means the Contributions distributed in accordance with this

Agreement.

"Recipient" means anyone who receives the Program under this

Agreement, including all Contributors.

2. GRANT OF RIGHTS

a) Subject to the terms of this Agreement, each Contributor hereby

grants Recipient a non-exclusive, worldwide, royalty-free copyright
license to reproduce, prepare derivative works of, publicly display,
publicly perform, distribute and sublicense the Contribution of such
Contributor, if any, and such derivative works, in source code and
object code form.

b) Subject to the terms of this Agreement, each Contributor hereby

grants Recipient a non-exclusive, worldwide, royalty-free patent
license under Licensed Patents to make, use, sell, offer to sell,
import and otherwise transfer the Contribution of such Contributor, if
any, in source code and object code form. This patent license shall
apply to the combination of the Contribution and the Program if, at
the time the Contribution is added by the Contributor, such addition
of the Contribution causes such combination to be covered by the
Licensed Patents. The patent license shall not apply to any other
combinations which include the Contribution. No hardware per se is
licensed hereunder.

c) Recipient understands that although each Contributor grants the

licenses to its Contributions set forth herein, no assurances are
provided by any Contributor that the Program does not infringe the
patent or other intellectual property rights of any other entity. Each
Contributor disclaims any liability to Recipient for claims brought by
any other entity based on infringement of intellectual property rights
or otherwise. As a condition to exercising the rights and licenses
granted hereunder, each Recipient hereby assumes sole responsibility
to secure any other intellectual property rights needed, if any. For
example, if a third party patent license is required to allow
Recipient to distribute the Program, it is Recipient’s responsibility
to acquire that license before distributing the Program.

d) Each Contributor represents that to its knowledge it has sufficient

3. REQUIREMENTS
1069

A Contributor may choose to distribute the Program in object code form

under its own license agreement, provided that:

a) it complies with the terms and conditions of this Agreement; and

b) its license agreement:

i) effectively disclaims on behalf of all Contributors all warranties

and conditions, express and implied, including warranties or
conditions of title and non-infringement, and implied warranties or
conditions of merchantability and fitness for a particular purpose;

ii) effectively excludes on behalf of all Contributors all liability

for damages, including direct, indirect, special, incidental and
consequential damages, such as lost profits;

iii) states that any provisions which differ from this Agreement are
offered by that Contributor alone and not by any other party; and

iv) states that source code for the Program is available from such
Contributor, and informs licensees how to obtain it in a reasonable
manner on or through a medium customarily used for software exchange.

When the Program is made available in source code form:

a) it must be made available under this Agreement; and

b) a copy of this Agreement must be included with each copy of the

Program.

Contributors may not remove or alter any copyright notices contained

within the Program.

Each Contributor must identify itself as the originator of its

Contribution, if any, in a manner that reasonably allows subsequent
Recipients to identify the originator of the Contribution.

4. COMMERCIAL DISTRIBUTION

Commercial distributors of software may accept certain

responsibilities with respect to end users, business partners and the
like. While this license is intended to facilitate the commercial use
of the Program, the Contributor who includes the Program in a
commercial product offering should do so in a manner which does not
create potential liability for other Contributors. Therefore, if a
Contributor includes the Program in a commercial product offering,
such Contributor ("Commercial Contributor") hereby agrees to defend
and indemnify every other Contributor ("Indemnified Contributor")
against any losses, damages and costs (collectively "Losses") arising
1070 CHAPTER 11. COPYRIGHT AND LICENSES

from claims, lawsuits and other legal actions brought by a third party
against the Indemnified Contributor to the extent caused by the acts
or omissions of such Commercial Contributor in connection with its
distribution of the Program in a commercial product offering. The
obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property
infringement. In order to qualify, an Indemnified Contributor must: a)
promptly notify the Commercial Contributor in writing of such claim,
and b) allow the Commercial Contributor to control, and cooperate with
the Commercial Contributor in, the defense and any related settlement
negotiations. The Indemnified Contributor may participate in any such
claim at its own expense.

For example, a Contributor might include the Program in a commercial

product offering, Product X. That Contributor is then a Commercial
Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance
claims and warranties are such Commercial Contributor’s responsibility
alone. Under this section, the Commercial Contributor would have to
defend claims against the other Contributors related to those
performance claims and warranties, and if a court requires any other
Contributor to pay any damages as a result, the Commercial Contributor
must pay those damages.

5. NO WARRANTY

EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS

PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
responsible for determining the appropriateness of using and
distributing the Program and assumes all risks associated with its
exercise of rights under this Agreement , including but not limited to
the risks and costs of program errors, compliance with applicable
laws, damage to or loss of data, programs or equipment, and
unavailability or interruption of operations.

6. DISCLAIMER OF LIABILITY

EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR

ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

7. GENERAL
1071

If any provision of this Agreement is invalid or unenforceable under

applicable law, it shall not affect the validity or enforceability of
the remainder of the terms of this Agreement, and without further
action by the parties hereto, such provision shall be reformed to the
minimum extent necessary to make such provision valid and enforceable.

If Recipient institutes patent litigation against any entity

(including a cross-claim or counterclaim in a lawsuit) alleging that
the Program itself (excluding combinations of the Program with other
software or hardware) infringes such Recipient’s patent(s), then such
Recipient’s rights granted under Section 2(b) shall terminate as of
the date such litigation is filed.

All Recipient’s rights under this Agreement shall terminate if it

fails to comply with any of the material terms or conditions of this
Agreement and does not cure such failure in a reasonable period of
time after becoming aware of such noncompliance. If all Recipient’s
rights under this Agreement terminate, Recipient agrees to cease use
and distribution of the Program as soon as reasonably
practicable. However, Recipient’s obligations under this Agreement and
any licenses granted by Recipient relating to the Program shall
continue and survive.

Everyone is permitted to copy and distribute copies of this Agreement,

but in order to avoid inconsistency the Agreement is copyrighted and
may only be modified in the following manner. The Agreement Steward
reserves the right to publish new versions (including revisions) of
this Agreement from time to time. No one other than the Agreement
Steward has the right to modify this Agreement. The Eclipse Foundation
is the initial Agreement Steward. The Eclipse Foundation may assign
the responsibility to serve as the Agreement Steward to a suitable
separate entity. Each new version of the Agreement will be given a
distinguishing version number. The Program (including Contributions)
may always be distributed subject to the version of the Agreement
under which it was received. In addition, after a new version of the
Agreement is published, Contributor may elect to distribute the
Program (including its Contributions) under the new version. Except as
expressly stated in Sections 2(a) and 2(b) above, Recipient receives
no rights or licenses to the intellectual property of any Contributor
under this Agreement, whether expressly, by implication, estoppel or
otherwise. All rights in the Program not expressly granted under this
Agreement are reserved.

This Agreement is governed by the laws of the State of New York and
the intellectual property laws of the United States of America. No
party to this Agreement will bring a legal action under this Agreement
more than one year after the cause of action arose. Each party waives
its rights to a jury trial in any resulting litigation.
1072 CHAPTER 11. COPYRIGHT AND LICENSES

———-

— Clojure Copyright —

; Copyright (c) Rich Hickey. All rights reserved. The use and
; distribution terms for this software are covered by the Eclipse
; Public License 1.0
; (http://opensource.org/licenses/eclipse-1.0.php) which can be
; found in the file epl-v10.html at the root of this distribution.
; By using this software in any fashion, you are agreeing to be
; bound by the terms of this license. You must not remove this
; notice, or any other, from this software.

———-

— France Telecom Copyright —

/***
* ASM: a very small and fast Java bytecode manipulation framework
* Copyright (c) 2000-2005 INRIA, France Telecom
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
1073

———-
1074 CHAPTER 11. COPYRIGHT AND LICENSES
Bibliography

[1] Bagwell, Phil “Fast and space efficient trie searches” Technical Report
EPFL (2000) http://lampwww.epfl.ch/papers/triesearches.pdf.gz
[2] Bagwell, Phil “Ideal Hash Trees” Es Grands Champs (2001)
[3] Daly, Timothy,
“Knuth’s literate programming ”tangle” function
in Clojure” groups.google.com/group/clojure
thread /browse_thread/thread/664a1d305f32ab90
[4] Okasaki, Chris “Purely Functional Data Structures” Cambridge University
Press (1998) ISBN 0-521-66350-4

[5] Queinnec, Christian “Lisp in Small Pieces” Cambridge University Press

(1994) ISBN 0-521-56247-3

1075
1076 BIBLIOGRAPHY
Chapter 12

Index

1077
Index

Black in PersistentTreeMap defclass, 3

defclass, 3 PersistentTreeMap$BlackBranch, 4
BlackBranch in PersistentTreeMap defclass, 4
defclass, 4 PersistentTreeMap$BlackBranchVal, 5
BlackBranchVal in PersistentTreeMap defclass, 5
defclass, 5 PersistentTreeMap$BlackVal, 4
BlackVal in PersistentTreeMap defclass, 4
defclass, 4 PersistentTreeMap$KeyIterator, 13
defclass, 13
defclass PersistentTreeMap$NodeIterator, 12
Node, 1 defclass, 12
PersistentTreeMap, 9 PersistentTreeMap$Red, 5
PersistentTreeMap$Black, 3 defclass, 5
PersistentTreeMap$BlackBranch, 4 PersistentTreeMap$RedBranch, 7
PersistentTreeMap$BlackBranchVal, defclass, 7
5 PersistentTreeMap$RedBranchVal, 8
PersistentTreeMap$BlackVal, 4 defclass, 8
PersistentTreeMap$KeyIterator, 13 PersistentTreeMap$RedVal, 6
PersistentTreeMap$NodeIterator, 12 defclass, 6
PersistentTreeMap$Red, 5 PersistentTreeMap$Seq, 9
PersistentTreeMap$RedBranch, 7 defclass, 9
PersistentTreeMap$RedBranchVal, PersistentTreeMap$ValIterator, 14
8 defclass, 14
PersistentTreeMap$RedVal, 6
PersistentTreeMap$Seq, 9 Red in PersistentTreeMap
PersistentTreeMap$ValIterator, 14 defclass, 5
RedBranch in PersistentTreeMap
KeyIterator in PersistentTreeMap defclass, 7
defclass, 13 RedBranchVal in PersistentTreeMap
defclass, 8
Node, 1 RedVal in PersistentTreeMap
defclass, 1 defclass, 6
NodeIterator in PersistentTreeMap
defclass, 12 Seq in PersistentTreeMap
defclass, 9
PersistentTreeMap, 9
defclass, 9 ValIterator in PersistentTreeMap
PersistentTreeMap$Black, 3 defclass, 14

1078

2 Upstream c1 3rdedition Test 02
No ratings yet
2 Upstream c1 3rdedition Test 02
2 pages
Torque 2.7 Sebring
No ratings yet
Torque 2.7 Sebring
1 page
Machine Learning Masterclass
100% (11)
Machine Learning Masterclass
108 pages
Schaum's Outline of Programming with Java
From Everand
Schaum's Outline of Programming with Java
John R. Hubbard
3/5 (2)
Complete Audio Mastering: Practical Techniques
From Everand
Complete Audio Mastering: Practical Techniques
Gebre E. Waddell
5/5 (5)
Dart Language Specification
No ratings yet
Dart Language Specification
122 pages
Pysheeet KR Readthedocs Io Ko Latest
No ratings yet
Pysheeet KR Readthedocs Io Ko Latest
269 pages
Dart Language Specification
No ratings yet
Dart Language Specification
111 pages
Ltxcmds PDF
No ratings yet
Ltxcmds PDF
35 pages
The Ltxcmds Package: Heiko Oberdiek 2020-05-10 v1.25
No ratings yet
The Ltxcmds Package: Heiko Oberdiek 2020-05-10 v1.25
35 pages
Clo Jure
No ratings yet
Clo Jure
1,742 pages
Manual Copasi PDF
No ratings yet
Manual Copasi PDF
139 pages
GCC Fastjar
No ratings yet
GCC Fastjar
61 pages
The Ocaml System Release 4.13: Documentation and User'S Manual
No ratings yet
The Ocaml System Release 4.13: Documentation and User'S Manual
876 pages
Dart Language Specification
100% (1)
Dart Language Specification
123 pages
Durexforth-V2 0 0
No ratings yet
Durexforth-V2 0 0
32 pages
W1 Trial Design Final Workbook
No ratings yet
W1 Trial Design Final Workbook
59 pages
Simple-Mvc Documentation: Release 0.1.0
No ratings yet
Simple-Mvc Documentation: Release 0.1.0
25 pages
Mathematical Typesetting With LATEX
100% (1)
Mathematical Typesetting With LATEX
221 pages
Concepts of Programming With Java
No ratings yet
Concepts of Programming With Java
91 pages
RE For Beginners-En
No ratings yet
RE For Beginners-En
247 pages
Ocaml 4.11 Refman
No ratings yet
Ocaml 4.11 Refman
822 pages
ocaml-4.14-refman
No ratings yet
ocaml-4.14-refman
931 pages
R Ints
No ratings yet
R Ints
63 pages
Tim Hieu Ve Deep Learning
100% (1)
Tim Hieu Ve Deep Learning
78 pages
Introduction To Matlab
100% (24)
Introduction To Matlab
68 pages
Solution Space of A Homogeneous Linear Differential Equation
No ratings yet
Solution Space of A Homogeneous Linear Differential Equation
37 pages
Econometrics in R
No ratings yet
Econometrics in R
34 pages
Yay Documentation: Release 3.1.2.dev0
No ratings yet
Yay Documentation: Release 3.1.2.dev0
47 pages
R Internals: R Development Core Team
No ratings yet
R Internals: R Development Core Team
48 pages
Apcalcprobbook Mccaffrey Revised
No ratings yet
Apcalcprobbook Mccaffrey Revised
216 pages
Matlab
No ratings yet
Matlab
87 pages
Java Structures
No ratings yet
Java Structures
542 pages
An Introduction To Python
No ratings yet
An Introduction To Python
115 pages
L TEX Maths and Graphics: A Tim Love July 27, 2006
No ratings yet
L TEX Maths and Graphics: A Tim Love July 27, 2006
16 pages
Learning Rust Notes
No ratings yet
Learning Rust Notes
106 pages
Stable Baselines
No ratings yet
Stable Baselines
239 pages
R Ints 3
No ratings yet
R Ints 3
69 pages
R Ints
No ratings yet
R Ints
72 pages
R Ints PDF
No ratings yet
R Ints PDF
63 pages
CK 12 Basic Algebra Concepts B v16 Jli s1
100% (1)
CK 12 Basic Algebra Concepts B v16 Jli s1
780 pages
The AP Calculus Problem Book: Chuck Garner, PH.D
No ratings yet
The AP Calculus Problem Book: Chuck Garner, PH.D
216 pages
(Ebook) Programming ERLANG: Software for a Concurrent World by Joe Armstrong ISBN 9781934356005, 193435600X - The latest ebook edition with all chapters is now available
100% (1)
(Ebook) Programming ERLANG: Software for a Concurrent World by Joe Armstrong ISBN 9781934356005, 193435600X - The latest ebook edition with all chapters is now available
49 pages
Dart Lang Spec
No ratings yet
Dart Lang Spec
80 pages
cookbook
No ratings yet
cookbook
58 pages
Document
No ratings yet
Document
234 pages
Programming the Intel Galileo: Getting Started with the Arduino -Compatible Development Board
From Everand
Programming the Intel Galileo: Getting Started with the Arduino -Compatible Development Board
Christopher Rush
5/5 (1)
Quasi-Monte Carlo Methods in Finance: With Application to Optimal Asset Allocation
From Everand
Quasi-Monte Carlo Methods in Finance: With Application to Optimal Asset Allocation
Mario Rometsch
No ratings yet
Design and Analysis of Distributed Algorithms
From Everand
Design and Analysis of Distributed Algorithms
Nicola Santoro
No ratings yet
Pollution Prevention: Methodology, Technologies and Practices
From Everand
Pollution Prevention: Methodology, Technologies and Practices
Kenneth L. Mulholland
No ratings yet
Gray Hat Hacking the Ethical Hacker's
From Everand
Gray Hat Hacking the Ethical Hacker's
Çağatay Şanlı
5/5 (1)
Excel VBA Macro Programming
From Everand
Excel VBA Macro Programming
Richard Shepherd
No ratings yet
Automatic Speech and Speaker Recognition: Large Margin and Kernel Methods
From Everand
Automatic Speech and Speaker Recognition: Large Margin and Kernel Methods
Joseph Keshet
No ratings yet
Structural Dynamics in Industry
From Everand
Structural Dynamics in Industry
Alain Girard
No ratings yet
PHP Programming Solutions
From Everand
PHP Programming Solutions
Vikram Vaswani
No ratings yet
Control Systems
From Everand
Control Systems
Francisco Luis Pagola y de las Heras
No ratings yet
Presentations with LaTeX: Which package, which command, which syntax?
From Everand
Presentations with LaTeX: Which package, which command, which syntax?
Herbert Voß
No ratings yet
Uncertainty Analysis with High Dimensional Dependence Modelling
From Everand
Uncertainty Analysis with High Dimensional Dependence Modelling
Dorota Kurowicka
No ratings yet
Location-Based Services: Fundamentals and Operation
From Everand
Location-Based Services: Fundamentals and Operation
Axel Küpper
No ratings yet
Stochastic Methods and their Applications to Communications: Stochastic Differential Equations Approach
From Everand
Stochastic Methods and their Applications to Communications: Stochastic Differential Equations Approach
Serguei Primak
No ratings yet
3D Printer Projects for Makerspaces
From Everand
3D Printer Projects for Makerspaces
Lydia Sloan Cline
4/5 (1)
Semiparametric Regression for the Social Sciences
From Everand
Semiparametric Regression for the Social Sciences
Luke John Keele
3/5 (1)
(ACC) 3B - Acara 3 - MIkroper
No ratings yet
(ACC) 3B - Acara 3 - MIkroper
13 pages
CASE DIGEST Labor Law Classification of Employment
No ratings yet
CASE DIGEST Labor Law Classification of Employment
8 pages
90 Series: Filter Characteristics
No ratings yet
90 Series: Filter Characteristics
8 pages
Ifs Ssrana Pchopra
No ratings yet
Ifs Ssrana Pchopra
100 pages
A Guide To Qualitative Research
No ratings yet
A Guide To Qualitative Research
14 pages
Silabus (Fil100) J1a
No ratings yet
Silabus (Fil100) J1a
9 pages
Chapter 20 Issuing Securities To The Public
No ratings yet
Chapter 20 Issuing Securities To The Public
34 pages
Claparols Vs CIR
No ratings yet
Claparols Vs CIR
7 pages
2.smart Logic System For Interlocks and Protections of Boilers in A Thermal Power Plant PDF
No ratings yet
2.smart Logic System For Interlocks and Protections of Boilers in A Thermal Power Plant PDF
7 pages
Crypt Analysis Using Simple Logical and Complement Operation
No ratings yet
Crypt Analysis Using Simple Logical and Complement Operation
3 pages
Tattooing and Body Piercing Guidance Toolkit July 2013
No ratings yet
Tattooing and Body Piercing Guidance Toolkit July 2013
66 pages
Brochure Daihatsu Copen
No ratings yet
Brochure Daihatsu Copen
5 pages
B.Tech CSC - IV Sem Quiz II (19/02/19) Time: 30 Min. Marks:10 (Weightage:2.5) Name: Lms Id No
No ratings yet
B.Tech CSC - IV Sem Quiz II (19/02/19) Time: 30 Min. Marks:10 (Weightage:2.5) Name: Lms Id No
1 page
Reported Speech Erklärung Wichtig
No ratings yet
Reported Speech Erklärung Wichtig
3 pages
Course Outline
No ratings yet
Course Outline
4 pages
Unit6 Test
No ratings yet
Unit6 Test
3 pages
F 22 Raptor Out of Popsicle Sticks
No ratings yet
F 22 Raptor Out of Popsicle Sticks
43 pages
XII UNIT-01 PYQ 2024-25-1
No ratings yet
XII UNIT-01 PYQ 2024-25-1
17 pages
Immunotherapy: Collected by Muhammad Khalil, KUMS-student
No ratings yet
Immunotherapy: Collected by Muhammad Khalil, KUMS-student
3 pages
Mark Drakeford & Kevin Brennan Letter To Planning Committee Re Creigiau Quarry
No ratings yet
Mark Drakeford & Kevin Brennan Letter To Planning Committee Re Creigiau Quarry
2 pages
Really Good Packaging Explained Ocr
100% (9)
Really Good Packaging Explained Ocr
273 pages
AQA English Language Sample Paper 1c
No ratings yet
AQA English Language Sample Paper 1c
5 pages
City of Ember Worksheet
No ratings yet
City of Ember Worksheet
1 page
EAP Law Unit3 Types - Businesses v5
No ratings yet
EAP Law Unit3 Types - Businesses v5
50 pages
Learning Module Dihybrid
No ratings yet
Learning Module Dihybrid
36 pages
GISMA - M503 - Nutrorim - Case Study 2021 06 06
No ratings yet
GISMA - M503 - Nutrorim - Case Study 2021 06 06
8 pages
Body Care 1
No ratings yet
Body Care 1
16 pages
Ygg 01
0% (1)
Ygg 01
30 pages