To download Iava as a zipped file (less than 200k), use one of
the links below. In order to obtain the
source code (which is not contained in the downloadable files below),
write a short email to me.
For the source code, please mind the license.
Download Iava 0.92 This version needs JDK 1.2 or higher.
The old "com.sun.java.swing" naming scheme is not supported anymore.
Copyright Notice and Terms of Usage for Non-Commercial
The Iava source code and binaries are copyrighted 1998/1999/2000 by
Mathias Richter. Permission for the use of this
software and the source code is granted for non-commercial use
exclusively under the following terms:
This software is provided "as is". Under no circumstances may the copyright
holder and author of this
software be held liable for any damages or losses resulting in the
use of this software.
This copyright notice must always be part of all copies or redistributions
of this software (source code
and binaries (ie. class files, jar files, etc.).
I (Mathias Richter) as owner of the copyright am provided with information
about modifications, bugs,
bug fixes and uses of this software (email@example.com).
What is Iava?
Iava is an interpreter that implements a subset of
the JavaTM programming language.
The philosophy of Iava is to provide a scripting language that integrates
compiled JavaTM applications and the
JavaTM platform. The motivation for using
the JavaTM language syntax is to provide the possibility to migrate scripted
code into compiled
code without having to rewrite it. Thus, features of an application
can be imlemented as
scripts and after they have proven useful, they can be integrated into
code by copy-paste.
By using a subset of the JavaTM syntax
and semantics, adding scripting to applications
does no longer force developers to maintain two different systems with
languages. The border between compiled code and scripted parts of an
becomes (almost) invisible.
What is the difference
between JavaTM and Iava?
There are no class declarations in Iava. This means you cannot define classes,
or anonymous classes in Iava scripts. Apart from this limitation, Iava
full syntax and semantics of the JavaTM
programming language. Iava scripts can declare
public or private methods. Public methods can be invoked by scriptable
objects, i.e. objects embedding the Iava interpreter. Private methods
accessible from within scripts (using this mechanism, fpr example ActionListeners
created and used from within scripts, refer to the API documentation
of the Scriptable interface for details).
What can Iava be used for?
There are lots of good reasons for integrating scripting into an application.
a lot of examples of scripted systems come to mind: The first to name
is certainly the
UNIX system (closely followed by almost every serious operating system).
prominent examples are Emacs and for Macintosh programmers the text
(based on Tcl). Here is just a short list of those motivations
that spawned the Iava project:
Extensibility and adaptability: Applications providing scripting
can be augmented
by functionality as needed and without recompilation. Applications
dedicated elements of their architecture for scripting and leave others
Prototyping: Certain functionality of application systems can be
scripts to prove their usefulness. The decision to "hardwire" some
of an application into the compiled code can be made later. Because
the same syntax and semantics as JavaTM,
this "hardwiring" is reduced to copy-paste
Component interconnection: Scripting provides a very interactive
interconnecting software components like JavaBeans in an application
Testing: A scripting language allows the creation of test scripts
which allow for the
Iava needs JDk1.2 or higher (or the corresponding runtime environment).
Just plug the location of the file "iava.jar" into your classpath.
The Iava interpreter can be invoked
on the command line by java Iava.Iava [-p] [-w | <sourcefile.iava>].
The option -p turns on profiling to the file ./profile.txt
while the option -w brings on a simple
interpreter window with a few self-explanatory features. Invokation
without a source file starts
the Iava command line (tab at the end of a line serves as a line continuation).
For integrating Iava with your application to make it scripted, please
refer to the API documentation.
Version and Change history
Version 0.3 was the first version released (to a close circle of friends).
Changes from Version 0.3 to Version 0.4
1. Changed the IavaConsole from AWT to Swing 101 and thus eliminated text
selection bug from
java.awt.TextArea. Changes to the GUI of the IavaConsole
include separate windows which allow
the observation of declared symbols and methods.
2. Added IavaRuntime scoping policy (global scope, script scope).
3. Added listener infrastructure for method declaration/method call
observation and symbol
Changes from Version 0.4 to Version 0.5
1. Exceptions and Errors which occurred as part of the execution of a scripted
called from compiled code are now accessible. The
class IError has been made
public for that purpose and provides a method for
getting the original Error or Exception
2. Fixed a bug in the interpretation of primary expressions: calls
using "this" as a reference
did not work properly in verson 0.4.
3. Fixed a number of minor bugs.
Changes from Version 0.5 to Version 0.6
1. Fixed a bug in the logical operators "&&" and "||".
2. The Iava interpreter used to output errors/exceptions directly to
was impractical, because embedding classes might
want to be informed about errors
in script execution. So now, the interpreter methods
"interpret" and "interpretFile" throw
IErrors (which are derived from Error and do not
have to be caught by calling code)
which the calling code is free to catch or ignore.
3. Took out the classes IavaListener and IavaTalker of the framework.
Changes from Version 0.6 to Version 0.7
This was a maintenance release. The exception handling was improved in
the Iava interpreter.
Changes from Version 0.7 to Version 0.8
1. Fixed the bug with non-public constructors. Now, scripts can
work with classes with non-public-constructors which
were created by compiled classes
(e.g. Enumerations). Thanks, Scott!
2. Added a IavaAccess class which allows classes embedding Iava to
restrict scripts from using certain classes or packages.
3. Fixed bug with for-statements without a variant.
4. Iava and IavaRuntime can now be subclassed. Changed protection of
methods in these classes to 'protected' where desirable.
5. IavaRuntime objects can be instantiated with their own classloader
Thanks again, Scott!
6. The naming scheme "com.sun.java.swing" is not supported anymore.
Changes from Version 0.8 to Version 0.9
1. Re-fixed the bug with non-public constructors. Now it *really* works
2. Added some performance treats (method lookup cache, ArrayList instead
of Vectors, etc.). Iava should run much faster now...
3. Fixed some minor errors (thanks Tiest!).
Changes from Version 0.9 to Version 0.91
1. Fixed a bug with the runtime stack, which would overflow under certain
2. Extended the signature of the classes of IavaRuntime and Iava. Now,
class provides an extended set of protected methods
available for subclasses. Iava provides
possibility to exchange the runtime object for an
interpreter instance. Thanks, Scott!
Changes from Version 0.91 to Version 0.92
1. Fixed a bug in method caching which would prevent method invocations
with null values for
parameters to be executed correctly.
Known Limitations and Bugs
The following bugs are known to me:
Unfixed as of Version 0.91: Please send me bug reports!!
Unfixed as of Version 0.7
In the HTML-Documentation generated with javadoc, the documentation for
contains a code example. In the middle of the example, the code is
not displayed properly.
The displayed code doesn't make sense at all. I'm working on that.
Unfixed as of Version 0.5
Important: If a method was overriden in a class used by a script, and the
script tries to
call the original method in the superclass by referencing "super",
the call will still be directed
to the overriding method. References to not-overridden methods and
fields in the superclass
using "super" as reference do work, however.
Unfixed as of Version 0.4
If a script calls a method which cannot be found (because it is not defined),
does not issue an "undefined method error" but sometimes throws a "null
Unfixed as of Version 0.3
No class declarations whatsoever. This is not a bug, but a limitation of
API. As soon as Sun extends reflection to allow the dynamic creation
I'll implement it.
No labeled statements. But hey, it's better practice to use continue
without labels, anyway. This is not a bug, because I don't like
and hence didn't bother to implement them.
No assignment operators yet. IMHO, they're syntactic sugar and too much
is not good for the teeth, not? But, hell, I might implement them,
if you insist.
Exceptions sometimes show the stack trace of the interpreter code and not
stack trace of your scripted code. There's not much I can do about
JavaTM only allows to append
to a stack trace, but not to manipulate it in other ways.
I would like to thank all Iava users for helpful hints, suggestions,
bugfixes and for the positive feedback that I have been receiving.
In particular, I would like to thank Scott
Boding and Tim Wright. Scott provided really
useful bugfixes while Tim suggested the restriction of script access
rights. Tiest from
HTSoft has really been helpful in finding some more bugs fixed as of