since: 2.4.0 -

 protected GenericInterpreter() 
{

}

 protected  void afterExec() 
{

}

Called after #exec , #get and many others.

Default: does nothing.

 protected  void afterInterpret(Namespace ns) 
{
		pop();
		afterExec();
}

Called after #exec .

Default: call #afterExec .

 protected  void beforeExec() 
{

}

Called before #exec , #get and many others.

Default: does nothing.

 protected  void beforeInterpret(Namespace ns) 
{
		beforeExec();
		push(ns); //getFromNamespace will handle null
}

Called before #exec .

Default: call #beforeExec and push the namespace as the active one.

 protected boolean contains(String name) 
{
		return get(name) != null;
}

Tests whether a variable is defined in this interpreter. Optional. Implement it if the interpreter can tell the difference between null and undefined.

By default, it tests whether #get(String) returns non-null.

 protected boolean contains(Namespace ns,
    String name) 
{
		return get(ns, name) != null;
}

Tests whether a variable is defined in the interpreter's scope associated with the specified namespace. Optional. Implement it if the interpreter can tell the difference between null and undefined.

By default, it tests whether #get(Namespace, String) returns non-null.

 public boolean containsVariable(String name) 
{
		beforeExec();
		push(Objects.UNKNOWN);
			//don't use null since it means Namespaces#getCurrent, see below
		try {
			return contains(name);
		} finally {
			pop();
			afterExec();
		}
}

Tests whether the variable exists.

Deriving class shall override #contains(String) , instead of this method.

 public boolean containsVariable(Namespace ns,
    String name) 
{
		beforeExec();
		push(Objects.UNKNOWN);
			//don't use null since it means Namespaces#getCurrent, see below
		try {
			return contains(ns, name);
		} finally {
			pop();
			afterExec();
		}
}

Tests whether the variable exists by using the specified name as a reference to identify the interpreter's scope.

Deriving class shall override #contains(Namespace,String) , instead of this method.

 public  void destroy() 
{
		_owner = null;
}

