\documentclass{book}
\usepackage{verbatim}
\usepackage{makeidx}
\usepackage{pstricks}
\usepackage{pst-node}
\usepackage{pst-tree}
\usepackage{hyperref}
% make underscore be an ordinary character
\catcode`\_=12 
% we need to have an index
\makeindex
\raggedbottom

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Define tags to make refs and indexes pretty
\newcommand{\defclass}[1]{% e.g. \defclass{classname}
\label{#1}%
\index{#1}%
\index{Class!#1}%
\index{#1!Class}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Define tags to make refs and indexes pretty
\newcommand{\defsubclass}[2]{% e.g. \defsubclass{classname}{subclassname}
\label{#2}%
\index{#1\$#2}%
\index{Class!#2\ in\ \pageref{#1}}%
\index{#2,\ class in\ \pageref{#1}}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Define tags to make refs and indexes pretty
\newcommand{\definterface}[1]{% e.g. \definterface{ifname}
\label{#1}%
\index{#1}%
\index{Interface!#1}%
\index{#1!Interface}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Define tags to make refs and indexes pretty
\newcommand{\defmethod}[2]{% e.g. \defmethod{classname}{methodname}
\label{#2}%
\index{#1.#2}%
\index{#2,\ method\ in\ \pageref{#1}}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Define tags to make refs and indexes pretty
\newcommand{\implements}[2]{% e.g. \implements{class}{interface}
(#2 [\pageref{#2}])%
\index{Implements!#2,\ by\ #1}%
\index{#1!\ implements\ \pageref{#2}}%
\index{#2!\ implemented\ by\ \pageref{#1}}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Define tags to make refs and indexes pretty
\newcommand{\extends}[2]{% e.g. \extends{class}{interface}
(#2 [\pageref{#2}])%
\index{Extends!#2,\ by\ #1}%
\index{#1!\ extends\ \pageref{#2}}%
\index{#2!\ extended\ by\ \pageref{#1}}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make our own sectioning commands
\newcommand{\defsection}[1]{% e.g. \defsection{sectionname}
\section{#1}%
\label{#1}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make our own sectioning commands
\newcommand{\defsubsection}[1]{% e.g. \defsubsection{sectionname}
\subsection{{#1}}%
\label{#1}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make our own references so we can have hyperlinks in pdfs
\newcommand{\refto}[1]{% e.g. \refto{name}
\index{#1}%
[\pageref{#1}] #1}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% a pretty box around some example text for quoting and examples
%%% boxed{boxcolor}{textcolor}{width}{text}
%%% boxed{yellow}{black}{4.6in}{text}
\providecommand\boxed[4]{% \boxed{boxcolor}{textcolor}{width}{text}
\begin{center}
\begin{tabular}{|c|}
\hline
\fcolorbox{#1}{#2}{
\begin{minipage}{#3}
\normalsize
{#4}\hfill
\end{minipage}}\\
\hline
\end{tabular}
\end{center}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% a colored box around quotes
%%% boxed{boxcolor}{textcolor}{width}{text}
%%% boxed{yellow}{black}{4.6in}{text}
\providecommand\quoteme[4]{% \boxed{boxcolor}{textcolor}{width}{text}
\begin{center}
\fcolorbox{#1}{#2}{
\begin{minipage}{#3}
\normalsize
{#4}\hfill
\end{minipage}}\\
\end{center}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% define the text and background colors for REPL boxes
\definecolor{ExampleTextColor}{rgb}{0.5 1.0 1.0}
\definecolor{ExampleBackColor}{rgb}{0.5.0.0 0.0}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% a colored box around quotes
%%% boxed{boxcolor}{textcolor}{width}{text}
%%% boxed{yellow}{black}{4.6in}{text}
\providecommand\forexample[1]{% \boxed{boxcolor}{textcolor}{width}{text}
\begin{center}
\fcolorbox{ExampleBackColor}{ExampleTextColor}{
\begin{minipage}{4.6in}
\normalsize
{#1}\hfill
\end{minipage}}\\
\end{center}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% REPL shows a prompt line and the response
%%% e.g. repl{(+ 2 3)}{5}
\providecommand\repl[2]{% \repl{input}{output}
\forexample{\noindent$>$\ {#1}\\{#2}}}


%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% The literate environments commands %%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% The begin{chunk} environment
\newenvironment{chunk}[1]{%   we need the chunkname as an argument
{\ }\newline\noindent%                    make sure we are in column 1
%{\small $\backslash{}$begin\{chunk\}\{{\bf #1}\}}% alternate begin mark
\hbox{\hskip 2.0cm}{\bf --- #1 ---}%      mark the beginning
\verbatim}%                               say exactly what we see
{\endverbatim%                            process \end{chunk}
\par{}%                                   we add a newline
\noindent{}%                              start in column 1
\hbox{\hskip 2.0cm}{\bf ----------}%      mark the end
%$\backslash{}$end\{chunk\}%              alternate end mark (commented)
\par%                                     and a newline
\normalsize\noindent}%                    and return to the document

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% the getchunk command
\providecommand{\getchunk}[1]{%
\noindent%
{\small $\backslash{}$begin\{chunk\}\{{\bf #1}\}}% mark the reference
\index{{#1}}}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% make the chunk font smaller
\chardef\atcode=\catcode`\@
\catcode`\@=11
\renewcommand{\verbatim@font}{\ttfamily\small}
\catcode`\@=\atcode

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% we need a single column index so write our own
\renewenvironment{theindex}{
 {\Huge {\bf {\hskip 1.0in}Index}}%
 \thispagestyle{plain}%    \parindent\z@%
 \begin{itemize}%
 \setlength{\itemsep}{1pt}%
 \setlength{\parskip}{0pt}%
 \setlength{\parsep}{0pt}%
}{\end{itemize}\clearpage}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% we need a packed itemize so write our own
\newenvironment{packeditemize}{%
\begin{itemize}%
\setlength{\itemsep}{1pt}%
\setlength{\parskip}{0pt}%
\setlength{\parsep}{0pt}%
}{\end{itemize}}


%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% leave notes for future work
\newcommand{\tpdhere}[1]{% e.g. \tpdhere{Some note}
{\bf TPDHERE: #1}%
\index{TPDHERE!{#1}}}

\begin{document}
\begin{titlepage}
%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make the front cover picture
%\center{\includegraphics{ps/clojurecover.eps}}
\vskip 0.1in
%\includegraphics{ps/bluebayou.ps}\\

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make sure everyone gets credit
\begin{center}
{\vbox {\vskip 2.0in {\Huge {Clojure In Small Pieces}}}}
{\vbox {\vskip 0.5in {\Large {Rich Hickey}}}}
{\vbox {\vskip 0.5in {
\begin{tabular}{lll}
Juozas Baliuka & Eric Bruneton & Chas Emerick \\
Tom Faulhaber & Stephen C. Gilardi & Daniel Solano Gómez \\
Christophe Grand & Stuart Halloway & Mike Hinchey  \\
Shawn Hoover & Chris Houser & Rajendra Inamdar \\
Eugene Kuleshov & Robert Lachlan & J. McConnell \\
Chris Nokleberg & Allen Rohner & Michel Salim \\
Jason Sankey  & Stuart Sierra & Frantisek Sodomka \\
Vishal Vishnoi &&\\
\end{tabular}
}}}
{\vbox {\vskip 1.0in {\Large {Timothy Daly (Editor)}}}}
{\vbox {\vskip 0.2in {Based on Version 1.3.0-alpha4}}}
{\vbox {\vskip 0.1in {\today}}}
\end{center}
\vskip 0.1in
\end{titlepage}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Use roman numeral pages for frontmatter
\pagenumbering{roman}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% because I add lines to the toc, the toc is 4.5pts too wide
%%% so I use this hack to fix it -- TimDaly
\makeatletter
\renewcommand{\@pnumwidth}{2.75em}
\renewcommand{\@tocrmarg}{2.75em}
\makeatother
\tableofcontents
\vfill
\eject

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make the forward be business block text style
\setlength{\parindent}{0em}
\setlength{\parskip}{1ex}
{\Large{\bf Foreword}}
\vskip .25in

Rich Hickey invented Clojure. This is a fork of the 
project to experiment with literate programming as a development
and documentation technology.

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.  As such
it is intended as an experiment, not a replacement or competition with
the official version of Clojure.

Most programmers are still locked into the idea of making a program
out of a large pile of tiny files containing pieces of programs.
They do not realize that this organization was forced by the fact
that machines like the PDP 11 only had 8k of memory and a limit
of 4k buffers in the editor. Thus there was a lot of machinery built
up, such as overlay linkers, to try to reconstruct the whole program.

The time has come to move into a more rational means of creating and
maintaining programs. Knuth suggested we write programs like we write
literature, with the idea that we are trying to communicate the ideas
to other people. The fact that the machine can also run the programs
is a useful side-effect but not important.

Very few people have seen a literate program so this is intended 
as a complete working example, published in book form. The intent
is that you can sit and read this book like any other novel. At 
the end of it you will be familiar with the ideas and how those
ideas are actually expressed in the code.

If programmers can read it and understand it then they can maintain
and modify it. The ideas will have been communicated. The code will
be changed to match changes in the idea. We will all benefit.

I've tried to make it as simple as possible. 
Try it once, you might like it.

\vskip .25in
%\noindent
Tim Daly\\
December 28, 2010 ((iHy))
\vfill
\eject

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Start using regular numbers
\pagenumbering{arabic}
\setcounter{chapter}{0} % Chapter 1
%\textunderscore

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% fix the preface in the table of contents
\frontmatter

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Preface  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make this fake chapter show up in the table of contents
\cleardoublepage
\phantomsection
{\bf {\Large Preface: Why Literate Programming}}
\addcontentsline{toc}{chapter}{Preface: Why Literate Programming}

{\vbox {\vskip 0.3in}}

This is a literate program, inspired by Donald Knuth \cite{Knu84}. It is
intended to be read like a novel from cover to cover. The ideas are 
expressed clearly but they are grounded in the actual source code.

The code in this documment is the executable source. The appendix gives
the procedure for building a running system from the enclosed sources.

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make this fake section show up in the table of contents
{\bf {\large Steps to build Clojure}}
\addcontentsline{toc}{section}{Steps to build Clojure}
{\vbox {\vskip 0.1in}}

{\bf Step 1}

Basically you need the C program \refto{tangle.c} which you can clip
using a text editor and save it as tangle.c.

{\bf Step 2}

Compile tangle.c to create a function called tangle.
\begin{verbatim}
gcc -o tangle tangle.c
\end{verbatim}

{\bf Step 3}
Run tangle to extract the \refto{Makefile} from this document.
\begin{verbatim}
tangle clojure.pamphlet Makefile >Makefile
\end{verbatim}

{\bf Step 4}
\begin{verbatim}
make
\end{verbatim}

This will 
\begin{packeditemize}
\item create a new subdirectory called ``tpd'' containing
all of the source code
\item test Clojure
\item create a running copy of Clojure
\item create the pdf
\item start a Clojure REPL
\end{packeditemize}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make this fake section show up in the table of contents
{\vbox {\vskip 0.1in}}
{\bf {\large Steps to change Clojure}}
\addcontentsline{toc}{section}{Steps to change Clojure}
{\vbox {\vskip 0.1in}}

If you make changes to this document and want the new changes 
just type:
\begin{verbatim}
rm -rf tpd 
tangle clojure.pamphlet Makefile >Makefile 
make
\end{verbatim}
 
or you can combine them into one line:
\begin{verbatim}
rm -rf tpd && tangle clojure.pamphlet Makefile >Makefile && make
\end{verbatim}

This will destroy the old source, extract the Makefile, and rebuild
the system. On a fast processor this takes about a minute.

Resist the urge to edit the files in the tpd directory.
They are only there for the compiler. Edit this file directly.

You can change where Clojure is built. In the \refto{Makefile}
there is a line which defines the root of the directory build.
You can change this or override it on the command line to build
Clojure elsewhere.
\begin{verbatim}
WHERE=tpd
\end{verbatim}

To build a second copy of Clojure, or to work in some other directory,
just type
\begin{verbatim}
make WHERE=newplace
\end{verbatim}

%%% Tim Daly %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Make this fake section show up in the table of contents
{\vbox {\vskip 0.1in}}
{\bf {\large Why Bother?}}
\addcontentsline{toc}{section}{Why Bother?}
{\vbox {\vskip 0.1in}}

Why bother with such a difficult method of programming? Because 
worthwhile programs should ``live''.

Programs ``live'' because people maintain them. Maintaining and
modifying code correctly requires that you understand why the program
is written as it is, what the key ideas that make the program work,
and why certain, not very obvious, pieces of code exist. Programmers
almost never write this information down anywhere. Great ideas are
invented, the code is written, a man page of documentation is created,
and the job is done.

Well, almost. What does is mean for a program to ``live''? How does a
program survive once the original developers leave the project? There
are many sources of information but almost no source of knowledge.
New programmers don't know what the ``elders'' know. In order to ``live''
and continue to grow there has to be a way to transmit this knowledge.

Literate programming is Knuth's proposed idea for moving from the
world of ideas to the world of information. This is not simply another
documentation format. This is meant to be {\bf Literature}. The ideas
are presented, the implications are explored, the tradeoffs are discussed,
and the code is ``motivated'', like characters in a novel.

You are encouraged to write or rewrite sections of this document to
improve the communication with the readers.

``But I have to learn latex!''. Well, for this document you do.
But \LaTeX is just more than a document markup language like
HTML and it is no harder to learn. It gives you the added advantage
that you have a real language for publishing real documents. Most
books are typeset with this technology and a lot of conferences
and Journals require it. If you can learn Clojure, you can learn
\LaTeX. If you're a programmer you will always need to continue
to learn, at least until you retire into management.

Having used literate programming for years I have collected some key
quotes that might stimulate your interest.

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
I believe that the time is ripe for significantly better documentation
of programs, and that we can best achieve this by considering programs
to be works of literature. Hence, my title ``Literate Programming''. 
Let us change our traditional attitude to the construction of programs.
Instead of imagining that our main task is to instruct a computer what to 
do, let us concentrate on explaining to human beings what we want a
computer to do.

{\bf --Donald Knuth ``Literate Programming (1984)''}}


\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
Step away from the machine. Literate programming has nothing to do with
tools or style. It has very little to do with programming. One of the
hard transitions to literate programming is ``literate thinking''.

{\bf --Timothy Daly in Lambda the Ultimate (2010)}}

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
The effect of this simple shift of emphasis can be so profound as to 
change one's whole approach to programming. Under the literate programming
paradigm, the central activity of programming becomes that of conveying
meaning to other intelligent beings rather than merely convincing the
computer to behave in a particular way. It is the difference between
performing and exposing a magic trick.

{\bf --Ross Williams, FunnelWeb Tutorial Manual}}

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
Another thing I've been enjoying lately is literate programming. Amazingly
it turns out to be faster to write a literate program than an ordinary
program because debugging takes almost no time.

{\bf --Bill Hart, SAGE Mailing list, May 3, 2010}}

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
The conversation is much more direct if the Design Concept per se, rather
than derivative representatives or partial details, is the focus.

{\bf --Fred Brooks, ``The Design of Design''}}

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
We are banning the old notion of literate programming that I used when
developing \TeX{}82 because documentation has proven to be too much of
a pain.

{\bf --Donald Knuth TUG 2010}}

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
Once upon a time I took great care to ensure that \TeX{}82 would be truly
archival so that results obtainable today would produce the same output
50 years from now but that was manifestly foolish. Let's face it, who is
going to care one whit for what I do today after even 5 years have
elapsed, let alone 50. Life is too short to re-read anything anymore
in the internet age. Nothing over 30 months old is trustworthy or
interesting.

{\bf --Donald Knuth TUG 2010}}

\mainmatter
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% From ideas to implementation %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{From ideas to implementation}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Starting from Java}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Extends and Implements}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{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 connected 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.

There are various rules defined (see Okasaki \cite{Oka98} p25 and
Wikipedia \cite{Wiki}). The Clojure implementation follows the Okasaki
model, which we will use as our background. Okasaki gives two rules
that are always true in a properly formed tree:

\begin{packeditemize}
\item No red node has a red child
\item Every path from the root to an empty node contains the same
number of black nodes.
\end{packeditemize}

\defsubsection{Persistence}
Driscoll defines a {\sl persistent} data structure as one that supports
mutliple versions. A data structure that allows only a single version
at a time is called {\sl ephemeral} \cite{DSST89}. 

The basic technique of creating a persistent data structure is to make
copies. However this is expensive in time and space. Driscoll shows
that data structures can be defined using {\bf links} between {\bf
nodes} where the nodes carry information and the links connect the nodes.
In such structures it is possible to only copy nodes that are changed
and update the links. Using this technique does not modify the old data
structure so the links can share portions of the old structure. Since
the old structure is not changed it is also available at the same time
as the new structure, albeit with different root nodes.

\defsubsection{Persistent Red Black Trees}

Okasaki has combined these two ideas to create Persistent Red Black
Trees. Each modification of the tree is done by making copies of changed
nodes but maintaining the red-black tree properties in the copy.

Since Clojure uses these persistent trees the actual tree is new copy, 
not a modified tree. We will now look into the details of how this
is done.

\defsubsection{Node Structure}
First we have to mirror Driscoll's concept of a {\bf Node}. This is
created in the code with a new Java abstract class called Node. Okasaki
requires that a node have 4 pieces of information, described as
{\tt T (Color, left, this, right)}. Thus we find that Nodes have
the ability to manipulate their left and right members. Thus, for the
left member we find:
\begin{packeditemize}
\item {\sl left} -- to return the left Node
\item {\sl addLeft} -- to add a left Node
\item {\sl removeLeft} -- to remove a left Node
\end{packeditemize}

and for the right member we find:
\begin{packeditemize}
\item {\sl left} -- to return the right Node
\item {\sl addLeft} -- to add a right Node
\item {\sl removeLeft} -- to remove a right Node
\end{packeditemize}

We have functions to set the color, {\sl blacken} and {\sl redden}.
We can ask this node for its {\sl key} and {\sl val}

Since every node has to maintain the Red-Black balance we have two
methods, {\sl balanceLeft} and {\sl balanceRight}. Note that these
methods always return a black node as the root of the red-black
tree is always black. 

We also have a method to replace this node, the {\sl replace} method. 

Some of the methods are abstract which means that any class
that implements a Node has to implement the following methods:
\begin{packeditemize}
\item Node addLeft(Node ins);
\item Node addRight(Node ins);
\item Node removeLeft(Node del);
\item Node removeRight(Node del);
\item Node blacken();
\item Node redden();
\item Node replace(Object key, Object val, Node left, Node right);
\end{packeditemize}

Since the data structure is persistent we need to copy
rather than modify the structure. Each implementation of this
abstract class has to handle the details.

Node assumes that it will return a Black node from its balance 
operations.

Nodes in a Clojure PersistentTreeMap have one of 8 possible 
subtypes of Node:
\begin{packeditemize}
\item Black - a black leaf node with a null value
\item BlackVal - a black leaf node with a value
\item BlackBranch - a black interior node with children and a null value
\item BlackBranchVal - a black interior node with children and a value
\item Red - a red leaf node with a null value
\item RedVal - a red leaf node with a value
\item RedBranch - a red interior node with children and a null value
\item RedBranchVal - a red interior node with children and a value
\end{packeditemize}

\defclass{Node}
\extends{Node}{AMapEntry}
\begin{chunk}{PersistentTreeMap Node Class}
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);
    }

    abstract Node replace(Object key, Object val, 
                          Node left, Node right);

}

