Object Orientation

Introduction

The main problem with checking OO-style code is lines like this:

$obj dosomething $arg

Since Nagelfar does not know the command, it does not know the syntax for it, and specially if an argument is a code block, it will not know that it should check into it.

Basically what is needed is types. If the type of $obj is known it can be checked. By introducing return types of commands and types of variables, code like this becomes checkable:

set w [frame .f]
$w configure -apa hej

First Example

If you have a command myCmd that returns an object which has a foreach loop method, the following are the basic steps needed to get going.

set o [myCmd stuff]
$o foreach x {
    puts $x
}

First give your object type a name. It should be prefixed with the magic string “_obj,”. Let’s call it “myObj”.

Define a return type to myCmd with the object type.

##nagelfar return myCmd _obj,myObj

Define this object type as a command with a sub-command (a.k.a method)

##nagelfar syntax _obj,myObj s x*

Define the list of valid sub-commands.

##nagelfar subcmd _obj,myObj foreach configure dostuff

Define the syntax for a specific subcommand.

##nagelfar syntax _obj,myObj\ foreach n c

Explicitly Named Object

It is possible that myCmd instead of returning the object takes an explicitly named object name as argument.

myCmd t1
t1 dostuff

The critical definition uses the define command (dc) token:

##nagelfar syntax myCmd dc=_obj,myObj

Defining it manually for that instance is also possible by doing the copy that is built into the “dc=” token.

##nagelfar copy _obj,myObj t1

Objects in parameters

Sometimes it is necessary to declare a variable as an object:

proc testingwithproc {ob} {
    ##nagelfar vartype ob _obj,myObj
    $ob dostuff
}

##nagelfar syntax testingwithproc2 x(_obj,myObj)
proc testingwithproc2 {ob} {
    $ob dostuff
}

Implicit variables

Some OO systems make instance variables “magically” show up in a method’s scope. Nagelfar needs to be told about this per object type using inline directive “implicitvarns”.

Example for a Snit object:

##nagelfar syntax pdf4tcl::pdf4tcl dc=_obj,pdf4tcl p*
##nagelfar return pdf4tcl::pdf4tcl _obj,pdf4tcl

##nagelfar implicitvarns snit::type::pdf4tcl::pdf4tcl self\ _obj,pdf4tcl pdf

snit::type pdf4tcl::pdf4tcl {
    variable pdf
    ...
}

Details

Class Definition

In order to automatically extract as much as possible from coded class definitions, base info about how a class definition works is needed. This is typically only done when setting up info for an OO system, not for a single object.

A class definition is resolved in a virtual namespace where commands like “constructor” and “method” can be recognised. It is denoted by the “cn” syntax token. It typically comes after the “define object”, “do”, token.

The virtual namespace is named after the calling command and its arguments. Examples:

##nagelfar syntax itcl::class do cn
itcl::class Test { ... }

Virtual namespace: itcl::class::Test

##nagelfar syntax snit::type do cn
snit::type pdf4tcl::pdf4tcl { ... }

Virtual namespace: snit::type::pdf4tcl::pdf4tcl

##nagelfar syntax oo:class\ create do cn
oo::class create Account { ... }

Virtual namespace: oo::classcreate::Account

Since name resolution works up the namespaces, class definition subcommands can be defined in the top virtual namespace for the class definition:

##nagelfar syntax itcl::class::constructor cv
##nagelfar syntax itcl::class::method dm
##nagelfar syntax snit::type::constructor cv
##nagelfar syntax snit::type::method dm
##nagelfar syntax oo::class\ create::constructor cv
##nagelfar syntax oo::class\ create::method dm

OO Systems

Different common OO systems needs different handling. Nagelfar has some built in knowledge about some of them that simplifies using them.

For now, see the “ootest” directory in Nagelfar’s source for some notes.

TclOO

Included in any 8.6+ database.

To be written…

Snit

Included in packagedb/snitdb.tcl.

Each object definition typically needs annotation for instance variables and options. Example of a Snit object’s annotation:

##nagelfar syntax pdf4tcl::pdf4tcl dc=_obj,pdf4tcl p*
##nagelfar return pdf4tcl::pdf4tcl _obj,pdf4tcl
##nagelfar option pdf4tcl::pdf4tcl -file
##nagelfar option _obj,pdf4tcl\ configure -file

##nagelfar implicitvarns snit::type::pdf4tcl::pdf4tcl self\ _obj,pdf4tcl pdf

snit::type pdf4tcl::pdf4tcl {
    variable pdf
    option -file      -default "" -readonly 1
    constructor {args} {
        $self configurelist $args
    }
    destructor {
        $self finish
        close $pdf(ch)
    }
    method cleanup {} {
        $self destroy
    }
    method finish {} {
        $self RequireVersion a
    }
    method RequireVersion {version} {
        $self finish
        if {$version > $pdf(version)} {
            set pdf(version) $version
        }
    }
}

ITcl

To be written…

TDBC

To be written…