Reset the owner (#getOwner ) to null.

 abstract protected  void exec(String script)
Executes the specified script.
Deriving class shall provide an implementation of this method, rather
than overriding #interpret .

 protected Object get(String name) 
{
		return null;
}

Gets the variable from the interpreter. Optional. Implement it if you want to expose variables defined in the interpreter to Java codes.

#beforeExec is called first, before this method is invoked.

An empty (and fake) namespace is pushed so #getFromNamespace always returns null.

 protected Object get(Namespace ns,
    String name) 
{
		return get(name);
}

Gets the variable from the interpreter's scope associated with the giving namespace. Optional. Implement it if you want to expose variables defined in the interpreter to Java codes.

This method is implemented only if the interpreter that supports hierachical scopes (org.zkoss.zk.scripting.HierachicalAware ).

Default: the same as #get(String) .

#beforeExec is called first, before this method is invoked.

An empty (and fake) namespace is pushed so #getFromNamespace always returns null.

 public Class getClass(String clsnm) 
{
		return null;
}

Returns null since retrieving class is not supported.

 protected Namespace getCurrent() 
{
		if (!_nss.isEmpty()) {
			Object o = _nss.get(0);
			if (o == Objects.UNKNOWN)
				return null; //no namespace allowed
			if (o != null)
				return (Namespace)o;
			//we assume owner's namespace if null, because zscript might
			//define a class that will be invoke thru, say, event listener
			//In other words, interpret is not called, so ns is not specified
		}
		return Namespaces.getCurrent(_owner); //never null
}

Returns the current namespace, or null if no namespace is allowed. Note: if this method returns null, it means the interpreter shall not search variables defined in ZK namespace.

This method will handle Namespaces#getCurrent automatically.

 protected Object getFromNamespace(String name) 
{
		final Namespace ns = getCurrent();
		if (ns != null) {
			Object val = ns.getVariable(name, false);
			if (val != null || ns.containsVariable(name, false))
				return val;
		}
		return UNDEFINED;
}

Returns the variable through namespaces and variable resolvers, or #UNDEFINED if the variable not defined.

It is usually called to search namespaces and variable resolvers, when the real interpreter failed to find a variable in its own scope.

Note: We use #UNDEFINED to denote undefined since 2.4.0, while null is a valid value.

 protected Object getFromNamespace(Namespace ns,
    String name) 
{
		if (getCurrent() != null) {
			Object val = ns.getVariable(name, false);
			if (val != null || ns.containsVariable(name, false))
				return val;
		}
		return UNDEFINED;
}

Returns the variable through the specified namespaces and variable resolvers, or #UNDEFINED if the variable is not defined.

It is usually called to search namespaces and variable resolvers, when the real interpreter failed to find a variable in its own scope.

This method is used with the interpreter that supports hierachical scopes (org.zkoss.zk.scripting.HierachicalAware ).

 public Function getFunction(String name,
    Class[] argTypes) 
{
		return null;
}

Returns null since retrieving methods is not supported.

 public Function getFunction(Namespace ns,
    String name,
    Class[] argTypes) 
{
		return null;
}

Returns null since retrieving methods is not supported.

 public String getLanguage() 
{
		return _zslang;
}

 public Page getOwner() 
{
		return _owner;
}

 public Object getVariable(String name) 
{
		beforeExec();
		push(Objects.UNKNOWN);
			//don't use null since it means Namespaces#getCurrent, see below
		try {
			return get(name);
		} finally {
			pop();
			afterExec();
		}
}

Retrieve the variable.

Deriving class shall override #get(String) , instead of this method.

 public Object getVariable(Namespace ns,
    String name) 
{
		beforeExec();
		push(Objects.UNKNOWN);
			//don't use null since it means Namespaces#getCurrent, see below
		try {
			return get(ns, name);
		} finally {
			pop();
			afterExec();
		}
}

Returns the value of a variable defined in this interpreter's scope identified by the specified namespace. Note: it doesn't search the specified namespace (Namespace ).

Deriving class shall override #get(Namespace,String) , instead of this method.

This method is part of org.zkoss.zk.scripting.HierachicalAware . It is defined here to simplify the implementation of the deriving classes, if they support the hierachical scopes.

 public  void init(Page owner,
    String zslang) 
{
		_owner = owner;
		_zslang = zslang;
}

 public  void interpret(String script,
    Namespace ns) 
{
		final String each =
			_owner.getLanguageDefinition().getEachTimeScript(_zslang);
		if (each != null)
			script = each + '\n" + script;
		beforeInterpret(ns);
		try {
			exec(script);
		} finally {
			afterInterpret(ns);
		}
}

Handles the namespace and then invoke #exec .

Don't override this method, rather, override #exec .

 protected  void set(String name,
    Object value) 
{

}

Sets the variable to the interpreter. Optional. Implement it if you want to allow Java codes to define a variable in the interpreter.

#beforeExec is called first, before this method is invoked.

 protected  void set(Namespace ns,
    String name,
    Object value) 
{
		set(name, value);
}

Sets the variable to the interpreter's scope associated with the giving namespace. Optional. Implement it if you want to allow Java codes to define a variable in the interpreter.

This method is implemented only if the interpreter that supports hierachical scopes (org.zkoss.zk.scripting.HierachicalAware ).

Default: the same as #set(String, Object) .

#beforeExec is called first, before this method is invoked.

 public final  void setVariable(String name,
    Object value) 
{
		beforeExec();
		try {
			set(name, value);
		} finally {
			afterExec();
		}
}

Sets the variable to this interpreter.

Deriving class shall override #set(String,Object) , instead of this method.

 public final  void setVariable(Namespace ns,
    String name,
    Object value) 
{
		beforeExec();
		try {
			set(ns, name, value);
		} finally {
			afterExec();
		}
}

Sets the value of a variable to this interpreter's scope identified by the specified namespace.

Deriving class shall override #set(Namespace,String,Object) , instead of this method.

 protected  void unset(String name) 
{

}

Removes the variable from the interpreter. Optional. Implement it if you want to allow Java codes to undefine a variable from the interpreter.

#beforeExec is called first, before this method is invoked.

 protected  void unset(Namespace ns,
    String name) 
{
		unset(name);
}

Removes the variable from the interpreter. Optional. Implement it if you want to allow Java codes to undefine a variable from the interpreter.

This method is implemented only if the interpreter that supports hierachical scopes (org.zkoss.zk.scripting.HierachicalAware ).

Default: the same as #unset(String) .

#beforeExec is called first, before this method is invoked.

 public final  void unsetVariable(String name) 
{
		beforeExec();
		try {
			unset(name);
		} finally {
			afterExec();
		}
}

Removes the variable from this interpreter.

Deriving class shall override #unset(String) , instead of this method.

 public final  void unsetVariable(Namespace ns,
    String name) 
{
		beforeExec();
		try {
			unset(ns, name);
		} finally {
			afterExec();
		}
}

Removes the value of a variable defined in the interpreter's scope identified by the specified namespace.

Deriving class shall override #unset(Namespace,String) , instead of this method.