\end{chunk}

\defsubsection{The Black Node implementation}
Since the Node class is abstract it has to have certain methods 
implemented in the extending class. 

We have two types of implementations, one for Red nodes and one for
Black nodes. Lets look at the Black node class. This is broken out
into a set of subclasses and we will drill down the chain for
implemention Black nodes.

The class {\sl Black} extends node and implements the abstract methods
of Node. This basically involves making sure that the subtrees
maintain their balance under the operations of adding and deleting
the subtrees. 

Black nodes assume they are black but they implement a method to 
change their color. Since it is a copy operation it returns a new
Red node as the result of {\sl redden}. 

Black nodes are the default color for a node so the Black class
does not have to do anything special for color.

There are 4 possible Black node types
\begin{packeditemize}
\item Black - a black leaf node with a null value
\item BlackVal - a black leaf node with a value
\item BlackBranch - a black interior node with children and a null value
\item BlackBranchVal - a black interior node with children and a value
\end{packeditemize}

A Black node is a leaf node with a null value. This is constructed by
PersistentTreeMap's \refto{black} method.

\defsubclass{PersistentTreeMap}{Black}
\extends{Black}{Node}
\defmethod{PersistentTreeMap}{removeRight}
\begin{chunk}{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);
    }

}

\end{chunk}

A BlackVal node is a leaf node with a value. This is constructed by
PersistentTreeMap's \refto{black} method.

\defsubclass{PersistentTreeMap}{BlackVal}
\extends{BlackVal}{Black}
\begin{chunk}{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);
    }

}

\end{chunk}

Interior nodes of Clojure's Red Black trees can have a value.
A BlackBranch node is a leaf node with a null value and children,
one of which could possibly be null. This is constructed by
PersistentTreeMap's \refto{black} method.

\defsubclass{PersistentTreeMap}{BlackBranch}
\extends{BlackBranch}{Black}
\begin{chunk}{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;
    }

    public Node right(){
        return right;
    }

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

}

\end{chunk}

A BlackBranchVal node is a leaf node with a value and children,
one of which could possibly be null. This is constructed by
PersistentTreeMap's \refto{black} method.

\defsubclass{PersistentTreeMap}{BlackBranchVal}
\extends{BlackBranchVal}{BlackBranch}
\begin{chunk}{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);
    }

}
\end{chunk}

\defsubsection{Constructing a Black Node}
We can construct a new black node given 4 parameters:
\begin{packeditemize}
\item key -- the TreeMap key
\item val -- the value stored in the TreeMap for this key
\item left -- a Node, possibly null
\item right -- a Node, possibly null
\end{packeditemize}

If both of the children are null we must be constructing a leaf node.
If the value is null we need only construct a naked {\sl Black} node,
otherwise we construct a {\sl BlackVal} node and store both the key
and the value.

If either of the children exist but have no value for this node
then construct a {\sl BlackBranch} internal tree node pointing at
the children.

If we have all four parameters then we have an internal node that
also has a value associated with it. Save the value and the children
in a {\sl BlackBranchVal} node.

\defmethod{PersistentTreeMap}{black}
\begin{chunk}{PersistentTreeMap black method}
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);
}
\end{chunk}

\defsubsection{The Red Node implementation}
The Red Node class differs from the Black node in many ways. In particular,
most of the operations return a new Red object whereas the Black node
implementation balances the subtrees.

Black nodes are the default color for a node so the Red class
has to return Red nodes for most operations.

There are 4 possible Red node types
\begin{packeditemize}
\item Red - a black leaf node with a null value
\item RedVal - a black leaf node with a value
\item RedBranch - a black interior node with children and a null value
\item RedBranchVal - a black interior node with children and a value
\end{packeditemize}

A Red node is a leaf node with a null value. This is constructed by
PersistentTreeMap's \refto{red} method.

\defsubclass{PersistentTreeMap}{Red}
\extends{Red}{Node}
\begin{chunk}{PersistentTreeMap Red Class}
static class Red extends Node{
    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);
    }

}

\end{chunk}

A RedVal node is a leaf node with a value. This is constructed by
PersistentTreeMap's \refto{red} method.

\defsubclass{PersistentTreeMap}{RedVal}
\extends{RedVal}{Red}
\begin{chunk}{PersistentTreeMap RedVal Class}
static class RedVal extends Red{
    final Object val;

    public RedVal(Object key, Object val){
        super(key);
        this.val = val;
    }

    public Object val(){
        return val;
    }

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

}

\end{chunk}

Interior nodes of Clojure's Red Black trees can have a value.
A RedBranch node is a leaf node with a null value and children,
one of which could possibly be null. This is constructed by
PersistentTreeMap's \refto{red} method.

\defsubclass{PersistentTreeMap}{RedBranch}
\extends{RedBranch}{Red}
\begin{chunk}{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
            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);
    }

}
\end{chunk}

A RedBranchVal node is a leaf node with a value and children,
one of which could possibly be null. This is constructed by
PersistentTreeMap's \refto{red} method.

\defsubclass{PersistentTreeMap}{RedBranchVal}
\extends{RedBranchVal}{RedBranch}
\begin{chunk}{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);
    }
}
\end{chunk}

\defsubsection{Constructing a Red Node}
We can construct a new red node given 4 parameters:
\begin{packeditemize}
\item key -- the TreeMap key
\item val -- the value stored in the TreeMap for this key
\item left -- a Node, possibly null
\item right -- a Node, possibly null
\end{packeditemize}

If both of the children are null we must be constructing a leaf node.
If the value is null we need only construct a naked {\sl Red} node,
otherwise we construct a {\sl RedVal} node and store both the key
and the value.

If either of the children exist but have no value for this node
then construct a {\sl RedBranch} internal tree node pointing at
the children.

If we have all four parameters then we have an internal node that
also has a value associated with it. Save the value and the children
in a {\sl RedBranchVal} node.

\defmethod{PersistentTreeMap}{red}
\begin{chunk}{PersistentTreeMap red method}
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);
}
\end{chunk}

\defsubsection{Okasaki's balance cases}

Okasaki distinguishes 4 cases of balancing. It turns out that all four
cases balance to the same tree, which is hardly a surprise given
the constraints on the red-black alternation.

ML \cite{Wiki1, Har05} is a functional programming language and is
used by Okasaki to express his tree transformations.

Each case shows the ML code and the associated diagram. The ML code
represents a node as a 4-tuple of type {\bf T}. Thus we see a node as
\begin{verbatim}
   Type ( Color, leftnode, thisnode, rightnode )
\end{verbatim}
so we can read the first case as:
\begin{verbatim}
  Node ( Black, 
         Node ( Red ,
                Node ( Red, Node a, Node X, Node b ),
                Node Y,
                Node c 
              )
         Node Z
         Node d 
       )
\end{verbatim}
Case 1: (B,T (R,T (R,a,x,b),y,c),z,d) = T (R,T (B,a,x,b),y,T (B,c,z,d))
\[\begin{array}{rcl}
\pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}}
  { \pstree{\Tcircle{Y}}
      { \pstree{\Tcircle{X}}
        { \Tr{\psframebox[linestyle=none]{a}}
          \Tr{\psframebox[linestyle=none]{b}}
        }
        \Tr{\psframebox[linestyle=none]{c}}
      }
    \Tr{\psframebox[linestyle=none]{d}}
  }& => &
\pstree{\Tcircle{Y}}
  { \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}X}}}
      { \Tcircle{a}
        \Tcircle{b}
      }
    \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}}
      { \Tcircle{c}
        \Tcircle{d}
      }
  }
\end{array}
\]

Case 2: (B, T (R,a,x,T (R,b,y,c)),z,d) = T (R,T (B,a,x,b),y,T (B,c,z,d))
\[\begin{array}{rcl}
\pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}}
  { \pstree{\Tcircle{X}}
      { \Tr{\psframebox[linestyle=none]{a}}
        \pstree{\Tcircle{Y}}
        { \Tr{\psframebox[linestyle=none]{b}}
          \Tr{\psframebox[linestyle=none]{c}}
        }
      }
    \Tr{\psframebox[linestyle=none]{d}}
  }& => &
\pstree{\Tcircle{Y}}
  { \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}X}}}
      { \Tcircle{a}
        \Tcircle{b}
      }
    \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}}
      { \Tcircle{c}
        \Tcircle{d}
      }
  }
\end{array}
\]

Case 3: (B,a,x,T (R,T (R,b,y,c),z,d)) = T (R,T (B,a,x,b),y,T (B,c,z,d))
\[\begin{array}{rcl}
\pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}X}}}
  { \Tr{\psframebox[linestyle=none]{a}}
    \pstree{\Tcircle{Z}}
      { \pstree{\Tcircle{Y}}
        { \Tr{\psframebox[linestyle=none]{b}}
          \Tr{\psframebox[linestyle=none]{c}}
        }
       \Tr{\psframebox[linestyle=none]{d}}
      }
   
  }& => &
\pstree{\Tcircle{Y}}
  { \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}X}}}
      { \Tcircle{a}
        \Tcircle{b}
      }
    \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}}
      { \Tcircle{c}
        \Tcircle{d}
      }
  }
\end{array}
\]

Case 4:  (B,a,x,T (R,b,y,T (R,c,z,d))) = T (R,T (B,a,x,b),y,T (B,c,z,d))
\[\begin{array}{rcl}
\pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}X}}}
  { \Tr{\psframebox[linestyle=none]{a}}
    \pstree{\Tcircle{Y}}
      { \Tr{\psframebox[linestyle=none]{b}}
        \pstree{\Tcircle{A}}
        { \Tr{\psframebox[linestyle=none]{c}}
          \Tr{\psframebox[linestyle=none]{d}}
        }
      }
  }& => &
\pstree{\Tcircle{Y}}
  { \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}X}}}
      { \Tcircle{a}
        \Tcircle{b}
      }
    \pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}}
      { \Tcircle{c}
        \Tcircle{d}
      }
  }
\end{array}
\]

\defsubsection{Deleting a Node}

Here we are being asked to remove the Node {\sl del}. This request is
either a call to a black node's {\sl \refto{removeRight}} method or
PersistentTreeMap's {\sl \refto{remove}} method.

\defmethod{PersistentTreeMap}{balanceRightDel}
\begin{chunk}{PersistentTreeMap balanceRightDel method}
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");
}
\end{chunk}

\defmethod{PersistentTreeMap}{balanceLeftDel}
\begin{chunk}{PersistentTreeMap balanceLeftDel method}
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");
}
\end{chunk}

\defsubsection{Clojure's balance cases}

We find the {\sl leftBalance} handling the case where a red node
has a red node as its left child. There are three cases.

Case 1: The left child of a red node is red. We return new nodes
X, Y, and Z where
\begin{packeditemize}
\item X -- Node ( Red, 
\item Y
\item Z -- Node ( Black, 
\end{packeditemize}
\[
\begin{array}{rlc}
\pstree{\Tcircle{A}}
  { \Tcircle{B}
    \Tdot
  } & => &
\pstree{\Tcircle{X}}
  { \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}
    \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}
  }
\end{array}
\]

Case 2: The right child of a red node is red. We rewrite that as:
\[
\begin{array}{rlc}
\pstree{\Tcircle{N}}
  { \Tdot
    \Tcircle{B}
  } & => &
\pstree{\Tcircle{new}}
  { \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}
    \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}Z}}
  }
\end{array}
\]

Case 3: Both children of a red node are black. Rewrite the node black.
\[
\begin{array}{rlc}
\pstree{\Tcircle{N}}
  { \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}B}}
    \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}C}}
  } & => &
\pstree{\Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}A}}}
  { \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}B}}
    \Tr{\pscirclebox[fillstyle=solid,fillcolor=black]{\color{white}C}}
  }
\end{array}
\]

\defmethod{PersistentTreeMap}{leftBalance}
\begin{chunk}{PersistentTreeMap leftBalance method}
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)
        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);
}
\end{chunk}

\defmethod{PersistentTreeMap}{rightBalance}
\begin{chunk}{PersistentTreeMap rightBalance method}
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);
}
\end{chunk}

\defsubsection{Replacing a Node}
\defmethod{PersistentTreeMap}{replace}
\begin{chunk}{PersistentTreeMap replace method}
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());
}
\end{chunk}


\refto{PersistentTreeMap} implements several subclasses to support the
interoperability 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 \refto{Iterators} for methods of iterating across
keys and values. See \refto{Seqs} for information about manipulating
sequences over tree maps.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Immutable Data Structures}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Bit-Partitioned Hash Tries}
\label{bit-partitioning}

A trie is a data structure that exploits the fact that a prefix or
suffix has some regular pattern\cite{Bag00}. For instance, credit card
numbers have a fixed format. We can look at the set of 16 digit credit
card numbers which have the pattern AAAA-BBBB-CCCC-DDDD. Given this
sequence of 4 digit fields we can create a trie data structure for
fast lookup.

If we created a tree structure where the first level of lookup was the
first 4 digits AAAA we would have a maximum of 9999 possible first
level branches. If the second layer of the tree were based on BBBB
then it would also have a branching factor of 9999. We eventually get
a tree at most 4 layers deep that handle all $10^16$ possible values.

Alternatively we can reduce the fan-out by choosing 2 digits, so
AA gives a fan-out of 99 and this happens at each level. Now the
tree is 8 layers deep in order to contain all possible nodes.

Clojure has chosen a strategy based a bit pattern. So if we look
at the bits in groups of five we get this kind of a trie:

\newpage
{\hskip -1.0cm}
\begin{pspicture}(0,0)
\psset{fillstyle=solid}
\newrgbcolor{gray7}{0.3 0.5 0.2}
\newrgbcolor{gray6}{0.0 0.9 0.1}
\newrgbcolor{gray5}{0.3 0.1 0.6}
%\newrgbcolor{gray4}{0.5 0.5 0.0}
\newrgbcolor{gray3}{0.8 0.1 0.1}
\newrgbcolor{gray2}{0.1 0.7 0.2}
\newrgbcolor{gray1}{0.1 0.1 0.8}
\psscalebox{0.69}{
\psframebox[fillcolor=gray7]{\color{white}G}{\hskip -0.09cm}
\psframebox[fillcolor=gray7]{\color{white}G}{\hskip -0.09cm}
\psframebox[fillcolor=gray6]{\color{white}F}{\hskip -0.09cm}
\psframebox[fillcolor=gray6]{\color{white}F}{\hskip -0.09cm}
\psframebox[fillcolor=gray6]{\color{white}F}{\hskip -0.09cm}
\psframebox[fillcolor=gray6]{\color{white}F}{\hskip -0.09cm}
\psframebox[fillcolor=gray6]{\color{white}F}{\hskip -0.09cm}
\psframebox[fillcolor=gray5]{\color{white}E}{\hskip -0.09cm}
\psframebox[fillcolor=gray5]{\color{white}E}{\hskip -0.09cm}
\psframebox[fillcolor=gray5]{\color{white}E}{\hskip -0.09cm}
\psframebox[fillcolor=gray5]{\color{white}E}{\hskip -0.09cm}
\psframebox[fillcolor=gray5]{\color{white}E}{\hskip -0.09cm}
\psframebox[fillcolor=yellow]{\color{white}D}{\hskip -0.09cm}
\psframebox[fillcolor=yellow]{\color{white}D}{\hskip -0.09cm}
\psframebox[fillcolor=yellow]{\color{white}D}{\hskip -0.09cm}
\psframebox[fillcolor=yellow]{\color{white}D}{\hskip -0.09cm}
\psframebox[fillcolor=yellow]{\color{white}D}{\hskip -0.09cm}
\psframebox[fillcolor=gray3]{\color{white}C}{\hskip -0.09cm}
\psframebox[fillcolor=gray3]{\color{white}C}{\hskip -0.09cm}
\psframebox[fillcolor=gray3]{\color{white}C}{\hskip -0.09cm}
\psframebox[fillcolor=gray3]{\color{white}C}{\hskip -0.09cm}
\psframebox[fillcolor=gray3]{\color{white}C}{\hskip -0.09cm}
\psframebox[fillcolor=gray2]{\color{white}B}{\hskip -0.09cm}
\psframebox[fillcolor=gray2]{\color{white}B}{\hskip -0.09cm}
\psframebox[fillcolor=gray2]{\color{white}B}{\hskip -0.09cm}
\psframebox[fillcolor=gray2]{\color{white}B}{\hskip -0.09cm}
\psframebox[fillcolor=gray2]{\color{white}B}{\hskip -0.09cm}
\psframebox[fillcolor=gray1]{\color{white}A}{\hskip -0.09cm}
\psframebox[fillcolor=gray1]{\color{white}A}{\hskip -0.09cm}
\psframebox[fillcolor=gray1]{\color{white}A}{\hskip -0.09cm}
\psframebox[fillcolor=gray1]{\color{white}A}{\hskip -0.09cm}
\psframebox[fillcolor=gray1]{\color{white}A}}

%\psset{fillstyle=solid}
%\newrgbcolor{yellow}{0.3 0.6 0.1}
%\newrgbcolor{gray3}{0.1 0.5 0.4}
%\newrgbcolor{gray2}{0.1 0.7 0.2}
%\newrgbcolor{gray1}{0.1 0.1 0.8}
\rput(-6,-5){
\pstree{\Tr{\psframebox[fillcolor=gray1]{\color{white}A}}}
  {  \pstree{\Tr{\psframebox[fillcolor=gray2]{\color{white}B}}}
     { \Tcircle{x}
       \Tcircle{x}
     }
     \pstree{\Tr{\psframebox[fillcolor=gray2]{\color{white}B}}}
     { \pstree{\Tr{\psframebox[fillcolor=gray3]{\color{white}C}}}
       { \Tcircle{x}
         \pstree{\Tr{\psframebox[fillcolor=yellow]{\color{white}D}}}
         { \Tcircle{x}
           \Tcircle{x}
         }
       }
       \Tcircle{x}
     }
     \Tcircle{x}
     \pstree{\Tr{\psframebox[fillcolor=gray2]{\color{white}B}}}
     { \Tcircle{x}
       \pstree{\Tr{\psframebox[fillcolor=gray3]{\color{white}C}}}
       { \Tcircle{x}
         \Tcircle{x}
       }
       \pstree{\Tr{\psframebox[fillcolor=gray3]{\color{white}C}}}
       { \Tcircle{x}
         \Tcircle{x}
         \Tcircle{x}
       }
     }
     \Tcircle{x}
     \Tcircle{x}
   }}
\end{pspicture}
\vspace{9.5cm}

