Tiki RSS feed for weblogs

Nibble v0.9.8 released: Class support!

Thu, 31 May 2007 21:08:21 +0100

Finally, Nibble is ready to support native classes. So far, the scripting engine only supported (un)compiled Java classes, and class behavior through prototyping.

The new class system is a Java like but simpler class, that utilizes prototyping behind the scene. It provides some benefits over mere prototyping though that come natural to the classic class entity:

regular class notation, including the keywords class and extends
private and public methods or constructors
private and public and/or final properties
static or instance methods/properties
inheriting mechanism and polymorphism
strong typing

native class example

class Greeting {
	private final greet;
 
	public Greeting(final String greet) {
		this.greet = greet;
	};
 
	public void greet(Object who) {
		trace(greet + who);
	};
};

Read more

Prototype based class

Shadowed by the fresh support for native classes is a new keyword... require. The require directive indicates that the scriptfile with the require statement needs another file; with require you can indicate dependencies not unlike the import statement. For example, if you defined a class somewhere in nibblescript, but use it in other files, you want to make sure the class declaration is parsed before the scripts that use it (or you might get a data type unknown exception).

Read more

keyword require

Progress Report

Sat, 12 May 2007 10:08:50 +0100

It's been a while since my last update. I've been very busy doing overtime for work on a flash project and simultaneously studying for the Java SCJP certification (still). But I'm still at it though, it's just slowing down a bit for the moment.

Last night I've encountered two problems with the prototype based class support that's been added last. It's a good thing I didn't release an update after all huh.

No comments were allowed between class members as you would expect (comments outside a class wasn't a problem ofcourse).
Constructors weren't optional, so a superclass with no constructor threw an exception when a subclass was instantiated and more of those scenarios.

I've fixed both and applied the class features in my hobby project that actually uses the script engine. It seems to work out ok now. After some more hands on experience with classes and if no serous problems arise, I'll release a new version soon.

Benny.

Progress Report

Sun, 22 Apr 2007 15:13:02 +0100

Ok, I've got static working now as well.

In addition to visiblity, data and final modifier you can now add the static modifier keyword for methods and properties as well. You can then access them through an instance or through the classname.

In effect you can now even do things like create singleton classes in NibbleScript?, where the constructor is private, but a static method creates one for you.

I expect some small bugs with all the new prototype based class support, because I implemented in like three days of non-stop coding... sort of. So I don't think it's completely stable yet, which is why I won't put out a new release untill I've tested it some more.

Progress Report

Sun, 22 Apr 2007 11:12:04 +0100

Today, I've added support for class constructors in Nibble's prototype based classes. Constructors can both be public and private, but being private has no added value without static methods to call it from the same class.

So, I'll go and look into Nibble's options for support for the static keyword. In the mean time, check out the wiki on the new constructors:

Constructors in prototype based classes

Progress Report

Sat, 21 Apr 2007 17:38:50 +0100

Yes! I got the classes working with visiblity modifiers now (private and public).

In addition to be able to strong type instance members, now you can't access private instance members from outside or you'll get an exception at runtime. It's working both for properties and methods.

This is a big step towards full fledged classes and now I can start to think about constructors...

Progress Report

Fri, 20 Apr 2007 20:37:06 +0100

This evening, I've fixed support for methods in user classes:

class SubClass extends BaseClass {
	public String subfoo = "sub foo";
	public Integer intValue2 = 999;
 
	public String testMethod(Integer q) {
		trace("method executed!");
	};
};

Progress Report

Sun, 15 Apr 2007 21:35:14 +0100

I got the strong typed properties working now too. You'll get an exception about not being able to convert the types when you try to assign a wrong type of value to a property.

In addition, I fixed the 'extends' keyword (classes can now inherit).

class BaseClass {
	public String foo = "base foo";
};
 
class SubClass extends BaseClass {
	public String subfoo = "sub foo";
};

Progress Report

Sun, 15 Apr 2007 15:20:53 +0100

I've been spending many hours into adding support for, get this: Native class support!

Yep, I finally pulled myself together to start working on this daunting task, but I must say it's been easier than I expected.

The approach I've taken is pretty much the same as you know from Actionscript 2.0, where the classes are prototype based. You define the class as normal, but behind the scenes, it is converted to a prototype. It works quite well, and currently the following works prett good:

class RealClass extends RealSuper {
	public String name1;
	public String name2 = "this is my name";
};
 
//Dynamic d = new Dynamic(RealClass);
Object d = new RealClass();
trace("test1: " + d.name1); // traces null
trace("test2: " + d.name2); // traces "this is my name"
 
d.name2 = "this is my new name";
trace("test3: " + d.name2); // traces "this is my new name"
 
d["name3"] = "this is test3";
trace("test4: " + d.name3);
// throws exception that you can't add new methods to the interface

Currently the visiblity modifiers don't work (yet). I might remove them completely. Also, the strong/safe typing doesn't work (you can objects of any type to the instance's properties).

Progress Report

Fri, 06 Apr 2007 22:42:11 +0100

I've just spent all evening rewriting *all* thrown Exceptions in the engine to subclassed version and writing comments for them. No exceptions are thrown of type Exception anymore.

This is what it roughly looks like:

Exception
Exception -> ScriptException?
Exception -> ScriptException? -> ParseException?
Exception -> ScriptException? -> ScanException?
Exception -> ScriptException? -> CompileException?
Exception -> ScriptException? -> ExecuteException? -> StatementException?
Exception -> ScriptException? -> ExecuteException? -> ExpressionException?

I've also done a complete Eclipse sweep with cleanup, format and imports cleanup

Progress report

Fri, 06 Apr 2007 10:59:25 +0100

Yesterday I've added the operator require, which loads a scriptfile before the calling script is being parsed any further.

So it is somewhat like an include statement, except it can only be parsed once. If you parse a bunch of files in a batch, you can prioritize scriptfiles needed by other scripts using the require statement.

The require statement loads a scriptfile if it is being queued for parsing or not. If it is however, it will only be pushed forward and parsed right away and it won't be parsed again.