Jint Programming Language Manual

Introduction

Jint used to mean Java Interpreter. It started as a simple interpreter for Java method calls, then for more general subset of java expressions, and then for the more general subset of Java programming language. It used to be implemented as an interpreter. At some point, though, it became clear that interpreter is too limited for Java environments, because it is almost impossible to do anything without subclassing which cannot be implemented very well by the interpreter. At that point Jint became compiled language. (It is compiled to JVM bytecodes, of course). It is still possible to compile a single statement to bytecode, load and execute it right away, so it still can behave as an "interpreter").

Jint Interactive Environment

bash% JINTC
jint: 1 + 1;
2
jint: 100.0 * 67.5 + 0.98;
6750.98
jint: "Hello " + "world!";
Hello world!
jint:

Expression statement allows one not only to evaluate an expression, but also assign value to variable using assignment operator '='. Jint variables, just like in Java are not prefixed by dollar (or anything else). While variables can be introduced by just assigning to them, it is better to declare all variables. To declare variable one uses variable declaration statement (which does not print the result of the expression evaluation). This is an example:

jint: var q = 89 - 8;
jint: q/9;
9

jint: square( n ) { var res = n*n; return res; }
jint: square(2);
4
jint: square(10);
100
jint: square(1.4142);
1.9999616399999998

Each variable or function is defined only in certain scope. One can use variable or function name to refer to it while in the same scope; it is harder (or even impossible) to refer to function or variable outside of the scope where it is defined. Initially one is working with global scope, but every function introduces its own scope, so if one declares variable inside the function body, it won't be visible outside the function. Function parameters (like 'n' in the above example) are considered to be variables defined in function scope. Scopes are nested, so it is still possible to access functions and variables from the global scope while in function scope (unless something in the function scope has the same name).

One can access the whole scope of a function using 'self' variable, but be aware that this can hurt compiled code efficiency.

Jint Type System

"Strong" and "Free" Types

a + 1

Classes

Expressions

The simples expression is a single value. Here is the list of what a value can be

Jint Values

Regular expressions and formats are described in more detail later.

More complex expressions can be built from simple ones using following constructions (EXPR means expression):

Kind	Syntax	Description
Infix expression	EXPR op EXPR	op is one of the infix operators
Prefix expression	op EXPR	op is one of the prefix operators
Postfix expression	EXPR op	op is one of the postfix operators
Bracketed expression	(EXPR)	brackets are used to alter order of execution
Array	{EXPR, ...}	Create array and fill it with the given values
Typed array	Clazz[] {EXPR, ...}	Create array of type Clazz[] (Clazz must be a class name) and fill it with the given values
Instantiation	new Clazz(EXPR, ...)	Create an object of class Clazz (Clazz must be a class name)
Subclassing instantiation	new Clazz(EXPR, ...){ statement ...}	Create an object of in-place defined Clazz's subclass
Array creation	new Clazz[EXPR]	Create array of EXPR elements (Clazz[EXPR][EXPR]... is allowed)
Block	[statement ...]	Creates a new kmy.jint.lang.Block object

Expression must not start with a '{', so if array value must be in the beginning of the expression (not sure that this ever makes sense), it must be bracketed.

Jint Operators

Statements

Expression Statement

Compound Statement

{
  statement1
  statement2
  ...
}

If Statement

if( expression )
  then-statement

if( expression )
  then-statement
else
  else-statement

While Statement

while( expression )
  body-statement

Do Statement

do
  body-statement
while( expression );

For Statement

for( init-statement cond-expression ; next-expression )
  body-statement

Switch statement

switch( expression )
{
  case case-expression :
    statement
    ...
  ...

  default:
    statement
    ...
}

Try statement

try
  statement
catch( Clazz var-name )
  catch-statement
...

try
  statement
catch( Clazz var-name )
  catch-statement
...
finally
  catch-statement

Synchronized statement

synchronized( expression )
  body_statement

Labeled Statement

Label : statement

Break Statement

break;

break Label;

Continue Statement

continue;

break Label;

Class Definition

access class name
  extends extended-name
  implements implemented-name,...
{
  statement
  ...
}

Interface Definition

access interface name
  extends extended-name,...
{
  statement
  ...
}

Method/Function Definition

access Clazz name( Clazz arg-name, ... )
  throws Clazz, ...
{
  statement
  ...
}

Field/Variable Declaration

Clazz name,...;

Clazz name=value,...;

Field/Variable Declaration With Subclassing

Clazz name {
 statement
 ...
}

public Clazz1 extends Clazz { 
  statement
  ...
}

public Clazz1 name = new Clazz1();

Regex Class Definition

access class name = regex;

Text Processing Constructions

There are 3 text processing constructions in Jint:

• regular expression
• formatted string
• replacer.

(*) Java is a registered trademark of Sun Microsystems, Inc.