Notice that the trie has a fan-out of $2^5$ or 32 at each level except
the last. To contain all possible 32 bit values requires a trie of at
most depth 7. This means that a lookup will take at most 7 possible
fetches. For any reasonable set of numbers this is a near constant
time lookup.

One advantage of this scheme is the ability to mask out a subset of
the word, fully right-shift the bits, and use the resulting number
as an index into the array. Any masked off value has to be between
0 and 31 because the mask is 5 bits wide.

The 5 bit mask function is part of \refto{PersistentHashMap}. Given a
number of bits to shift right (a multiple of 5 appears to be used
everywhere) this routine returns a number between 0 and 31.

\defmethod{PersistentHashMap}{mask}
\begin{chunk}{PersistentHashMap mask method}
static int mask(int hash, int shift){
    //return ((hash << shift) >>> 27);// & 0x01f;
    return (hash >>> shift) & 0x01f;
}
\end{chunk}

This is used in the ArrayNode class. For instance, the {\sl find}
method 
\begin{packeditemize}
\item uses mask to get an index from 5 bits
\item uses that value to index into an array
\item if that entry is not set we didn't find it
\item shift 5 more bits right and search again.
\end{packeditemize}
\defmethod{ArrayNode}{find}
\begin{chunk}{ArrayNode find Object method}
    public Object find(int shift, int hash, Object key, 
                       Object notFound){
        int idx = mask(hash, shift);
        INode node = array[idx];
        if(node == null)
            return notFound;
        return node.find(shift + 5, hash, key, notFound); 
    }
\end{chunk}

Note that ArrayNode is a container class so it is actually recursively
calling the {\sl find} method on whatever was found in that container
slot. It might be anything that implements the INode interface:
\definterface{INode}
\extends{INode}{Serializable}
\begin{chunk}{PersistentHashMap INode interface}
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);
}
\end{chunk}

There are 3 classes that implement INode.
\begin{packeditemize}
\item \refto{ArrayNode}
\item \refto{BitmapIndexedNode}
\item \refto{HashCollisionNode}
\end{packeditemize}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{Lists}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{Vectors}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{Hashmaps}

Maps are associations of keywords and data. Hashmaps are untyped data
structures, as opposed to Records which carry their type.
\repl{(def tim \{:fname "Tim"\\
{\hbox {\hskip 1.8cm} :lname "Daly"}\\
{\hbox {\hskip 1.8cm} :address \{:street "Long Ridge Road"}\\
{\hbox {\hskip 3.3cm} :city "Pittsburgh"}\\
{\hbox {\hskip 3.3cm} :state "PA"}\\
{\hbox {\hskip 3.3cm} :zip 15022\}\}})}
{\#'user/tim}

We can look up by keyword since keywords are
\repl{(:lname tim)}{"Daly"}


We can nest access using the ``thread first'' operator which threads
arbitrary pieces of code (as opposed to ``..'' which threads Java classes).
\repl{(-$>$ tim :address :city)}{"Pittsburgh"}

We can create a new object with a change to a field.
\repl{(assoc tim :fname ``Timothy'')}{
\{:lname "Daly",\\
{\hbox {\hskip 0.1cm} :address \{:state "PA",}\\
{\hbox {\hskip 1.6cm} :city "Pittsburgh",}\\
{\hbox {\hskip 1.6cm} :street "Long Ridge Road",}\\
{\hbox {\hskip 1.6cm} :zip 15022\},}\\
{\hbox {\hskip 0.1cm} :fname "Timothy"\}}}

The {\tt update-in} function threads into a nested data structure
and then applies a function, in this case the {\tt inc} function.
This reduces the need to create intermediate classes.
\repl{(update-in tim [:address :zip] inc)}{
\{:lname "Daly",\\
{\hbox {\hskip 0.1cm} :address \{:state "PA",}\\
{\hbox {\hskip 1.6cm} :city "Pittsburgh",}\\
{\hbox {\hskip 1.6cm} :street "Long Ridge Road",}\\
{\hbox {\hskip 1.6cm} :zip 15023\},}\\
{\hbox {\hskip 0.1cm} :fname "Tim"\}}}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{Seqs}

\defsubclass{PersistentTreeMap}{Seq}
\extends{PersistentTreeMap}{ASeq}
\begin{chunk}{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){
        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);
    }
}

\end{chunk}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Records}

Records carry their type, in this case ``Person'', as opposed to hashmaps
which are untyped data structures.
\repl{(defrecord Person [fname lname address])}{user.Person}

and in this case ``Address''
\repl{(defrecord Address [street city state zip])}{user.Address}

We can create a Var reference to a new record and set the address
field to be a new Address record.
\repl{
(def tim\\
{\hbox {\hskip 0.6cm} (Person. "Tim" "Daly"}\\
{\hbox {\hskip 0.8cm}
(Address. "Long Ridge Road" "Pittsburgh" "PA" 15022)))}}
{\#'user/tim}

Record field names are functions so we can use them as accessors.
\repl{(:lname tim)}{"Daly"}

And we can access them with the "thread first" operator which threads
through the set of accessors and then applies the function, in this case,
the {\tt inc} function. This is similar to the ``..'' operator except
that it applies to any kind of operator, not just Java operators.
\repl{(-$>$ tim :address :city)}{"Pittsburgh"}

\repl{(assoc tim :fname "Timothy")}{
\#:user.Person\{:fname "Timothy",\\
{\hbox {\hskip 2.2cm} :lname "Daly",}\\
{\hbox {\hskip 2.2cm} :address \#:user.Address\{}\\
{\hbox {\hskip 3.2cm} :street "Long Ridge Road",}\\
{\hbox {\hskip 3.2cm} :city "Pittsburgh",}\\
{\hbox {\hskip 3.2cm} :state "PA",}\\
{\hbox {\hskip 3.2cm} :zip 15022\}}}

\repl{(update-in tim [:address :zip] inc)}{
\#:user.Person\{:fname "Tim",\\
{\hbox {\hskip 2.2cm} :lname "Daly",}\\
{\hbox {\hskip 2.2cm} :address \#:user.Address\{}\\
{\hbox {\hskip 3.2cm} :street "Long Ridge Road",}\\
{\hbox {\hskip 3.2cm} :city "Pittsburgh",}\\
{\hbox {\hskip 3.2cm} :state "PA",}\\
{\hbox {\hskip 3.2cm} :zip 15023\}}}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Java Interoperability}

\defsubsection{Language primitives}

{\bf Atomic data types}\cite{Hal11}

\begin{tabular}{|l|l|l|}
\hline
type & Clojure & Java\\
\hline
&&\\
string & "foo" &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/String.html}{String}
\defclass{String}\\
character & \verb|\f| &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Character.html}{Character}
\defclass{Character}\\
regular expression & \verb|#"fo*"| &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/util/regex/Pattern.html}{Pattern}
\defclass{Pattern}\\
integer & 42 &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Long.html}{Long}
\defclass{Long}\\
big integer & 42N &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigInteger.html}{BigInteger}
\defclass{BigInteger}\\
double & 3.14159 &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Double.html}{Double}
\defclass{Double}\\
big decimal & 3.141519M &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html}{BigDecimal}
\defclass{BigDecimal}\\
boolean & true &
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Boolean.html}{Boolean}
\defclass{Boolean}\\
nil & nil & null \\
ratio & 22/7 & N/A\\
symbol & foo & N/A\\
keyword & :foo ::foo & N/A\\
\hline
\end{tabular}

{\bf Data literals}

These data structures can contain anything of any type.

\begin{tabular}{|l|l|l|}
\hline
type & property & example\\
\hline
&&\\
list & singly-linked, insert at front & (1 2 3)\\
vector & indexed, insert at rear & [1 2 3]\\
map & key-value pairs & \verb|{:a 10 :b 20}|\\
set & key & \verb|#{1 2 3}|\\
\hline
\end{tabular}

\quoteme{gray}{yellow}{4.6in}
{\vskip 0.1cm
People make claims that Lisp has no syntax $\ldots$
A more accurate thing to say is that Lisp has the syntax of its data
structures and that syntax has been built upon to write code.

{\bf --Stuart Halloway ``Clojure-Java Interp (Jan 19, 2011)''}}

{\bf Function Calling}

\begin{verbatim}
  (println "Hello Wikileaks")
\end{verbatim}

This is a list data structure with a first element of a Symbol
and a second element of a String. The first element is the function
to be called and the second element is the argument to that function.

{\bf Function Definition}

\begin{verbatim}
  (defn funname
   "documentation string of the function"
   [vector of arguments]
   (function arg1 ... argN))
\end{verbatim}

This is a list data structure with the elements:
\begin{packeditemize}
\item defn, a Symbol, used as a function to define a function
\item funname, a Symbol, used as the name of the new function
\item docstring, a String, used to document the function
\item argvec, a Vector of arguments to the new function
\item function, a Symbol, used as the name of some other function to call
\item arg1$\ldots$argN, a list of arguments to the function
\end{packeditemize}

For example,
\repl{(defn say "says the name and age" [name age] (str name " " age))}
{{\#'user/say}}

The defn function creates the new function called "say" which
takes 2 arguments and returns a string with the two arguments
separated by a space as in:
\repl{(say "Tim" 24)}{"Tim 24"}

You can add meta information to your programs to improve the
performance or simplify the runtime lookup of classes. The
syntax for metadata is a Symbol or hashmap prefixed by a caret \verb|^|.
For example, the say function returns a String so we could write
\begin{verbatim}
  (defn ^String say
   "says the name and age"
   [name age]
   (str name " " age))
\end{verbatim}

If the item after the caret is a single Symbol it is expanded into
a hashmap with the keyword :tag and the Symbol. In our case, this is
\verb|{:tag String}|

\defsubsection{Clojure calling Java}

{\bf Java ``new'' in Clojure}
\begin{verbatim}
  new MyClass("arg1")
\end{verbatim}
becomes
\begin{verbatim}
  (MyClass. "arg1")
\end{verbatim}

{\bf Accessing a Java static member}
\begin{verbatim}
  Math.PI
\end{verbatim}
becomes
\begin{verbatim}
  Math/PI
\end{verbatim}

{\bf Accessing instance members}

Since Clojure shifts the focus from the object to the function
we call, the Clojure syntax favors putting the function at the
head of the list, the so-called ``function'' position.
\begin{verbatim}
  rnd.nextInt()
\end{verbatim}
becomes
\begin{verbatim}
  (.nextInt rnd)
\end{verbatim}

{\bf Chaining function calls}
\begin{verbatim}
  person.getAddress().getZip()
\end{verbatim}
becomes
\begin{verbatim}
  (.. person getAddress getZip)
\end{verbatim}

The {\tt doto} macro uses the first form to create an object
upon which subsequent method calls can be applied in series.
\begin{verbatim}
  (doto (JFrame. "argument")
   (.add (proxy [JPanel] []))
   (.setSize 640 480)
   (.setVisible true))
\end{verbatim}





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Recursion}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Argument Deconstruction}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{The Read-Eval-Print Loop}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Special Forms}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Reader Macros}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Namespaces}

Namespaces map to java packages.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Dynamic Comopilation}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Ahead-Of-Time Comopilation}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Lazy Evaluation}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Metadata}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Concurrency}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Identity and State}

Identity is a logical entity associated with a series of causally
related values, called states, over time. Identity is not a name
but can be named (e.g. my ``Mom'' is not your mom). Identity can
be a composite object (e.g. the New York Yankees). Programs that
are processes need identity. \cite{Hic10}

State is the value of an identity at a given time. Variables are
not sufficient to refer to a state because state could be composite.
This leads to a situation where, at a given time, the variable does
not refer to a properly formed state but refers to inconsistent
composite information. There is a lack of time coordination.

In order to properly capture state we need to incorporate some 
notion of time. Once we have time as a marker we can talk about
state at a particular time. Since Clojure deals with immutable
objects that implies that a changed state must be a different object
since things don't change in place. 

Since state is a combination of information and time it is possible
for multiple observers to query the state. Each will see a consistent
view of the information (the value) based on the time of the observation.

Clojure manages state by creating an intermediate object called a
reference. The reference object has atomic semantics. Changing a
reference happens as an all-or-nothing event. References are
essentially a pointer to a stateful object. The reference points at
the current state.  When a new state is being constructed as a
function of the old state there is no way to reference it until the
function completes. At that time the reference is atomically updated
and the new state can be observed as a wholly-formed object. This
becomes the new state which is a function of the current time and the
new information.  Observers of the prior state will still see the old
state unchanged.

There are four kinds of reference objects in Clojure which we will
discuss in detail below. These are {\sl vars}, {\sl atoms}, {\sl refs},
and {\sl agents}. 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Software Transactional Memory}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Symbols}

Internally, a Clojure Symbol contains four pieces of data
\begin{packeditemize}
\item {\bf ns} an interned string of the namespace for this symbol
\item {\bf name} a interned string for this symbol name
\item {\bf hash} a hash of the name and the namespace
\item {\bf \_meta} meta data associated with this Symbol
\end{packeditemize}

\begin{chunk}{Symbol private data}
//these must be interned strings!
final String ns;
final String name;
final int hash;
final IPersistentMap _meta;
\end{chunk}

Java's String class has an {\sl intern} method \cite{Ora11} which returns
a canonical representation for the string object. The String class maintains
a pool of strings. When String's {\sl intern} method is invoked the pool is
searched for an {\sl equals} match. If the search succeeds then a reference
to the stored string is returned, otherwise the new string is added to the
pool and a reference to this String object is returned. Thus, the String
{\sl name} of a Symbol is a unique reference.

As pointed out in \cite{Web11}, Clojure creates a new Symbol for each
occurence it reads. The Symbols are not unique despite having equal names:
\begin{verbatim}
node2: clj
Clojure 1.3.0-alpha4
user=> (identical? 'a 'a)
false
user=> (= 'a 'a)
true
user=> (identical? (clojure.lang.Symbol/intern "a") 
       (clojure.lang.Symbol/intern "a"))
false
\end{verbatim}

\defmethod{Symbol}{intern}
\begin{chunk}{Symbol intern method}
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());
}

\end{chunk}

A new Symbol is automatically prepended with its namespace.
\begin{verbatim}
user=> (def a 1)
#'user/a
\end{verbatim}

\defmethod{Symbol}{intern(2)}
\begin{chunk}{Symbol intern method 2}
static public Symbol intern(String ns, String name){
    return new Symbol(ns == null ? null : ns.intern(), name.intern());
}
\end{chunk}

Since the namespace was null the current namespace {\tt user} was used.
We can see this from the {\sl toString} result.

\defmethod{Symbol}{toString}
\begin{chunk}{Symbol method toString}
public String toString(){
    if(ns != null)
        return ns + "/" + name;
    return name;
}
\end{chunk}

Since Symbols optionally include a namespace {\tt user/a}, which includes
a namespace,  and {\tt a} which does not include a namespace,
are different symbols but they name the same variable.

\begin{verbatim}
user=> (= 'user/a 'a)
false
user=> (def a 1)
#'user/a
user=> user/a
1
user=> (def user/a 2)
#'user/a
user=> a
2
\end{verbatim}

\defmethod{Symbol}{equals}
\begin{chunk}{Symbol method equals}
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;
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{The Lisp Reader}

When the LispReader read function is invoked it reads each character
as an integer. The read function is parsing S-expressions so it skips
whitespace and fails if it does not get a complete S-expression. Numbers
are handled specially by the reader.

\defmethod{LispReader}{read}
\begin{chunk}{LispReader read method}
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();

            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))
            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);
        }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{Reader Syntax Macros}

Almost every special character is handled by looking up the special
function associated with that character in the {\tt macros} array:

\begin{chunk}{LispReader macros statement}
static IFn[] macros = new IFn[256];
\end{chunk}

The default values are specified in the syntax macro table. These are all
class objects that implement the \refto{IFn} interface which requires that
they have an {\tt invoke} method.

For the special case of the \verb|#| character there is a separate
table, the \refto{Dispatch Macro Table} which reads the next character
and calls another dispatch function. All of the special characters
get their meaning from these tables.

By default the special syntax characters are
\begin{packeditemize}
\item {\bf \verb|"|} a \refto{StringReader}
\item {\bf \verb|;|} a \refto{CommentReader}
\item {\bf \verb|'|} a \refto{WrappingReader}(QUOTE)
\item {\bf \verb|@|} a \refto{WrappingReader}(DEREF)
\item {\bf \verb|^|} a \refto{MetaReader}
\item {\bf \verb|`|} a \refto{SyntaxQuoteReader}
\item {\bf \verb|~|} a \refto{UnquoteReader}
\item {\bf \verb|(|} a \refto{ListReader}
\item {\bf \verb|)|} a \refto{UnmatchedDelimiterReader}
\item {\bf \verb|[|} a \refto{VectorReader}
\item {\bf \verb|]|} a \refto{UnmatchedDelimiterReader}
\item {\bf \verb|{|} a \refto{MapReader}
\item {\bf \verb|}|} a \refto{UnmatchedDelimiterReader}
\item {\bf \verb|\|} a \refto{CharacterReader}
\item {\bf \verb|%|} a \refto{ArgReader}
\item {\bf \verb|#|} a \refto{DispatchReader}
\end{packeditemize}

\label{Syntax Macro Table}
\index{Syntax Macro Table}
\begin{chunk}{LispReader Syntax Macro Table}
    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();
//    macros['|'] = new ArgVectorReader();
    macros['\\'] = new CharacterReader();
    macros['%'] = new ArgReader();
\getchunk{LispReader sharpsign macro statement}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The String reader macro}

\defsubclass{LispReader}{StringReader}
\extends{StringReader}{AFn}
\begin{chunk}{LispReader StringReader class}
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;
                    }
                    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();
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Comment reader macro}

\defsubclass{LispReader}{CommentReader}
\extends{CommentReader}{AFn}
\begin{chunk}{LispReader CommentReader class}
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;
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Wrapping reader macro}

\defsubclass{LispReader}{WrappingReader}
\extends{WrappingReader}{AFn}
\begin{chunk}{LispReader WrappingReader class}
public static class WrappingReader extends AFn{
    final Symbol sym;

    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);
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Meta reader macro}

\defsubclass{LispReader}{MetaReader}
\extends{MetaReader}{AFn}
\begin{chunk}{LispReader MetaReader class}
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)
            {
            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");
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The SyntaxQuote reader macro}

\defsubclass{LispReader}{SyntaxQuoteReader}
\extends{SyntaxQuoteReader}{AFn}
\begin{chunk}{LispReader SyntaxQuoteReader class}
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 = 
                    (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)
                {
                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)
              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;
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Unquote reader macro}

\defsubclass{LispReader}{UnquoteReader}
\extends{UnquoteReader}{AFn}
\begin{chunk}{LispReader UnquoteReader class}
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");
        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);
            }
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The List reader macro}

\defsubclass{LispReader}{ListReader}
\extends{ListReader}{AFn}
\begin{chunk}{LispReader ListReader class}
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;
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Unmatched Delimiter reader macro}

\defsubclass{LispReader}{UnmatchedDelimiterReader}
\extends{UnmatchedDelimiterReader}{AFn}
\begin{chunk}{LispReader UnmatchedDelimiterReader class}
public static class UnmatchedDelimiterReader extends AFn{
    public Object invoke(Object reader, Object rightdelim)
     throws Exception{
        throw new Exception("Unmatched delimiter: " + rightdelim);
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Vector reader macro}

\defsubclass{LispReader}{VectorReader}
\extends{VectorReader}{AFn}
\begin{chunk}{LispReader VectorReader class}
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));
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Map reader macro}

\defsubclass{LispReader}{MapReader}
\extends{MapReader}{AFn}
\begin{chunk}{LispReader MapReader class}
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());
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Character reader macro}

\defsubclass{LispReader}{CharacterReader}
\extends{CharacterReader}{AFn}
\begin{chunk}{LispReader CharacterReader class}
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)
                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);
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Arg reader macro}

\defsubclass{LispReader}{ArgReader}
\extends{ArgReader}{AFn}
\begin{chunk}{LispReader ArgReader class}
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());
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Reader Dispatch Macros}

The \refto{LispReader} read function, when it encounters a \verb|#|
character indexes into the \refto{Syntax Macro Table} to find an
entry initialized to a \refto{DispatchReader} object.

\begin{chunk}{LispReader sharpsign macro statement}
    macros['#'] = new DispatchReader();
\end{chunk}

A DispatchReader reads the next character and uses it as an index
into the \refto{dispatchMacros} array. The reader function associated
with the macro character, in this case, is a \refto{VarReader}. This
gets assigned to {\tt fn} and then calls the {\tt invoke} method
of the \refto{VarReader} class.

\defsubclass{LispReader}{DispatchReader}
\extends{DispatchReader}{AFn}
\begin{chunk}{LispReader DispatchReader class}
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);
    }
}
\end{chunk}

The dispatchMacros array is defined to be an array of IFn objects.
The \refto{IFn} interface requires that all implementations have
to have an {\tt invoke} method, which VarReader has.
\label{dispatchMacros}
\index{dispatchMacros}
\begin{chunk}{LispReader dispatchMacros statement}
static IFn[] dispatchMacros = new IFn[256];
\end{chunk}

By default the special dispatch characters are:
\begin{packeditemize}
\item {\bf \verb|^|} a \refto{MetaReader}, 
for attaching meta information to objects
\item {\bf \verb|'|} a \refto{VarReader}, returns a Var object
\item {\bf \verb|"|} a \refto{RegexReader}, returns a regular expression
\item {\bf \verb|(|} a \refto{FnReader}, returns a function object
\item {\bf \verb|{|} a \refto{SetReader}, returns a set object
\item {\bf \verb|=|} a \refto{EvalReader}, returns an evaled object
\item {\bf \verb|!|} a \refto{CommentReader}, returns a commented object
\item {\bf \verb|<|} a \refto{UnreadableReader}, returns an unreadable object
\item {\bf \verb|_|} a \refto{DiscardReader}, returns a discarded object
\end{packeditemize}

These are all defined in this table and they are explained in the 
following sections.
\label{Dispatch Macro Table}
\index{Dispatch Macro Table}
\begin{chunk}{LispReader Dispatch Macro Table}
    dispatchMacros['^'] = new MetaReader();
\getchunk{LispReader dispatchMacros VarReader statement}
    dispatchMacros['"'] = new RegexReader();
    dispatchMacros['('] = new FnReader();
    dispatchMacros['{'] = new SetReader();
    dispatchMacros['='] = new EvalReader();
    dispatchMacros['!'] = new CommentReader();
    dispatchMacros['<'] = new UnreadableReader();
    dispatchMacros['_'] = new DiscardReader();
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Var reader macro}
Vars have a special reader macro \verb|#'| so that the input form
\verb|#'foo| expands into (var foo). The Symbol foo must be a Var
and the Var object itself, not its value, is returned.

The single-quote (\verb|'|) array entry contains a \refto{VarReader} function.
\begin{chunk}{LispReader dispatchMacros VarReader statement}
    dispatchMacros['\''] = new VarReader();
\end{chunk}

The VarReader {\sl invoke} method reads the next object and 
returns the Var reference.
\defsubclass{LispReader}{VarReader}
\extends{VarReader}{AFn}
\begin{chunk}{LispReader VarReader class}
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);
    }
}
\end{chunk}

The \verb|#'| macro is useful for naming functions or variables in 
another namespace. You can call function across namespaces by writing
\begin{verbatim}
  (#'mynamespace/functionname ...)
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Regular Expression reader macro}

\defsubclass{LispReader}{RegexReader}
\extends{RegexReader}{AFn}
\begin{chunk}{LispReader RegexReader class}
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 ) ;
                }
            }
        return Pattern.compile(sb.toString());
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Function reader macro}

\defsubclass{LispReader}{FnReader}
\extends{FnReader}{AFn}
\begin{chunk}{LispReader FnReader class}
public static class FnReader extends AFn{
    public Object invoke(Object reader, Object lparen)
     throws Exception{
        PushbackReader r = (PushbackReader) reader;
        if(ARG_ENV.deref() != null)
            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();
            }
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Set reader macro}

\defsubclass{LispReader}{SetReader}
\extends{SetReader}{AFn}
\begin{chunk}{LispReader SetReader class}
public static class SetReader extends AFn{
    public Object invoke(Object reader, Object leftbracket)
     throws Exception{
        PushbackReader r = (PushbackReader) reader;
        return PersistentHashSet
                 .createWithCheck(readDelimitedList('}', r, true));
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Eval reader macro}

\defsubclass{LispReader}{EvalReader}
\extends{EvalReader}{AFn}
\begin{chunk}{LispReader EvalReader class}
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))
                {
                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");
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Unreadable reader macro}

\defsubclass{LispReader}{UnreadableReader}
\extends{UnreadableReader}{AFn}
\begin{chunk}{LispReader UnreadableReader class}
public static class UnreadableReader extends AFn{
    public Object invoke(Object reader, Object leftangle)
     throws Exception{
        throw new Exception("Unreadable form");
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The Discard reader macro}

\defsubclass{LispReader}{DiscardReader}
\extends{DiscardReader}{AFn}
\begin{chunk}{LispReader DiscardReader class}
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;
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Vars}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Transients}

Transients are intended to make your code faster. Transients ignore
structural sharing so time and space is saved. The underlying data
structure is different. 

For example, we thread a persistent map through some associations.
\begin{chunk}{transients example}
(-> {} (assoc :a 1) (assoc :b 2) (assoc :c 3))
\end{chunk}
which results in the persistent map
\begin{chunk}{transients example}
{:c 3, :b 2, :a 1}
\end{chunk}

A {\bf transient} version is similar but transients are not mutable.
\begin{chunk}{transients example}
(-> (transient {}) (assoc! :a 1) (assoc! :b 2) (assoc! :c 3) persistent!)
\end{chunk}

\begin{chunk}{defn transient}
(defn transient 
  "Alpha - subject to change.
  Returns a new, transient version of the collection, in constant time."
  {:added "1.1"
   :static true}
  [^clojure.lang.IEditableCollection coll] 
  (.asTransient coll))

\end{chunk}

The difference is that the transient call makes the persistent map
is transformed to a transient map. The {\bf assoc!} call operates
similar to assoc. The {\bf persistent!} call transforms the result to
a persistent map.

There are several function that operate on transients, 
{\bf persistent!}, {\bf conj!}, {\bf assoc!}, {\bf dissoc!}, {\bf pop!},
and {\bf disj!}.

\begin{chunk}{defn persistent!}
(defn persistent! 
  "Alpha - subject to change.
  Returns a new, persistent version of the transient collection, in
  constant time. The transient collection cannot be used after this
  call, any such use will throw an exception."
  {:added "1.1"
   :static true}
  [^clojure.lang.ITransientCollection coll]
  (.persistent coll))

\end{chunk}

\begin{chunk}{defn conj!}
(defn conj!
  "Alpha - subject to change.
  Adds x to the transient collection, and return coll. The 'addition'
  may happen at different 'places' depending on the concrete type."
  {:added "1.1"
   :static true}
  [^clojure.lang.ITransientCollection coll x]
  (.conj coll x))

\end{chunk}

\begin{chunk}{defn assoc!}
(defn assoc!
  "Alpha - subject to change.
  When applied to a transient map, adds mapping of key(s) to
  val(s). When applied to a transient vector, sets the val at index.
  Note - index must be <= (count vector). Returns coll."
  {:added "1.1"
   :static true}
  ([^clojure.lang.ITransientAssociative coll key val]
   (.assoc coll key val))
  ([^clojure.lang.ITransientAssociative coll key val & kvs]
   (let [ret (.assoc coll key val)]
     (if kvs
       (recur ret (first kvs) (second kvs) (nnext kvs))
       ret))))

\end{chunk}

\begin{chunk}{defn dissoc!}
(defn dissoc!
  "Alpha - subject to change.
  Returns a transient map that doesn't contain a mapping for key(s)."
  {:added "1.1"
   :static true}
  ([^clojure.lang.ITransientMap map key] (.without map key))
  ([^clojure.lang.ITransientMap map key & ks]
   (let [ret (.without map key)]
     (if ks
       (recur ret (first ks) (next ks))
       ret))))

\end{chunk}

\begin{chunk}{defn pop!}
(defn pop!
  "Alpha - subject to change.
  Removes the last item from a transient vector. If
  the collection is empty, throws an exception. Returns coll"
  {:added "1.1"
   :static true}
  [^clojure.lang.ITransientVector coll] 
  (.pop coll)) 

\end{chunk}

\begin{chunk}{defn disj!}
(defn disj!
  "Alpha - subject to change.
  disj[oin]. Returns a transient set of the same (hashed/sorted) type,
  that does not contain key(s)."
  {:added "1.1"
   :static true}
  ([set] set)
  ([^clojure.lang.ITransientSet set key]
   (. set (disjoin key)))
  ([set key & ks]
   (let [ret (disj set key)]
     (if ks
       (recur ret (first ks) (next ks))
       ret))))

\end{chunk}

The imperative style will not work everywhere. For instance,
\begin{chunk}{transients example}
(let [a (transient {})]
  (dotimes [i 20] (assoc! a i i))
  (persistent! a))
\end{chunk}
returns with the broken result
\begin{chunk}{transients example}
(0 0, 1 1, 2 2, 3 3, 4 4, 5 5, 6 6, 7 7}
\end{chunk}
which is only the first 8 values of the map.

However, if it is done in a recursive style, as in 
\begin{chunk}{transients example}
(persistent!
  (reduce (fn[m v] (assoc! m v v))
          (transient {})
          (range 1 21)))
\end{chunk}
yields all twenty pairs.
\begin{chunk}{transients example}
(0 0, 1 1, 2 2, 3 3, 4 4, 5 5, 6 6, 7 7, 8 8, 9 9, 10 10, 11 11, 12 12,
13 13, 14 14, 15 15, 16 16, 17 17, 18 18, 19 19, 20 20)
\end{chunk}

Transients can only be modified by the thread that creates them.
Attemping to access them will throw a
\verb|java.util.concurrent.ExecutionException|
\begin{chunk}{transients example}
@(let [c (transient [])] (future (conj! c :a)))
\end{chunk}

It is also not possible to modify a Transient after the call to
{\bf persistent!} will throw a 
\verb|java.lang.IllegalAccessError| exception. So this will not work:
\begin{chunk}{transients example}
(let [c (transient #{})] (persistent! c) (conj! c :a))
\end{chunk}

Transients do not work on every data structure. Lists, sets, and maps
all throw a
\verb|java.lang.ClassCastException|
\begin{chunk}{transients example}
(transient '())
(transient (sorted-set))
(transient (sorted-map))
\end{chunk}

The Transient data structure must support 
\verb|clojure.lang.IEditableCollection|.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Atoms}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Refs}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Agents}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Promise and Deliver}

A Promise is a mechanism for storing data and reading this data across
threads. 

The {\bf promise} function creates a promise that can be stored as in:
\begin{chunk}{promise example}
(def prom (promise))
\end{chunk}

\begin{chunk}{defn promise}
(defn promise
  "Alpha - subject to change.
  Returns a promise object that can be read with deref/@, and set,
  once only, with deliver. Calls to deref/@ prior to delivery will
  block. All subsequent derefs will return the same delivered value
  without blocking."
  {:added "1.1"
   :static true}
  []
  (let [d (java.util.concurrent.CountDownLatch. 1)
        v (atom nil)]
    (reify 
     clojure.lang.IDeref
      (deref [_] (.await d) @v)
     clojure.lang.IPromiseImpl
      (hasValue [this]
       (= 0 (.getCount d)))
     clojure.lang.IFn
      (invoke [this x]
        (locking d
          (if (pos? (.getCount d))
            (do (reset! v x)
                (.countDown d)
                this)
            (throw (IllegalStateException. 
                    "Multiple deliver calls to a promise"))))))))

\end{chunk}

To fulfill a promise we use the {\bf deliver} function. So we would use
\begin{chunk}{promise example}
(deliver prom 1)
\end{chunk}

\begin{chunk}{defn deliver}
(defn deliver
  "Alpha - subject to change.
  Delivers the supplied value to the promise, releasing any pending
  derefs. A subsequent call to deliver on a promise will throw an 
  exception."
  {:added "1.1"
   :static true}
  [promise val] (promise val))

\end{chunk}

\index{promise}{dereference}
\index{promise}{@}
\index{@}{promise}
To see the delivered value we deference the variable.
\begin{chunk}{promise example}
@prom
\end{chunk}
Note that dereferencing a promise before the value is delivered
will block the current thread. So you can have a future deliver
on the promise from another thread and wait on the result.
\begin{chunk}{promise example}
(do (future
     (Thread/sleep 5000)
     (deliver prom 1))
 @prom)
\end{chunk}

\index{promise}{IllegalStateException}
\index{exceptions}{IllegalStateException}
\index{IllegalStateException}{promise}
Attemping to deliver a value more than once will throw a
\verb|java.lang.IllegalStateException|

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Futures}

Futures are a mechanism for executing a function in a different thread
and retrieving the results later.

Futures are useful for long running tasks that should not block, such
as a UI thread, communicating across networks, or a task that has 
a side-effect that does not affect the main computation, such as 
displaying an image or printing. For example,
\begin{chunk}{future example}
(do 
  (future
    (Thread/sleep 3000)
    (sendToPrinter "resume.pdf"))
  (messages/plain-message "file being printed"))
\end{chunk}

A future can return a value. We define a var that will hold the
value of a future as in:

\begin{chunk}{defn future-call}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; futures (needs proxy);;;;;;;;;;;;;;;;;;
(defn future-call 
  "Takes a function of no args and yields a future object that will
  invoke the function in another thread, and will cache the result and
  return it on all subsequent calls to deref/@. If the computation has
  not yet finished, calls to deref/@ will block."
  {:added "1.1"
   :static true}
  [f]
  (let [f (binding-conveyor-fn f)
        fut (.submit clojure.lang.Agent/soloExecutor ^Callable f)]
    (reify 
     clojure.lang.IDeref 
      (deref [_] (.get fut))
     java.util.concurrent.Future
      (get [_] (.get fut))
      (get [_ timeout unit] (.get fut timeout unit))
      (isCancelled [_] (.isCancelled fut))
      (isDone [_] (.isDone fut))
      (cancel [_ interrupt?] (.cancel fut interrupt?)))))

\end{chunk}

\begin{chunk}{defmacro future}  
(defmacro future
  "Takes a body of expressions and yields a future object that will
  invoke the body in another thread, and will cache the result and
  return it on all subsequent calls to deref/@. If the computation has
  not yet finished, calls to deref/@ will block."
  {:added "1.1"}
  [& body] `(future-call (^{:once true} fn* [] ~@body)))

\end{chunk}

\begin{chunk}{future var}
(def result
  (future
   (Thread/sleep 3000)
   "The future has arrived"))
\end{chunk}

\index{future}{dereference}
\index{future}{@}
\index{@}{future}
We can get the value of this var using the dereference operator "@".
\begin{chunk}{future dereference}
@result
\end{chunk}

\index{future}{CancellationException}
\index{exceptions}{CancellationException}
\index{CancellationException}{future}
If we dereference the var before the future completes then the
dereference blocks until the result is available. The result
retains its value so a second dereference will return immediately.
If the future is cancelled (see below), then the dereference will
throw a |java.util.concurrent.CancellationException|.

\index{future}{future?}
We can test if a var is a future with the {\bf future?} predicate.
\begin{chunk}{future dereference}
(future? result) ==> true
\end{chunk}

\begin{chunk}{defn future?}
(defn future?
  "Returns true if x is a future"
  {:added "1.1"
   :static true}
  [x] (instance? java.util.concurrent.Future x))

\end{chunk}

\index{future}{future-done?}
We can test if the future has completed witht he {\bf future-done?}
predicate.
\begin{chunk}{future done}
(future-done? result) ==> true
\end{chunk}

\begin{chunk}{defn future-done?}
(defn future-done?
  "Returns true if future f is done"
  {:added "1.1"
   :static true}
  [^java.util.concurrent.Future f] (.isDone f))

\end{chunk}

A pending future can be cancelled with the {\bf future-cancel} function
\begin{chunk}{future cancel}
(future-cancel result) ==> true
\end{chunk}
which, if it successfully cancels the future returns true.

\begin{chunk}{defn future-cancel}
(defn future-cancel
  "Cancels the future, if possible."
  {:added "1.1"
   :static true}
  [^java.util.concurrent.Future f] (.cancel f true))

\end{chunk}

We can test if the future was cancelled with the {\bf future-cancelled?}
function
\begin{chunk}{future cancelled}
(future-cancelled? result) ==> true
\end{chunk}
which, if the future was cancelled, will return true.

\begin{chunk}{defn future-cancelled?}
(defn future-cancelled?
  "Returns true if future f is cancelled"
  {:added "1.1"
   :static true}
  [^java.util.concurrent.Future f] (.isCancelled f))

\end{chunk}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{MultiMethods}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Deftype}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Defrecord}

Define a record object with slots named :a, :b, and :c
\repl{(defrecord Foo [a b c])}{user.Foo}

This makes a Java class {\tt Foo} in the Java package {\tt user}.

Make a Var reference to a our new record object.
\repl{(def f (Foo. 1 2 3))}{\#:user.Foo\{:a 1, :b 2, :c 3\}}

Access the value of the :b slot in the record instance f
\repl{(:b f)}{2}
or
\repl{(.b f)}{2}

What is the Var f actually pointing to? It points to a class object.
\repl{(class f)}{user.Foo}

We can apply normal functions to the query information about the
class of f.
\repl{(supers (class f))}{
\#\{clojure.lang.ILookup\\
{\hbox {\hskip 0.4cm} java.lang.Object}\\
{\hbox {\hskip 0.4cm} java.util.Map}\\
{\hbox {\hskip 0.4cm} clojure.lang.Seqable}\\
{\hbox {\hskip 0.4cm} clojure.lang.IKeywordLookup}\\
{\hbox {\hskip 0.4cm} java.lang.Iterable}\\
{\hbox {\hskip 0.4cm} clojure.lang.IMeta}\\
{\hbox {\hskip 0.4cm} clojure.lang.IPersistentCollection}\\
{\hbox {\hskip 0.4cm} clojure.lang.IPersistentMap}\\
{\hbox {\hskip 0.4cm} clojure.lang.Counted}\\
{\hbox {\hskip 0.4cm} clojure.lang.IObj}\\
{\hbox {\hskip 0.4cm} java.io.Serializable}\\
{\hbox {\hskip 0.4cm} clojure.lang.Associative\}}}

We see that the Var f references a record class which has a number of
interesting properties. In particular, given this record we know many
things about its properties.
\begin{packeditemize}
\item \refto{ILookup}
\item 
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Object.html}{Object} Since records are Java Objects they can be compared with the default
{\tt equals} method and can be stored in containers or passed as arguments.
\item  
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/util/Map.html}{Map}
 Since records implement Map they provide three collection views, as a set
of keys, as a set of values, and as a set of key-value mappings.
\item \refto{Seqable} 
\item \refto{IKeywordLookup}
\item 
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Iterable.html}{Iterable} Since records are Iterable they implement an {\tt iterator} method
that allows them to be the target of a {\tt foreach} statement.
\item \refto{IMeta}
\item \refto{IPersistentCollection}
\item \refto{IPersistentMap}
\item \refto{Counted}
\item \refto{IObj}
\item
\href{http://download.oracle.com/javase/1.5.0/docs/api/java/io/Serializable.html}{Serializable} Since records are Serializable the implement 
{\tt writeObject} and {\tt readObject} methods that make it possible to 
stream the state of the object out and recreate it by reading it back.
\item \refto{Associative}
\end{packeditemize}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Protocols}

\repl{(defprotocol coerce\\
{\hbox {\hskip 0.5cm} "coerce between things"}\\
{\hbox {\hskip 0.5cm} (as-file [x] "Coerce argument to a file")}\\
{\hbox {\hskip 0.5cm} (as-url [x] "Coerce argument to a URL"))}}{coerce}

Defprotocol defines a named set of generic functions which dispatch on
the type of the first argument. The functions are defined in the same
namespace (and thus the same Java package) as the protocol.

Similar to Java interfaces but are functions, not associated with classes.
In this example, we mimic the Java idioms. A record is like class and
coerce is like an interface so we are saying that the class {\tt Name}
implements the {\tt as-file} method of interface {\tt coerce}.

{\bf Extending inline}

\repl{(defrecord Name [n]\\
{\hbox {\hskip 0.5cm} coerce}\\
{\hbox {\hskip 0.5cm} (as-file [_] (File. n)))}}
{user.Name}

\repl{(def n (Name. "johndoe"))}
{\#'user/n}

\repl{(as-file n)}
{\#<File johndoe>}

{\bf Extending protocol to classes that already exist}

Protocols can implement methods without classes by associating them
with types of their first argument. So we extend the {\tt coerce}
protocol to work with {\tt nil} arguments and {\tt String} arguments.

\repl{(extend-protocol coerce\\
{\hbox {\hskip 0.5cm} nil}\\
{\hbox {\hskip 0.5cm} (as-file [_] nil)}\\
{\hbox {\hskip 0.5cm} (as-url [_] nil)}\\
{\hbox {\hskip 0.5cm} String}\\
{\hbox {\hskip 0.5cm} (as-file [s] (File. s))}\\
{\hbox {\hskip 0.5cm} (as-url [s] (URL. s)))}}
{nil}

\repl{(as-file "data.txt")}
{\#File data.txt}

{\bf Extending existing classes to add protocols}

\repl{(defprotocol MyNewProtocol (myNewFunction [x] "answer"))}
{MyNewProtocol}

\repl{(extend-type String\\
{\hbox {\hskip 0.5cm} coerce}\\
{\hbox {\hskip 0.5cm} (as-file [s] (File. s))}\\
{\hbox {\hskip 0.5cm} (as-url [s] (URL. s))}\\
{\hbox {\hskip 0.5cm} MyNewProtocol}\\
{\hbox {\hskip 0.5cm} (myNewMethod [x] (str "answer: " x)))}}
{nil}

\repl{(myNewFunction "test")}
{"answer"}

\repl{(extend-type Long MyNewProtocol (myNewFunction [x] (+ x 1)))}
{nil}

\repl{(myNewFunction 1)}
{2}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Prototypes}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Genclass}

\defsubsection{Overriding protected methods}

In order to override a protected method and call the superclass
you need to make the protected method available under an alternate
name. For examle, to extend Java class Foo with fooMethod(bar) you
would use

\begin{verbatim}
(ns.com.example.subclass-of-Foo
  (:gen-class :extends com.example.Foo
   :exposes-methods {fooMethod fooSuperMethod}))

(defn -fooMethod [this parameter]
 (fooSuperMethod this parameter))
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Proxies}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Macros}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Iterators}

\defsubclass{PersistentTreeMap}{NodeIterator}
\implements{NodeIterator}{Iterator}
\begin{chunk}{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);
    }

    void push(Node t){
        while(t != null)
            {
            stack.push(t);
            t = asc ? t.left() : t.right();
            }
    }

    public boolean hasNext(){
        return !stack.isEmpty();
    }

    public Object next(){
        Node t = (Node) stack.pop();
        push(asc ? t.right() : t.left());
        return t;
    }

    public void remove(){
        throw new UnsupportedOperationException();
    }
}

\end{chunk}

\defsubclass{PersistentTreeMap}{KeyIterator}
\implements{KeyIterator}{Iterator}
\begin{chunk}{PersistentTreeMap KeyIterator Class}
static class KeyIterator implements Iterator{
    NodeIterator it;

    KeyIterator(NodeIterator it){
        this.it = it;
    }

    public boolean hasNext(){
        return it.hasNext();
    }

    public Object next(){
        return ((Node) it.next()).key;
    }

    public void remove(){
        throw new UnsupportedOperationException();
    }
}

\end{chunk}

\defsubclass{PersistentTreeMap}{ValIterator}
\implements{ValIterator}{Iterator}
\begin{chunk}{PersistentTreeMap ValIterator Class}
static class ValIterator implements Iterator{
    NodeIterator it;

    ValIterator(NodeIterator it){
        this.it = it;
    }

    public boolean hasNext(){
        return it.hasNext();
    }

    public Object next(){
        return ((Node) it.next()).val();
    }

    public void remove(){
        throw new UnsupportedOperationException();
    }
}

\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Generating Java Classes}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Type Hints}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Native Arithmetic}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Writing Idiomatic Clojure %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Writing Idiomatic Clojure}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% The Ants Demo %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{The Ants Demo}
\begin{chunk}{The Ants Demo}
\getchunk{Clojure Copyright}

;;;;;;;;;;;;;;;;;;;;;;;;;; ant sim ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;dimensions of square world
(def dim 80)
;number of ants = nants-sqrt^2
(def nants-sqrt 7)
;number of places with food
(def food-places 35)
;range of amount of food at a place
(def food-range 100)
;scale factor for pheromone drawing
(def pher-scale 20.0)
;scale factor for food drawing
(def food-scale 30.0)
;evaporation rate
(def evap-rate 0.99)

(def animation-sleep-ms 100)
(def ant-sleep-ms 40)
(def evap-sleep-ms 1000)

(def running true)

(defstruct cell :food :pher) ;may also have :ant and :home

;world is a 2d vector of refs to cells
(def world 
     (apply vector 
            (map (fn [_] 
                   (apply vector (map (fn [_] (ref (struct cell 0 0))) 
                                      (range dim)))) 
                 (range dim))))

(defn place [[x y]]
  (-> world (nth x) (nth y)))

(defstruct ant :dir) ;may also have :food

(defn create-ant 
  "create an ant at the location, returning an ant agent on the location"
  [loc dir]
    (sync nil
      (let [p (place loc)
            a (struct ant dir)]
        (alter p assoc :ant a)
        (agent loc))))

(def home-off (/ dim 4))
(def home-range (range home-off (+ nants-sqrt home-off)))

(defn setup 
  "places initial food and ants, returns seq of ant agents"
  []
  (sync nil
    (dotimes [i food-places]
      (let [p (place [(rand-int dim) (rand-int dim)])]
        (alter p assoc :food (rand-int food-range))))
    (doall
     (for [x home-range y home-range]
       (do
         (alter (place [x y]) 
                assoc :home true)
         (create-ant [x y] (rand-int 8)))))))

(defn bound 
  "returns n wrapped into range 0-b"
  [b n]
    (let [n (rem n b)]
      (if (neg? n) 
        (+ n b) 
        n)))

(defn wrand 
  "given a vector of slice sizes, returns the index of a slice given a
  random spin of a roulette wheel with compartments proportional to
  slices."
  [slices]
  (let [total (reduce + slices)
        r (rand total)]
    (loop [i 0 sum 0]
      (if (< r (+ (slices i) sum))
        i
        (recur (inc i) (+ (slices i) sum))))))

;dirs are 0-7, starting at north and going clockwise
;these are the deltas in order to move one step in given dir
(def dir-delta {0 [0 -1]
                1 [1 -1]
                2 [1 0]
                3 [1 1]
                4 [0 1]
                5 [-1 1]
                6 [-1 0]
                7 [-1 -1]})

(defn delta-loc 
  "returns the location one step in the given dir. 
  Note the world is a torus"
  [[x y] dir]
    (let [[dx dy] (dir-delta (bound 8 dir))]
      [(bound dim (+ x dx)) (bound dim (+ y dy))]))

;(defmacro dosync [& body]
;  `(sync nil ~@body))

;ant agent functions
;an ant agent tracks the location of an ant, and controls the behavior of 
;the ant at that location

(defn turn 
  "turns the ant at the location by the given amount"
  [loc amt]
    (dosync
     (let [p (place loc)
           ant (:ant @p)]
       (alter p assoc :ant
         (assoc ant :dir (bound 8 (+ (:dir ant) amt))))))
    loc)

(defn move 
  "moves the ant in the direction it is heading. Must be called in a
  transaction that has verified the way is clear"
  [loc]
     (let [oldp (place loc)
           ant (:ant @oldp)
           newloc (delta-loc loc (:dir ant))
           p (place newloc)]
         ;move the ant
       (alter p assoc :ant ant)
       (alter oldp dissoc :ant)
         ;leave pheromone trail
       (when-not (:home @oldp)
         (alter oldp assoc :pher (inc (:pher @oldp))))
       newloc))

(defn take-food [loc]
  "Takes one food from current location. Must be called in a
  transaction that has verified there is food available"
  (let [p (place loc)
        ant (:ant @p)]    
    (alter p assoc 
           :food (dec (:food @p))
           :ant (assoc ant :food true))
    loc))

(defn drop-food [loc]
  "Drops food at current location. Must be called in a
  transaction that has verified the ant has food"
  (let [p (place loc)
        ant (:ant @p)]    
    (alter p assoc 
           :food (inc (:food @p))
           :ant (dissoc ant :food))
    loc))

(defn rank-by 
  "returns a map of xs to their 1-based rank when sorted by keyfn"
  [keyfn xs]
  (let [sorted (sort-by (comp float keyfn) xs)]
    (reduce (fn [ret i] (assoc ret (nth sorted i) (inc i)))
            {} (range (count sorted)))))

(defn behave 
  "the main function for the ant agent"
  [loc]
  (let [p (place loc)
        ant (:ant @p)
        ahead (place (delta-loc loc (:dir ant)))
        ahead-left (place (delta-loc loc (dec (:dir ant))))
        ahead-right (place (delta-loc loc (inc (:dir ant))))
        places [ahead ahead-left ahead-right]]
    (. Thread (sleep ant-sleep-ms))
    (dosync
     (when running
       (send-off *agent* #'behave))
     (if (:food ant)
       ;going home
       (cond 
        (:home @p)                              
          (-> loc drop-food (turn 4))
        (and (:home @ahead) (not (:ant @ahead))) 
          (move loc)
        :else
          (let [ranks (merge-with + 
                        (rank-by (comp #(if (:home %) 1 0) deref) places)
                        (rank-by (comp :pher deref) places))]
          (([move #(turn % -1) #(turn % 1)]
            (wrand [(if (:ant @ahead) 0 (ranks ahead)) 
                    (ranks ahead-left) (ranks ahead-right)]))
           loc)))
       ;foraging
       (cond 
        (and (pos? (:food @p)) (not (:home @p))) 
          (-> loc take-food (turn 4))
        (and (pos? (:food @ahead)) 
             (not (:home @ahead)) 
             (not (:ant @ahead)))
          (move loc)
        :else
          (let [ranks (merge-with + 
                                  (rank-by (comp :food deref) places)
                                  (rank-by (comp :pher deref) places))]
          (([move #(turn % -1) #(turn % 1)]
            (wrand [(if (:ant @ahead) 0 (ranks ahead)) 
                    (ranks ahead-left) (ranks ahead-right)]))
           loc)))))))

(defn evaporate 
  "causes all the pheromones to evaporate a bit"
  []
  (dorun 
   (for [x (range dim) y (range dim)]
     (dosync 
      (let [p (place [x y])]
        (alter p assoc :pher (* evap-rate (:pher @p))))))))

;;;;;;;;;;;;;;;;;;;;;;;; UI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import 
 '(java.awt Color Graphics Dimension)
 '(java.awt.image BufferedImage)
 '(javax.swing JPanel JFrame))

;pixels per world cell
(def scale 5)

(defn fill-cell [#^Graphics g x y c]
  (doto g
    (.setColor c)
    (.fillRect (* x scale) (* y scale) scale scale)))

(defn render-ant [ant #^Graphics g x y]
  (let [black (. (new Color 0 0 0 255) (getRGB))
        gray (. (new Color 100 100 100 255) (getRGB))
        red (. (new Color 255 0 0 255) (getRGB))
        [hx hy tx ty] ({0 [2 0 2 4] 
                        1 [4 0 0 4] 
                        2 [4 2 0 2] 
                        3 [4 4 0 0] 
                        4 [2 4 2 0] 
                        5 [0 4 4 0] 
                        6 [0 2 4 2] 
                        7 [0 0 4 4]}
                       (:dir ant))]
    (doto g
      (.setColor (if (:food ant) 
                  (new Color 255 0 0 255) 
                  (new Color 0 0 0 255)))
      (.drawLine (+ hx (* x scale)) (+ hy (* y scale)) 
                (+ tx (* x scale)) (+ ty (* y scale))))))

(defn render-place [g p x y]
  (when (pos? (:pher p))
    (fill-cell g x y 
      (new Color 0 255 0 
           (int (min 255 (* 255 (/ (:pher p) pher-scale)))))))
  (when (pos? (:food p))
    (fill-cell g x y
      (new Color 255 0 0 
           (int (min 255 (* 255 (/ (:food p) food-scale)))))))
  (when (:ant p)
    (render-ant (:ant p) g x y)))

(defn render [g]
  (let [v (dosync (apply vector (for [x (range dim) y (range dim)] 
                                   @(place [x y]))))
        img (new BufferedImage (* scale dim) (* scale dim) 
                 (. BufferedImage TYPE_INT_ARGB))
        bg (. img (getGraphics))]
    (doto bg
      (.setColor (. Color white))
      (.fillRect 0 0 (. img (getWidth)) (. img (getHeight))))
    (dorun 
     (for [x (range dim) y (range dim)]
       (render-place bg (v (+ (* x dim) y)) x y)))
    (doto bg
      (.setColor (. Color blue))
      (.drawRect (* scale home-off) (* scale home-off) 
                 (* scale nants-sqrt) (* scale nants-sqrt)))
    (. g (drawImage img 0 0 nil))
    (. bg (dispose))))

(def panel (doto (proxy [JPanel] []
                        (paint [g] (render g)))
             (.setPreferredSize (new Dimension 
                                     (* scale dim) 
                                     (* scale dim)))))

(def frame (doto (new JFrame) (.add panel) .pack .show))

(def animator (agent nil))

(defn animation [x]
  (when running
    (send-off *agent* #'animation))
  (. panel (repaint))
  (. Thread (sleep animation-sleep-ms))
  nil)

(def evaporator (agent nil))

(defn evaporation [x]
  (when running
    (send-off *agent* #'evaporation))
  (evaporate)
  (. Thread (sleep evap-sleep-ms))
  nil)

;;;;;;;;;;;;;;;;;;;;;;;; use ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(comment
;demo
(load-file "/Users/rich/dev/clojure/ants.clj")
(def ants (setup))
(send-off animator animation)
(dorun (map #(send-off % behave) ants))
(send-off evaporator evaporation)

)
\end{chunk}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Parallel Processing %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Parallel Processing}

\defsection{Natural Graphs}

Could we do massively parallel work in ``native'' lisp (i.e. not just a
swig cover for MPI). Could we develop a lisp graph data structure that
was designed to be run in parallel with multiple processes (aka closures,
continuations) ``owning'' subgraphs and using the subgraph edges leaving
their ``clades'' as natural communication paths? That way we could develop
a  ``natural map'' from the graph to the available resources.

It raises interesting questions, such as how to dynamically allocate
the graph map to nodes transparently, similar to the way garbage
collection is now transparent. This would allow Lisp programs to
be written against the graph and run in parallel without knowing
about parallel issues. The immutable data structures and STM would help
with the coordination and state issues.

The combination of a processor and a subgraph is called a ``clade'',
similar to the idea of calling a processor and a program a ``process''.

\defsection{Steele's parallel ideas}

From Steele \cite{Ste09} we find the following ideas:

\begin{packeditemize}
\item effective parallelism uses trees
\item associative combining operators are good
\item mapreduce is good
\item catamorphisms are good
\item there are systematic strategies for parallizing sequential code
\item we must lose the accumulator paradigm
\item we must emphasize divide and conquer
\end{packeditemize}

Contrast good sequential code and good parallel code

\begin{packeditemize}
\item good sequential code minimizes total number of operations
\begin{packeditemize}
\item clever tricks to reuse previously computed results
\item good parallel code often performs redundant operations to reduce
communication
\end{packeditemize}
\item good sequential algorithms minimize space usage
\begin{packeditemize}
\item clever tricks to reuse storage
\item good parallel code often requires extra space to permit
temporal decoupling
\end{packeditemize}
\item sequential idioms stress linear problem decomposition
\begin{packeditemize}
\item process on thing at a time and accumulate results
\item good parallel code usually requires multiway problem
\end{packeditemize}
\end{packeditemize}

\begin{packeditemize}
\item linearly linked lists are inherently sequential
\begin{packeditemize}
\item compare peano arithmetic: 5 = ((((0+1)+1)+1)+1)+1
\item binary arithmetic is much more efficient than unayr
\end{packeditemize}
\item we need a multiway decomposition paradigm
\begin{verbatim}
   length [ ] = 0
   length [a] = 1
   length (a++b) = (length a) + (length b)
\end{verbatim}
\end{packeditemize}
This is just a summation problem: adding up a bunch of 1's!

Total work: $\Theta(n)$

Delay: $\Omega(log\ n)$, $O(n)$ depending on how a++b is split
even worse if splitting has worse than constant cost

{\bf Thoughts}

What you want to do versus how you want to do it.

Give the compiler wiggle room. The wiggle room concept is based on the
idea that certain mathematical properties allow the compiler to rewrite
a computation into a parallel form. So the idea of associativity, which
allows terms of an expression to be grouped in arbitrary ways without
affecting the computation allows us to rewrite
\begin{verbatim}
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8
\end{verbatim}
as
\begin{verbatim}
((1 + 2) + (3 + 4)) + ((5 + 6) + (7 + 8))
\end{verbatim}
which then allows the compiler to add the subterms and then add their
results. Steele identifies several mathematical 
properties that the compiler can exploit:
\begin{packeditemize}
\item associativity
\item commutativity
\end{packeditemize}


What are the parallel operators. 
Which of these parallel operators are thinking vs implementation.

Could the add tree be log 32 since add can be multi-arg?
Is there a mapping from persistent trees to parallel code?

Clojure could partition tasks based on log32. A better, more fine
grained alternative is to use \refto{bit-partitioning} to split 
tasks based on the size of the task and the number of processors.
That is,
\begin{verbatim}
  (partition chunksize processors)
\end{verbatim}

Concatenation lists give wiggle room. That is, 
\begin{packeditemize}
\item \verb|<>| is the empty list
\item \verb|<23>| is a singleton list
\item \verb?< a || b >? is a concatenation of a and b
\end{packeditemize}
so
\begin{verbatim}
<<23 || 47> || <18 || 11>>
\end{verbatim}
\pstree{\Tr{\psframebox{$\ ||\ $}}}
  { \pstree{\Tr{\psframebox{$\ ||\ $}}}
    { \Tr{\psframebox{23}}
      \Tr{\psframebox{47}}
    }
    \pstree{\Tr{\psframebox{$\ ||\ $}}}
    { \Tr{\psframebox{18}}
      \Tr{\psframebox{11}}
    }
  }

but the same list could be:
\begin{verbatim}
<<<23 || 47> || 18> || 11>
\end{verbatim}

\pstree{\Tr{\psframebox{$\ ||\ $}}}
  { \pstree{\Tr{\psframebox{$\ ||\ $}}}
    { \pstree{\Tr{\psframebox{$\ ||\ $}}}
      { \Tr{\psframebox{23}}
        \Tr{\psframebox{47}}
      }
      \Tr{\psframebox{18}}
    }
    \Tr{\psframebox{11}}
  }

or
\begin{verbatim}
<<23 || <47 || <>>> || <18 || <<> || 11>>>
\end{verbatim}
\pstree{\Tr{\psframebox{$\ ||\ $}}}
 { \pstree{\Tr{\psframebox{$\ ||\ $}}}
   { \Tr{\psframebox{23}}
     \pstree{\Tr{\psframebox{$\ ||\ $}}}
     { \Tr{\psframebox{47}}
       \Tr{\psframebox{$/$}}
     }
   }
   \pstree{\Tr{\psframebox{$\ ||\ $}}}
   { \Tr{\psframebox{18}}
     \pstree{\Tr{\psframebox{$\ ||\ $}}}
     { \Tr{\psframebox{$/$}}
       \Tr{\psframebox{11}}
     }
   }
 }

or
\begin{verbatim}
<23 || <47 || <18 || <11 || <>>>>>
\end{verbatim}
\pstree{\Tr{\psframebox{$\ ||\ $}}}
  { \Tr{\psframebox{23}}
    \pstree{\Tr{\psframebox{$\ ||\ $}}}
    { \Tr{\psframebox{47}}
      \pstree{\Tr{\psframebox{$\ ||\ $}}}
      { \Tr{\psframebox{18}}
        \pstree{\Tr{\psframebox{$\ ||\ $}}}
        { \Tr{\psframebox{11}}
          \Tr{\psframebox{$/$}}
        }
      }
    }
  }

\defsection{Sequential mapreduce}
For the list form Steele defines three operators, map, reduce, and mapreduce.
They are:
\begin{chunk}{Steele map}
(define (map f xs)                   ; linear in (length xs)
 (cond ((null? xs) '())
       (else (cons (f (car xs)) (map f (cdr xs))))))
\end{chunk}
so, for example,

(map ($\lambda$ (x) (* x x)) '(1 2 3)) $\Rightarrow$ (1 4 9)

\begin{chunk}{Steele reduce}
(define (reduce g id xs)             ; linear in (length xs)
 (cond ((null? xs) id)
       (else (g (car xs) (reduce g id (cdr xs))))))
\end{chunk}
so, for example,

(reduce + 0 '(1 4 9)) $\Rightarrow$ 14

\begin{chunk}{Steele mapreduce}
(define (mapreduce f g id xs)        ; linear in (length xs)
 (ocnd ((null? xs) id)
       (else (g (f (car xs)) (mapreduce f g id (cdr xs))))))
\end{chunk}
so, for example,

(mapreduce ($\lambda$ (x) (* x x)) + 0 '(1 2 3)) $Rightarrow$ 14

\begin{chunk}{Steele length}
(define (length xs)                  ; linear in (length xs)
 (mapreduce (lambda (q) 1) + 0 xs))
\end{chunk}

Using structural recursion, we can define filter as:
\begin{chunk}{Steele filter}
(define (filter p xs)                ; linear in (length xs)
 (cond ((null? xs) '())
       ((p (car xs)) (cons p (filter p (cdr xs))))
       (else (filter p (cdr x)))))
\end{chunk}

Alternatively we could map the predicate down the list:
\begin{chunk}{Steele filter 2}
(define (filter p xs)                ; linear in (length xs)??
 (apply append
  (map (lambda (x) (if (p x) (list x) '())) xs)))
\end{chunk}

Or, by using mapreduce
\begin{chunk}{Steele filter 3}
(define (filter p xs)          ; linear in (length xs)!!
 (mapreduce (lambda (x) (if (p x) (list x) '()))
            append '() xs))    ; each call to append is constant time
\end{chunk}

The reverse function could be defined structurally as:
\begin{chunk}{Steele reverse 1}
(define (reverse xs)                 ; quadratic in (length xs)
 (cond ((null? xs) '())
       (else (addright (reverse (cdr xs)) (car xs)))))
\end{chunk}

Or we could define a new function, revappend, by using the accumulator
trick to reduce the time complexity from quadratic to linear.
\begin{chunk}{Steele revappend}
(define (revappend xs ys)            ; linear in (length xs)
 (cond ((null? xs) ys)
       (else (revappend (cdr xs) (cons (car xs) ys)))))
\end{chunk}

and use it to define reverse:
\begin{chunk}{Steele reverse 2}
(define (reverse xs)                 ; linear in (length xs)
 (revappend xs '()))
\end{chunk}

\defsubsection{Parallel mapreduce}
\begin{chunk}{Steele parallel mapreduce}
(define (mapreduce f g id xs)        ; logarithmic in (length xs)??
 (ocnd ((null? xs) id)
       ((singleton? xs) (f (item xs)))
       (else (split xs (lambda (ys zs)
              (g (mapreduce f g id ys)       ; opportunity for
                 (mapreduce f g id zs))))))) ; parallelism
\end{chunk}

\begin{chunk}{Steele parallel map}
(define (map f xs)
 (mapreduce (lambda (x) (list (f x))) append '() xs)) ; or conc
\end{chunk}

\begin{chunk}{Steele parallel reduce}
(define (reduce g id xs)
 (mapreduce (lambda (x) x) g id xs))
\end{chunk}

\begin{chunk}{Steele parallel length}
(define (length xs)                  ; logarithmic in (length xs)??
 (mapreduce (lambda (q) 1) + 0 xs))
\end{chunk}

\begin{chunk}{Steele parallel filter}
(define (filter p xs)                ; logarithmic in (length xs)??
 (mapreduce (lambda (x) (if (p x) (list x) '()))
            append '() xs))
\end{chunk}

\begin{chunk}{Steele parallel reverse}
(define (reverse xs)                 ; logarithmic in (length xs)??
 (mapreduce list (lambda (ys zx) (append zs ys)) '() xs))
\end{chunk}

\begin{packeditemize}
\item for filter, unlike summation, we rely on maintaining the original
order of the elements in the input list. Thus $||$ and $+$ are associative,
but only $+$ is commutative.
\item do not confuse the ordering of elements in the result list (which is
a spatial order) with the order in which they are computed (which is a 
temporal order)
\item sequential programming often ties spatial order to temporal order
\item it is incorrect to say that since I don't pay attention to the
order in which things are done then we require commutativity. But
commutativity has to do with the spatial ordering in the result, not the
temporal order in which they are computed.
\end{packeditemize}

Steele defines ``Conjugate Transforms'' which, instead of mapping input
items directly to the output data type T:
\begin{packeditemize}
\item map inputs (maybe by way of T) to a richer data type U
\item perform the computation in this richer space U (chosen to make
computation simpler or faster)
\item finally, project the result from U back into T
\end{packeditemize}

Thought: he is just wrapping T with a structure for side information

Thought: much effort needs to be placed on the combining operator




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{MPI Message Passing}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsubsection{The N-colony Ant Demo}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{MapReduce}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% The ant build sequence %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{The ant build sequence}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ant.build}
\begin{chunk}{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"/>
  <property name="test" location="test"/>
  <property name="jsrc" location="${src}/jvm"/>
  <property name="cljsrc" location="${src}/clj"/>
  <property name="build" location="classes"/>
  <property name="test-classes" location="test-classes"/>
  <property name="dist" location="dist"/>
  <!-- override this with 
     -Ddeployment.url=scp://build.clojure.org/srv/test-deploy 
     to test a deployment -->
  <property name="deployment.url" 
            value="scp://build.clojure.org/srv/www/releases"/>

  <target name="debug">
    <echo message="${deployment.url}"/>
  </target>

  <!-- version related properties -->
  <property file="${cljsrc}/clojure/version.properties"/>
  <!-- ensures all version properties are present -->
  <fail unless="clojure.version.major"/>
  <fail unless="clojure.version.minor"/>
  <fail unless="clojure.version.interim"/>

  <condition property="clojure.version.incremental.label"
             value=".${clojure.version.incremental}"
             else="">
      <length string="${clojure.version.incremental}" 
                when="greater" length="0" />
  </condition>
  <condition property="clojure.version.qualifier.label"
             value="-${clojure.version.qualifier}"
             else="">
      <length string="${clojure.version.qualifier}" when="greater" 
                length="0" />
  </condition>
  <condition property="clojure.version.interim.label"
             value="-SNAPSHOT"
             else="">
    <!-- We place -SNAPSHOT whenever interim is not set to false, not 
         only if interim is set to true (this is less typo prone in the 
         worst case -->
      <not><equals arg1="${clojure.version.interim}" arg2="false" 
                     trim="true"/></not>
  </condition>
    
  <property name="cvm"   value="${clojure.version.major}"/>
  <property name="cvm1"  value="${clojure.version.minor}"/>
  <property name="cvil"  value="${clojure.version.incremental.label}"/>
  <property name="cvql"  value="${clojure.version.qualifier.label}"/>
  <property name="cvil1" value="${clojure.version.interim.label}"/>
  <property name="clojure.version.label" 
    value="${cvm}.${cvm1}${cvil}${cvql}${cvil}"/>
    
  <!-- general filterset for use when clojure version must be copied -->
  <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" 
            location="clojure-sources-${clojure.version.label}.jar"/>

  <!-- These make sense for building on tapestry.formos.com -->

  <property name="snapshot.repo.dir" 
            location="/var/www/maven-snapshot-repository"/>
  <property name="stable.repo.dir" location="/var/www/maven-repository"/>

  <target name="init" depends="clean">
    <tstamp/>
    <mkdir dir="${build}"/>
      <antcall target="init-version"/>
  </target>

  <target name="init-version">
    <copy file="pom-template.xml" 
          tofile="pom.xml">
        <filterset refid="clojure-version-filterset"/>
    </copy>
      <!--prevents users from modifying accidentally the generated 
          pom.xml works only on linux.-->
      <chmod file="pom.xml" perm="ugo-w"/>
  </target>

  <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}"/>
      <!-- <sysproperty key="clojure.compile.warn-on-reflection" 
            value="true"/> -->
      <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"/>
      <arg value="clojure.test.tap"/>
      <arg value="clojure.test.junit"/>
      <arg value="clojure.pprint"/>
      <arg value="clojure.java.io"/>
      <arg value="clojure.repl"/>
      <arg value="clojure.java.browse"/>
      <arg value="clojure.java.javadoc"/>
      <arg value="clojure.java.shell"/>
      <arg value="clojure.java.browse-ui"/>
      <arg value="clojure.string"/>
      <arg value="clojure.data"/>
      <arg value="clojure.reflect"/>
    </java>
  </target>

  <target name="build"
          description="Build Clojure (compilation only, no tests)."
          depends="compile-java, compile-clojure"/>

  <target name="compile-tests" 
    description="Compile the subset of tests that require compilation.">
    <delete dir="${test-classes}"/>
    <mkdir dir="${test-classes}"/>
    <java classname="clojure.lang.Compile"
          classpath="${test-classes}:${test}:${build}:${cljsrc}"
          failonerror="true">
      <sysproperty key="clojure.compile.path" value="${test-classes}"/>
      <arg value="clojure.test-clojure.protocols.examples"/>
      <arg value="clojure.test-clojure.genclass.examples"/>
    </java>
  </target>

  <target name="test"
          description="Run clojure tests without recompiling clojure."
          depends="compile-tests">
    <java classname="clojure.main" failonerror="true">
      <classpath>
        <path location="${test-classes}"/>
        <path location="${test}"/>
        <path location="${build}"/>
        <path location="${cljsrc}"/>
      </classpath>
      <arg value="-e"/>
      <arg value=
        "(require '(clojure [test-clojure :as main])) (main/run-ant)"/>
    </java>
  </target>

  <target name="clojure-jar" depends="build"
          description="Create clojure jar file.">
    <jar jarfile="${clojure_jar}" basedir="${build}">
      <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="${clojure_jar}" tofile="${clojure_noversion_jar}" />
  </target>

  <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="all" 
    depends=
      "build,test,clojure-jar,clojure-jar-slim,clojure-jar-sources"/>

  <target name="clean"
          description="Remove autogenerated files and directories.">
    <delete dir="${build}"/>
    <delete dir="${test-classes}"/>
    <delete dir="${dist}"/>
    <delete file="pom.xml"/>
    <delete verbose="true">
      <fileset dir="${basedir}" includes="*.jar"/>
      <fileset dir="${basedir}" includes="*.zip"/>
    </delete>
  </target>

  <target name="setup-maven">
    <typedef resource="org/apache/maven/artifact/ant/antlib.xml" 
    uri="urn:maven-artifact-ant"/>
  </target>

  <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"/>
      <attach file="${src_jar}" classifier="sources"/>
      <attach file="${slim_jar}" classifier="slim"/>
    </mvn:install>
  </target>

  <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>
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{The Execution}
\begin{verbatim}
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,
    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, 
     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.
    [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 
            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 
            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 
            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 
            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 
            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:
             /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
       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
       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
       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
     [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
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% jvm/clojure/asm %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{jvm/clojure/asm/}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AnnotationVisitor.java}
\definterface{AnnotationVisitor}
\begin{chunk}{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).
 */
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. <i>The nested annotation value must be
 *         fully visited before calling other methods on this annotation
 *         visitor</i>.
 */
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. <i>All the array values must be 
 *         visited before calling other methods on this annotation 
 *         visitor</i>.
 */
AnnotationVisitor visitArray(String name);

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

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AnnotationWriter.java}
\defclass{AnnotationWriter}
\implements{AnnotationWriter}{AnnotationVisitor}
\begin{chunk}{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
 * {@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)
        {
        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;
        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);
            }
        }
    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;
        }
}

// -------------------------------------------------------------------
// 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;
        }
}

/**
 * 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;
            }
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Attribute.java}
\defclass{Attribute}
\begin{chunk}{Attribute.java}
\getchunk{France Telecom Copyright}
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.
 */
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 
 * <i>new</i> {@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 <i>new</i> {@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);
    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)
        {
        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.
 *
 * @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;
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ByteVector.java}
\defclass{ByteVector}
\begin{chunk}{ByteVector.java}
\getchunk{France Telecom Copyright}
package clojure.asm;

/**
 * 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);
        }
    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.
 *
 * @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)
        {
        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
            {
            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;
            }
        }
    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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ClassAdapter.java}
\defclass{ClassAdapter}
\implements{ClassAdapter}{ClassVisitor}
\begin{chunk}{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,
        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();
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ClassReader.java}
\defclass{ClassReader}
\begin{chunk}{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;

/**
 * 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. <i>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.</i>
 */
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
// ------------------------------------------------------------------

/**
 * 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;
                    }
                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]);
}

/**
 * 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),
                         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;
            }

        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);
        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. 
 *                     <i>This may corrupt it if this value contains 
 *                     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</i>.
 * @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;
    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);
                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,
                       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(
              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;
                }
            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;
                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"))
                {
                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
        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
                            {
                            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)
                        {
                        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)
                            {
                            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
                        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);
                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;
                        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
         * 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);
                }

            // 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;
                                    }
                                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);
                        }
                    }

                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,
                                                     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;
                                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])
                    {
                    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
                        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;
                    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);
                }
            // 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;
                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 
 * 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 (<i>not including the value name constant pool 
 *             index</i>).
 * @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.
 * @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;
        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] = 
                          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];
                    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;
        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 
 *                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. <i>This method is intended for {@link Attribute} sub 
 * classes, and is normally not needed by class generators or 
 * adapters.</i>
 *
 * @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}. <i>This method is intended for
 * {@link Attribute} sub classes, and is normally not needed by class
 * generators or adapters.</i>
 *
 * @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;
}

/**
 * Reads an unsigned short value in {@link #b b}. <i>This method is
 * intended for {@link Attribute} sub classes, and is normally not 
 * needed by class generators or adapters.</i>
 *
 * @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}. <i>This method is intended
 * for {@link Attribute} sub classes, and is normally not needed by class
 * generators or adapters.</i>
 *
 * @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}. <i>This method is intended 
 * for {@link Attribute} sub classes, and is normally not needed by 
 * class generators or adapters.</i>
 *
 * @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}. <i>This method is intended
 * for {@link Attribute} sub classes, and is normally not needed by class
 * generators or adapters.</i>
 *
 * @param index the start index of the value to be read in {@link #b b}.
 * @return the read value.
 */
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}. <i>This 
 * method is intended for {@link Attribute} sub classes, and is normally 
 * not needed by class generators or adapters.</i>
 *
 * @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:
            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}. <i>This method 
 * is intended for {@link Attribute} sub classes, and is normally not 
 * needed by class generators or adapters.</i>
 *
 * @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}. 
 * <i>This method is intended for {@link Attribute} sub classes, 
 * and is normally not needed by class generators or adapters.</i>
 *
 * @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);
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ClassVisitor.java}
\definterface{ClassVisitor}
\begin{chunk}{ClassVisitor.java}
\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> ] 
 * ( <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.
 *
 * @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);

/**
 * 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). <i>This parameter is only used for 
 *                  static fields</i>. 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 <i>must</i> 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 
 *         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();
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ClassWriter.java}
\defclass{ClassWriter}
\implements{ClassWriter}{ClassVisitor}
\begin{chunk}{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.
 *
 * @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.
 */
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.
 */
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.
 */
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.
 */
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;

/**
 * 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;

/**
 * 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;

/**
 * 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
// -------------------------------------------------------------------

/**
 * 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) {
    // 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();
    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:
 * <p/>
 * <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 
 * <i>won't be removed</i>.</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 <i>lot</i> 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,
        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);
    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){
    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");
        }
    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)
        {
        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);
        }
    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
// -------------------------------------------------------------------

/**
 * 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)
        {
        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. <i>This method is intended for {@link Attribute} 
 * sub classes, and is normally not needed by class generators or 
 * adapters.</i>
 *
 * @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. 
 * <i>This method is intended for {@link Attribute} sub classes, and 
 * is normally not needed by class generators or adapters.</i>
 *
 * @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);
    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.
 * <i>This method is intended for {@link Attribute} sub classes, and is
 * normally not needed by class generators or adapters.</i>
 *
 * @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.
 * <i>This method is intended for {@link Attribute} sub classes, and is
 * normally not needed by class generators or adapters.</i>
 *
 * @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.
 * @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.
 * <i>This method is intended for {@link Attribute} sub classes, and is
 * normally not needed by class generators or adapters.</i>
 *
 * @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);
    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.
 * <i>This method is intended for {@link Attribute} sub classes, and is
 * normally not needed by class generators or adapters.</i>
 *
 * @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;
}

/**
 * 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)
        {
        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. 
 * <i>This method is intended for {@link Attribute} sub classes, and 
 * is normally not needed by class generators or adapters.</i>
 *
 * @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;
}

/**
 * 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;
    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 <i>loads<i> 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 
 * 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.
 */
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 <i>must</i> 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);
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Edge.java}
\defclass{Edge}
\begin{chunk}{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;

/**
 * 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;
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{FieldVisitor.java}
\definterface{FieldVisitor}
\begin{chunk}{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);

/**
 * 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();
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{FieldWriter.java}
\defclass{FieldWriter}
\implements{FieldWriter}{FieldVisitor}
\begin{chunk}{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 
 * 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,
        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){
    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)
        {
        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
       && (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);
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Frame.java}
\defclass{Frame}
\begin{chunk}{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{

/*
     * 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 
     * 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.
 */
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;

/**
 * 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 
 * 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, // -
    // 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, // -
    // 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, // -
    // -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, // -
    // 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.
 */
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.
 * <p/>
 * 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.
 * <p/>
 * 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 <i>every occurence</i> 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){
    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){
    // 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){
    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;
                    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;
        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;
}

/**
 * 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.
 *
 * @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(
        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);
            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);
            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:
            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();
            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:
        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;
        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:
            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();
            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];
        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)
            {
            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;
}

/**
 * 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)
                {
                // 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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Handler.java}
\defclass{Handler}
\begin{chunk}{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;
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Item.java}
\defclass{Item}
\begin{chunk}{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}.
 * <p/>
 * 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.
 */
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.
 *
 * @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.
 *
 * @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.
 *
 * @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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Label.java}
\defclass{Label}
\begin{chunk}{Label.java}
\getchunk{France Telecom Copyright}
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.
 */
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 
 * 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", 
 * <i>relatively</i> to the frame state at the beginning of the basic 
 * block, which is called the "input frame", and which is <i>unknown</i> 
 * 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.
 * <p/>
 * When only the maximum stack size is computed, this field is the 
 * number of elements in the input stack.
 * <p/>
 * When the stack map frames are completely computed, this field is 
 * the offset of the first output stack element relatively to the top 
 * 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
// -------------------------------------------------------------------

/**
 * 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. <i>This method 
 * is intended for {@link Attribute} sub classes, and is normally 
 * not needed by class generators or adapters.</i>
 *
 * @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 
 *                   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){
    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)
        {
        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 
 * 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);
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{MethodAdapter.java}
\defclass{MethodAdapter}
\implements{MethodAdapter}{MethodVisitor}
\begin{chunk}{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;

/**
 * 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);
}

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,
        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();
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{MethodVisitor.java}
\definterface{MethodVisitor}
\begin{chunk}{MethodVisitor.java}
\getchunk{France Telecom Copyright}
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><i>X</i>Insn</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><i>X</i>Insn</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 <i>before</i> the 
 * labels passed as arguments have been visited, and the 
 * <tt>visitLocalVariable</tt> and <tt>visitLineNumber</tt> methods 
 * must be called <i>after</i> 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);

/**
 * 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 <i>just before</i> any
 * instruction <b>i</b> 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 <i>just before</i> <b>i</b> is executed. 
 * <br> <br> (*) this is mandatory only for classes whose version 
 * is greater than or equal to {@link Opcodes#V1_6 V1_6}. <br> <br> 
 * 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 
 * 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 
 *               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.<br> When
 *                opcode is BIPUSH, operand value should be between 
 *                Byte.MIN_VALUE and Byte.MAX_VALUE.<br> When opcode 
 *                is SIPUSH, operand value should be between 
 *                Short.MIN_VALUE and Short.MAX_VALUE.<br> 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);

/**
 * 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 
 *               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[]);

/**
 * 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.
 * @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();
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{MethodWriter.java}
\defclass{MethodWriter}
\implements{MethodWriter}{MethodVisitor}
\begin{chunk}{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
 * 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}).
 */
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;

/**
 * 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.
 */
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.
 */
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.
 */
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.
 */
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){
    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
// -------------------------------------------------------------------

public AnnotationVisitor visitAnnotationDefault(){
    annd = new ByteVector();
    return new AnnotationWriter(cw, false, annd, null, 0);
}

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 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[
                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
                {
                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]);
                    }
                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;
        }
}

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;
            }
        }
    // 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)
            {
            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);
            }
        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;
                }
            // 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)
                {
                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
            {
            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)
                {
                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)
        {
        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;
            }
        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);
        }
}

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);
}

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();
        }
}

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,
        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)
        {
        // 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 
            // 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;
                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;
                    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
         * 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
        {
        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')
                {
                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;
}

/**
 * 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,
        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;
                        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];
        ++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;
}

/**
 * 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)
            {
            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);
            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;
                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()));
            }
        }
}

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");
            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)
        {
        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)
        {
        ++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;
            }
        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;
            }
        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]);
            }
        }
    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 
// 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. <p> <i>This method must be called after all the method 
 * that is being built has been visited</i>. 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).
     */
    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
                               || 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;
                    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;
                }
            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 
                    // 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;
            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);
                    }
                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();
            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;
        }
    // 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;
        }

    // 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;
}

/**
 * Computes the future value of a bytecode offset. <p> 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 <i>last</i> byte, plus one (or, in other words, by 
 *                the index of the <i>first</i> byte of the <i>next</i> 
 *                instruction).
 * @param sizes   the number of bytes to be <i>added</i> 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 <i>last</i> |<tt>sizes[i]</tt>|
 *                bytes of the instruction will be removed (the 
 *                instruction size <i>must not</i> 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.
 *
 * @param indexes current positions of the instructions to be resized. 
 *                Each instruction must be designated by the index of 
 *                its <i>last</i> byte, plus one (or, in other words, 
 *                by the index of the <i>first</i> byte of the 
 *                <i>next</i> instruction).
 * @param sizes   the number of bytes to be <i>added</i> 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 <i>last</i> | <tt>sizes[i]</tt>| 
 *                bytes of the instruction will be  removed (the 
 *                instruction size <i>must not</i> 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;
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Opcodes.java}
\definterface{Opcodes}
\begin{chunk}{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.
 *
 * @author Eric Bruneton
 * @author Eugene Kuleshov
 */
public interface Opcodes{

// versions

int V1_1 = 3 << 16 | 45;
int V1_2 = 0 << 16 | 46;
int V1_3 = 0 << 16 | 47;
int V1_4 = 0 << 16 | 48;
int V1_5 = 0 << 16 | 49;
int V1_6 = 0 << 16 | 50;

// 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;

// 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; // -
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; // -
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; // -
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; // -
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; // -
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Type.java}
\defclass{Type}
\begin{chunk}{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;

/**
 * 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);

/**
 * 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.
 */
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.
 */
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>.
 * <i>Note that opposed to {@link Type#getType(String)}, this method 
 * takes internal class names and not class descriptor.</i>
 *
 * @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] != ')')
        {
        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());
}

/**
 * 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] != ';')
                {
                ++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.
 *
 * @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);
}

// -------------------------------------------------------------------
// 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:
            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('.', '/');
}

/**
 * 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.
 *
 * @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())
            {
            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)
            {
            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
// -------------------------------------------------------------------

/**
 * 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]);
            }
        }
    return hc;
}

/**
 * Returns a string representation of this type.
 *
 * @return the descriptor of this type.
 */
public String toString(){
    return getDescriptor();
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% jvm/clojure/asm/commons %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{jvm/clojure/asm/commons}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AdviceAdapter.java}
\defclass{AdviceAdapter}
\implements{AdviceAdapter}{Opcodes}
\extends{AdviceAdapter}{GeneratorAdapter}
\begin{chunk}{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. <p> The behavior for constructors 
 * is like this: <ol>
 * <p/>
 * <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>
 * <p/>
 * <li>when this one is reached, it is only added in the ctor code 
 * visitor and a JP invoke is added</li>
 * <p/>
 * <li>after that, only the other code visitor receives the 
 * instructions</li>
 * <p/>
 * </ol>
 *
 * @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();
        }
}

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:
            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
            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();
                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;

            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:
            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)
        {
        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)
        {
        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();
                }
            }
        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:
                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);
        }
}

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. <br><br>
 * <p/>
 * <i>Custom code can use or change all the local variables, but 
 * should not change state of the stack.</i>
 */
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:
 * <p/>
 * <pre>
 *   public void onMethodExit(int opcode) {
 *     if(opcode==RETURN) {
 *         visitInsn(ACONST_NULL);
 *     } else if(opcode==ARETURN || opcode==ATHROW) {
 *         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");
 *   }
 * <p/>
 *   // an actual call back method
 *   public static void onExit(int opcode, Object param) {
 *     ...
 * </pre>
 * <p/>
 * <br><br>
 * <p/>
 * <i>Custom code can use or change all the local variables, but should 
 * not change state of the stack.</i>
 *
 * @param opcode one of the RETURN, IRETURN, FRETURN, ARETURN, LRETURN,
 *               DRETURN or ATHROW
 */
protected abstract void onMethodExit(int opcode);

// TODO onException, onMethodCall

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AnalyzerAdapter.java}
\defclass{AnalyzerAdapter}
\extends{AnalyzerAdapter}{MethodAdapter}
\begin{chunk}{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;

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 
 * visit<i>XXX</i> 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 <i>before</i> each instruction by reading 
 * the value of these fields in its visit<i>XXX</i> 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 
 * 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();

    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,
        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)
       || 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,
        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);
                    }
                }
            }
        }
    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);
        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;
}

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':
        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);
        }
}

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:
        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;
        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:
            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();
            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:
        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;
        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();
            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);
                }
            break;
            // case Opcodes.MULTIANEWARRAY:
        default:
            pop(iarg);
            pushDesc(sarg);
            break;
        }
    labels = null;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{CodeSizeEvaluator.java}
\defclass{CodeSizeEvaluator}
\extends{CodeSizeEvaluator}{MethodAdapter}
\implements{CodeSizeEvaluator}{Opcodes}
\begin{chunk}{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;
}

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){
    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
        {
        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)
        {
        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);
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{EmptyVisitor.java}
\defclass{EmptyVisitor}
\implements{EmptyVisitor}{ClassVisitor}
\implements{EmptyVisitor}{FieldVisitor}
\implements{EmptyVisitor}{MethodVisitor}
\implements{EmptyVisitor}{AnnotationVisitor}
\begin{chunk}{EmptyVisitor.java}
\getchunk{France Telecom Copyright}
package clojure.asm.commons;

import clojure.asm.AnnotationVisitor;
import clojure.asm.Attribute;
import clojure.asm.ClassVisitor;
import clojure.asm.FieldVisitor;
import clojure.asm.Label;
import clojure.asm.MethodVisitor;

/**
 * An empty implementation of the ASM visitor interfaces.
 *
 * @author Eric Bruneton
 */
public class EmptyVisitor implements
                          ClassVisitor,
                          FieldVisitor,
                          MethodVisitor,
                          AnnotationVisitor{

public void visit(
        final int version,
        final int access,
        final String name,
        final String signature,
        final String superName,
        final String[] interfaces){
}

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

public void visitOuterClass(
        final String owner,
        final String name,
        final String desc){
}

public AnnotationVisitor visitAnnotation(
        final String desc,
        final boolean visible){
    return this;
}

public void visitAttribute(final Attribute attr){
}

public void visitInnerClass(
        final String name,
        final String outerName,
        final String innerName,
        final int access){
}

public FieldVisitor visitField(
        final int access,
        final String name,
        final String desc,
        final String signature,
        final Object value){
    return this;
}

public MethodVisitor visitMethod(
        final int access,
        final String name,
        final String desc,
        final String signature,
        final String[] exceptions){
    return this;
}

public void visitEnd(){
}

public AnnotationVisitor visitAnnotationDefault(){
    return this;
}

public AnnotationVisitor visitParameterAnnotation(
        final int parameter,
        final String desc,
        final boolean visible){
    return this;
}

public void visitCode(){
}

public void visitFrame(
        final int type,
        final int nLocal,
        final Object[] local,
        final int nStack,
        final Object[] stack){
}

public void visitInsn(final int opcode){
}

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

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

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

public void visitFieldInsn(
        final int opcode,
        final String owner,
        final String name,
        final String desc){
}

public void visitMethodInsn(
        final int opcode,
        final String owner,
        final String name,
        final String desc){
}

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

public void visitLabel(final Label label){
}

public void visitLdcInsn(final Object cst){
}

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

public void visitTableSwitchInsn(
        final int min,
        final int max,
        final Label dflt,
        final Label labels[]){
}

public void visitLookupSwitchInsn(
        final Label dflt,
        final int keys[],
        final Label labels[]){
}

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

public void visitTryCatchBlock(
        final Label start,
        final Label end,
        final Label handler,
        final String type){
}

public void visitLocalVariable(
        final String name,
        final String desc,
        final String signature,
        final Label start,
        final Label end,
        final int index){
}

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

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

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

public void visitEnum(
        final String name,
        final String desc,
        final String value){
}

public AnnotationVisitor visitAnnotation(
        final String name,
        final String desc){
    return this;
}

public AnnotationVisitor visitArray(final String name){
    return this;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{GeneratorAdapter.java}
\defclass{GeneratorAdapter}
\extends{GeneratorAdapter}{LocalVariablesSorter}
\begin{chunk}{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;
import clojure.asm.Type;

/**
 * A {@link clojure.asm.MethodAdapter} with convenient methods to 
 * generate code. For example, using this adapter, the class below
 * <p/>
 * <pre>
 * public class Example {
 *     public static void main(String[] args) {
 *         System.out.println(&quot;Hello world!&quot;);
 *     }
 * }
 * </pre>
 * <p/>
 * can be generated as follows:
 * <p/>
 * <pre>
 * ClassWriter cw = new ClassWriter(true);
 * cw.visit(V1_1, ACC_PUBLIC, &quot;Example&quot;, null, 
 *          &quot;java/lang/Object&quot;, null);
 * <p/>
 * Method m = Method.getMethod(&quot;void &lt;init&gt; ()&quot;);
 * GeneratorAdapter mg = 
 *      new GeneratorAdapter(ACC_PUBLIC, m, null, null, cw);
 * mg.loadThis();
 * mg.invokeConstructor(Type.getType(Object.class), m);
 * mg.returnValue();
 * mg.endMethod();
 * <p/>
 * m = Method.getMethod(&quot;void main (String[])&quot;);
 * mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);
 * mg.getStatic(Type.getType(System.class), &quot;out&quot;, 
 *              Type.getType(PrintStream.class));
 * mg.push(&quot;Hello world!&quot;);
 * mg.invokeVirtual(Type.getType(PrintStream.class), 
 *                  Method.getMethod(&quot;void println (String)&quot;));
 * mg.returnValue();
 * mg.endMethod();
 * <p/>
 * 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");

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;

/**
 * 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;

/**
 * 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;

/**
 * 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
 *                   <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);
}

/**
 * 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
        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)
        {
        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);
}

/**
 * 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.
 */
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 
 * 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.
 */
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(){
    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();
            }
        }
    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);
}

/**
 * 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)
                {
                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){
    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();
            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);
        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())
        {
        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)
        {
        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>.
 */
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.
 * @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();
                }
            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.
 * @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);
}

// -------------------------------------------------------------------
// 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.
 */
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.
 */
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.
 */
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);
}

/**
 * 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());
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{LocalVariablesSorter.java}
\defclass{LocalVariablesSorter}
\extends{LocalVariablesSorter}{MethodAdapter}
\begin{chunk}{LocalVariablesSorter.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;
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.
 */
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:
        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
    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;
}

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

/**
 * 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
 */
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;
    if(value == 0)
        {
        throw new 
            IllegalStateException("Unknown local variable " + var);
        }
    return value - 1;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Method.java}
\defclass{Method}
\begin{chunk}{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;

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 
 *               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;
    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);
            }
        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;
}

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();
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{SerialVersionUIDAdder.java}
\defclass{SerialVersionUIDAdder}
\extends{SerialVersionUIDAdder}{ClassAdapter}
\begin{chunk}{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:
 * <p/>
 * <pre>
 *   ClassWriter cw = new ClassWriter(...);
 *   ClassVisitor sv = new SerialVersionUIDAdder(cw);
 *   ClassVisitor ca = new MyClassAdapter(sv);
 *   new ClassReader(orginalClass).accept(ca, false);
 * </pre>
 * <p/>
 * The SVUID algorithm can be found on the java.sun.com website under
 * "j2se/1.4.2/docs/guide/serialization/spec/class.html"
 * <p/>
 * <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.
 * <p/>
 * The sequence of items in the stream is as follows:
 * <p/>
 * 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, &lt;clinit&gt;, 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, &lt;init&gt;, 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].
 * <p/>
 * 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:
 * <p/>
 * long hash = ((sha[0] &gt;&gt;&gt; 24) &amp; 0xFF) |
 * ((sha[0] &gt;&gt;&gt; 16) &amp; 0xFF) &lt;&lt; 8 |
 * ((sha[0] &gt;&gt;&gt; 8) &amp; 0xFF) &lt;&lt; 16 |
 * ((sha[0] &gt;&gt;&gt; 0) &amp; 0xFF) &lt;&lt; 24 |
 * ((sha[1] &gt;&gt;&gt; 24) &amp; 0xFF) &lt;&lt; 32 |
 * ((sha[1] &gt;&gt;&gt; 16) &amp; 0xFF) &lt;&lt; 40 |
 * ((sha[1] &gt;&gt;&gt; 8) &amp; 0xFF) &lt;&lt; 48 |
 * ((sha[1] &gt;&gt;&gt; 0) &amp; 0xFF) &lt;&lt; 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.
 */
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);
}

/*
 * 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.
 */
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",
                          "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));

        /*
         * 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.
         */
        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.
 */
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;

    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;
    }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{StaticInitMerger.java}
\defclass{StaticInitMerger}
\extends{StaticInitMerger}{ClassAdapter}
\begin{chunk}{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;

public StaticInitMerger(final String prefix, final ClassVisitor cv){
    super(cv);
    this.prefix = prefix;
}

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);
    this.name = name;
}

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();
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{TableSwitchGenerator.java}
\definterface{TableSwitchGenerator}
\begin{chunk}{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();
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% jvm/clojure/lang/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{jvm/clojure/lang/}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AFn.java}
\defclass{AFn}
\implements{AFn}{IFn}
\begin{chunk}{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);
}

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, 
                     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, 
                     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, 
                     Object arg10, Object arg11, Object arg12, 
                     Object arg13, Object arg14, Object arg15, 
                     Object arg16) 
        throws Exception{
    return throwArity(16);
}

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 throwArity(17);
}

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 throwArity(18);
}

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 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{
    return throwArity(20);
}


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, Object... args)
        throws Exception{
    return throwArity(21);
}

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()
                    , 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()
                    , 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()
                    , (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()
                    , (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()
                    , (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)
            );
        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('_', '-'));
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AFunction.java}
\defclass{AFunction}
\extends{AFunction}{AFn}
\implements{AFunction}{IObj}
\implements{AFunction}{Comparator}
\implements{AFunction}{Fn}
\implements{AFunction}{Serializable}
\begin{chunk}{AFunction.java}
/*
\getchunk{Clojure Copyright}
*/
/* rich Dec 16, 2008 */

package 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);
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Agent.java}
\defclass{Agent}
\extends{Agent}{ARef}
\begin{chunk}{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;
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) {
    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
                }
            }
    }

    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);
                }

            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;
}

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)
        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();
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AMapEntry.java}
\defclass{AMapEntry}
\extends{AMapEntry}{APersistentVector}
\implements{AMapEntry}{IMapEntry}
\begin{chunk}{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){
    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);
}

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();
}
*/

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{APersistentMap.java}
\defclass{APersistentMap}
\extends{APersistentMap}{AFn}
\implements{APersistentMap}{IPersistentMap}
\implements{APersistentMap}{Map}
\implements{APersistentMap}{Iterable}
\implements{APersistentMap}{Serializable}
\implements{APersistentMap}{MapEquivalence}
\begin{chunk}{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);
}

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)
        {
        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;

    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(){

        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();
                    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();
                    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))
            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;
}
*/
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{APersistentSet.java}
\defclass{APersistentSet}
\extends{APersistentSet}{AFn}
\implements{APersistentSet}{IPersistentSet}
\implements{APersistentSet}{Collection}
\implements{APersistentSet}{Set}
\implements{APersistentSet}{Serializable}
\begin{chunk}{APersistentSet.java}
/*
\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;

    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){
    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());
}

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{APersistentVector.java}
\defclass{APersistentVector}
\extends{APersistentVector}{AFn}
\implements{APersistentVector}{IPersistentVector}
\implements{APersistentVector}{Iterable}
\implements{APersistentVector}{List}
\implements{APersistentVector}{RandomAccess}
\implements{APersistentVector}{Comparable}
\implements{APersistentVector}{Serializable}
\begin{chunk}{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;
        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;
        }
//    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++)
//            {
//            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++);
        }

        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();
}


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))
        {
        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();
}

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())
        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);
    }

    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){
        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;
    }

    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;
    }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{AReference.java}
\defclass{AReference}
\implements{AReference}{IReference}
\begin{chunk}{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) {
        _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;
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ARef.java}
\defclass{ARef}
\extends{ARef}{AReference}
\implements{ARef}{IRef}
\begin{chunk}{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
        {
        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)
        {
        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);
                }
            }
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ArityException.java}
\defclass{ArityException}
\extends{ArityException}{IllegalArgumentException}
\begin{chunk}{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) {
        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;
    }

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ArrayChunk.java}
\defclass{ArrayChunk}
\implements{ArrayChunk}{IChunk}
\implements{ArrayChunk}{Serializable}
\begin{chunk}{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];
}

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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ArraySeq.java}
\defclass{ArraySeq}
\extends{ArraySeq}{ASeq}
\implements{ArraySeq}{IndexedSeq}
\implements{ArraySeq}{IReduce}
\begin{chunk}{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(){
    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));
}

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++)
            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 
  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++)
                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);
    }

    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(){
        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;
    }
}

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) {
        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){
        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;

    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) {
            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;
    }

    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;
    }
}

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ASeq.java}
\defclass{ASeq}
\extends{ASeq}{Obj}
\implements{ASeq}{ISeq}
\implements{ASeq}{List}
\implements{ASeq}{Serializable}
\begin{chunk}{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){
    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();
//}

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();
}

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;
}


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);
}

public void add(int index, Object element){
    throw new UnsupportedOperationException();
}

public boolean addAll(int index, Collection c){
    throw new UnsupportedOperationException();
}

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Associative.java}
\definterface{Associative}
\extends{Associative}{IPersistentCollection}
\extends{Associative}{ILookup}
\begin{chunk}{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);

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Atom.java}
\defclass{Atom}
\extends{Atom}{ARef}
\begin{chunk}{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;

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))
            {
            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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ATransientMap.java}
\defclass{ATransientMap}
\extends{ATransientMap}{AFn}
\implements{ATransientMap}{ITransientMap}
\begin{chunk}{ATransientMap.java}
/*
\getchunk{Clojure Copyright}
*/
package clojure.lang;

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());
            }
        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));
            }
        
        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);
    }

    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();
    }
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ATransientSet.java}
\defclass{ATransientSet}
\extends{ATransientSet}{AFn}
\implements{ATransientSet}{ITransientSet}
\begin{chunk}{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() {
        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);    
    }
    
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{BigInt.java}
\defclass{BigInt}
\extends{BigInt}{Number}
\begin{chunk}{BigInt.java}
/*
\getchunk{Clojure Copyright}
*/
/* chouser Jun 23, 2010 */

package clojure.lang;

import java.math.BigInteger;

public final class BigInt extends Number{

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;
}

///// 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(){
    if(bipart == null)
        return String.valueOf(lpart);
    return bipart.toString();
}

public int bitLength(){
    return toBigInteger().bitLength();
}

}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Binding.java}
\defclass{Binding}
\begin{chunk}{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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Box.java}
\defclass{Box}
\begin{chunk}{Box.java}
/*
\getchunk{Clojure Copyright}
*/
/* rich Mar 27, 2006 8:40:19 PM */

package clojure.lang;

public class Box{

public Object val;

public Box(Object val){
    this.val = val;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ChunkBuffer.java}
\defclass{ChunkBuffer}
\implements{ChunkBuffer}{Counted}
\begin{chunk}{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;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{ChunkedCons.java}
\defclass{ChunkedCons}
\extends{ChunkedCons}{ASeq}
\implements{ChunkedCons}{IChunkedSeq}
\begin{chunk}{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;
}

public IChunk chunkedFirst(){
    return chunk;
}

public ISeq chunkedNext(){
    return chunkedMore().seq();    
}

public ISeq chunkedMore(){
    if(_more == null)
        return PersistentList.EMPTY;
    return _more;
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Compile.java}
\defclass{Compile}
\begin{chunk}{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{

    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);
            }
        }
}
}
\end{chunk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\defsection{Compiler.java}
\defclass{Compiler}
\implements{Compiler}{Opcodes}
\begin{chunk}{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");
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(),
        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 = 
    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>
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();

//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(){
        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 = 
        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());
                }
            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{
        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)))
                {
                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();
    }

    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;
    }

    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 + 
                                " 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{
        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{
    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()");

    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);
                        }
                    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)");
                    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 ...)");
            //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)));
                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){
                            //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"))
                        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;
        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)
                {
                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);
            }
        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());

        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();
            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);
                    }
                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;

    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);
                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;
            }
    }

    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)
                {
                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;
    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);
            }
    }

    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), 
                                  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)
                {
                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;

    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());
    }

    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();
        //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{
    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);
    }

    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");
    }

    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;
    }

    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), 
                             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{

        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)
                            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 = 
                              (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();
//        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;
    }


    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)
        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), 
                          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);
            }

        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)
                {
                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)");


    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();
    }

    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);
        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");
            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 =
        PersistentHashMap.create('-', "_",
//                                 '.', "_DOT_",
':', "_COLON_",
'+', "_PLUS_",
'>', "_GT_",
'<', "_LT_",
'=', "_EQ_",
'~', "_TILDE_",
'!', "_BANG_",
'@', "_CIRCA_",
'#', "_SHARP_",
'$', "_DOLLARSIGN_",
'%', "_PERCENT_",
'^', "_CARET_",
'&', "_AMPERSAND_",
'*', "_STAR_",
'|', "_BAR_",
'{', "_LBRACE_",
'}', "_RBRACE_",
'[', "_LBRACK_",
']', "_RBRACK_",
'/', "_SLASH_",
'\\', "_BSLASH_",
'?', "_QMARK_");

static public String munge(String name){
    StringBuilder sb = new StringBuilder();
    for(char c : name.toCharArray())
        {
        String sub = (String) CHAR_MAP.valAt(c);
        if(sub != null)
            sb.append(sub);
        else
            sb.append(c);
        }
    return sb.toString();
}

public static class EmptyExpr implements Expr{
    public final Object coll;
    final static Type HASHMAP_TYPE = 
        Type.getType(PersistentArrayMap.class);
    final static Type HASHSET_TYPE = 
        Type.getType(PersistentHashSet.class);
    final static Type VECTOR_TYPE = 
        Type.getType(PersistentVector.class);
    final static Type LIST_TYPE = 
        Type.getType(PersistentList.class);
    final static Type EMPTY_LIST_TYPE = 
        Type.getType(PersistentList.EmptyList.class);


    public EmptyExpr(Object coll){
        this.coll = coll;
    }

    public Object eval() throws Exception{
        return coll;
    }

    public void emit(C context, ObjExpr objx, GeneratorAdapter gen){
        if(coll instanceof IPersistentList)
            gen.getStatic(LIST_TYPE, "EMPTY", EMPTY_LIST_TYPE);
        else if(coll instanceof IPersistentVector)
            gen.getStatic(VECTOR_TYPE, "EMPTY", VECTOR_TYPE);
        else if(coll instanceof IPersistentMap)
                gen.getStatic(HASHMAP_TYPE, "EMPTY", HASHMAP_TYPE);
            else if(coll instanceof IPersistentSet)
                    gen.getStatic(HASHSET_TYPE, "EMPTY", HASHSET_TYPE);
                else
                    throw new UnsupportedOperationException(
                      "Unknown Collection type");
        if(context == C.STATEMENT)
            {
            gen.pop();
            }
    }

    public boolean hasJavaClass() throws Exception{
        return true;
    }

    public Class getJavaClass() throws Exception{
        if(coll instanceof IPersistentList)
            return IPersistentList.class;
        else if(coll instanceof IPersistentVector)
            return IPersistentVector.class;
        else if(coll instanceof IPersistentMap)
                return IPersistentMap.class;
            else if(coll instanceof IPersistentSet)
                    return IPersistentSet.class;
                else
                    throw new UnsupportedOperationException(
                       "Unknown Collection type");
    }
}

public static class ListExpr implements Expr{
    public final IPersistentVector args;
    final static Method arrayToListMethod = 
      Method.getMethod("clojure.lang.ISeq arrayToList(Object[])");


    public ListExpr(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.seq();
    }

    public void emit(C context, ObjExpr objx, GeneratorAdapter gen){
        MethodExpr.emitArgsAsArray(args, objx, gen);
        gen.invokeStatic(RT_TYPE, arrayToListMethod);
        if(context == C.STATEMENT)
            gen.pop();
    }

    public boolean hasJavaClass() throws Exception{
        return true;
    }

    public Class getJavaClass() throws Exception{
        return IPersistentList.class;
    }

}

public static class MapExpr implements Expr{
    public final IPersistentVector keyvals;
    final static Method mapMethod = 
       Method.getMethod("clojure.lang.IPersistentMap map(Object[])");


    public MapExpr(IPersistentVector keyvals){
        this.keyvals = keyvals;
    }

    public Object eval() throws Exception{
        Object[] ret = new Object[keyvals.count()];
        for(int i = 0; i < keyvals.count(); i++)
            ret[i] = ((Expr) keyvals.nth(i)).eval();
        return RT.map(ret);
    }

    public void emit(C context, ObjExpr objx, GeneratorAdapter gen){
        MethodExpr.emitArgsAsArray(keyvals, objx, gen);
        gen.invokeStatic(RT_TYPE, mapMethod);
        if(context == C.STATEMENT)
            gen.pop();
    }

    public boolean hasJavaClass() throws Exception{
        return true;
    }

    public Class getJavaClass() throws Exception{
        return IPersistentMap.class;
    }


    static public Expr parse(C context, IPersistentMap form) 
      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;
    }

    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++)
                {
                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;

        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);
    }

    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),
                      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{
        return HostExpr.tagToClass(tag);
    }

}
//static class KeywordSiteInvokeExpr implements Expr{
//    public final Expr site;
//    public final Object tag;
//    public final Expr target;
//    public final int line;
//    public final String source;
//
//    public KeywordSiteInvokeExpr(String source, int line, 
//                                 Symbol tag, Expr site, Expr target){
//        this.source = source;
//        this.site = site;
//        this.target = target;
//        this.line = line;
//        this.tag = tag;
//    }
//
//    public Object eval() throws Exception{
//        try
//            {
//            KeywordCallSite s = (KeywordCallSite) site.eval();
//            return s.thunk.invoke(s,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){
//        gen.visitLineNumber(line, gen.mark());
//        site.emit(C.EXPRESSION, objx, gen);
//        gen.dup();
//        gen.getField(Type.getType(KeywordCallSite.class),
//                     "thunk",IFN_TYPE);
//        gen.swap();
//        target.emit(C.EXPRESSION, objx, gen);
//
//        gen.invokeInterface(IFN_TYPE, 
//                   new Method("invoke", OBJECT_TYPE, ARG_TYPES[2]));
//        if(context == C.STATEMENT)
//            gen.pop();
//    }
//
//    public boolean hasJavaClass() throws Exception{
//        return tag != null;
//    }
//
//    public Class getJavaClass() throws Exception{
//        return HostExpr.tagToClass(tag);
//    }
//
//}

public static class InstanceOfExpr 
  implements Expr, MaybePrimitiveExpr{
    Expr expr;
    Class c;

    public InstanceOfExpr(Class c, Expr expr){
        this.expr = expr;
        this.c = c;
    }

    public Object eval() throws Exception{
        if(c.isInstance(expr.eval()))
            return RT.T;
        return RT.F;
    }

    public boolean canEmitPrimitive(){
        return true;
    }

    public void emitUnboxed(C context, 
                            ObjExpr objx, 
                            GeneratorAdapter gen){
        expr.emit(C.EXPRESSION, objx, gen);
        gen.instanceOf(getType(c));
    }

    public void emit(C context, ObjExpr objx, GeneratorAdapter gen){
        emitUnboxed(context,objx,gen);
        HostExpr.emitBoxReturn(objx,gen,Boolean.TYPE);
        if(context == C.STATEMENT)
            gen.pop();
    }

    public boolean hasJavaClass() throws Exception{
        return true;
    }

    public Class getJavaClass() throws Exception{
        return Boolean.TYPE;
    }

}

static class StaticInvokeExpr implements Expr, MaybePrimitiveExpr{
    public final Type target;
    public final Class retClass;
    public final Class[] paramclasses;
    public final Type[] paramtypes;
    public final IPersistentVector args;
    public final boolean variadic;
    public final Symbol tag;

    StaticInvokeExpr(Type target, 
                     Class retClass, 
                     Class[] paramclasses, 
                     Type[] paramtypes, 
                     boolean variadic,
                     IPersistentVector args,Symbol tag){
        this.target = target;
        this.retClass = retClass;
        this.paramclasses = paramclasses;
        this.paramtypes = paramtypes;
        this.args = args;
        this.variadic = variadic;
        this.tag = tag;
    }

    public Object eval() throws Exception{
        throw new UnsupportedOperationException(
                                      "Can't eval StaticInvokeExpr");
    }

    public void emit(C context, ObjExpr objx, GeneratorAdapter gen){
        emitUnboxed(context, objx, gen);
        if(context != C.STATEMENT)
            HostExpr.emitBoxReturn(objx,gen,retClass);
        if(context == C.STATEMENT)
            {
            if(retClass == long.class || retClass == double.class)
                gen.pop2();
            else
                gen.pop();
            }
    }

    public boolean hasJavaClass() throws Exception{
        return true;
    }

    public Class getJavaClass() throws Exception{
        return tag != null ? HostExpr.tagToClass(tag) : retClass;
    }

    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)
                    {
                    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;
                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
                                .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: " + 
                              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);
            }

        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, 
                          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();
            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);
            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);
    }
}

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,
                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,
                           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(
                 "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
            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;

    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;
    }

    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();
            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" +
                          (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);
            }

        //static fields for lookup sites
        for(int i = 0; i < keywordCallsites.count(); i++)
            {
            cv.visitField(ACC_FINAL
                          + ACC_STATIC, 
                          siteNameStatic(i), 
                          KEYWORD_LOOKUPSITE_TYPE.getDescriptor(),
                          null, null);
            cv.visitField(ACC_STATIC, 
                          thunkNameStatic(i), 
                          ILOOKUP_THUNK_TYPE.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)
            {
            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())
                {
                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
        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);
                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();
            }

        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,
                                                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();
                }
            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){
    }

    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())
                {
                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)"));
//           }
        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)
                {
                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();
            }
    }

    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)
                {
                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
            {
            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
            {
            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);
                        }
                    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);
    }

    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) + "__";
    }

    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);
            }
        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)
            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
                        ));

            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)
//                        {
//                        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 " + 
                                     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
            {
            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();
        //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();
        //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);
            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;
    }

    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
    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)
                    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,
                               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);                
                }

            }
//        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);
    }

    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)
                {
                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);
        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{
        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);
    }
}

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)));

            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{
        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,
                                       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 
                  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)
                                {
                                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 = 
                         (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, 
                       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(); 
              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;
    }

    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)
                            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;
    }

    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;
                        }
                    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);
    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)
                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");
            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)
        {
        ISeq form = (ISeq) x;
        Object op = RT.first(form);
        if(is