TL language
version 1.5

1) What is TL

1.1) Introduction

vme open ?$name? vme map $cid $address $size $am vme close $cid vme read $cid $offset ?D8/D16/D32? vme write $cid $offset $data ?D8/D16/D32?

As could be deduced from the proposed syntax, the command should be quite simple to implement. However, I discovered this was not the case when I have started the command implementation. There were no big conceptual problems, nevertheless there was a lot of code to be written. Lots of switch statements were needed to distinguish between different cases and also error checking has taken a lot of coding. Moreover, at the end of all this code writing, one could simply forget what the command was supposed to do. The biggest part of the code was the interpreter!

Interpreters for Tcl commands are based on argument evaluation. The zero argument, i.e. the command name, is treated by the main Tcl interpreter, so the only thing to do is to declare it. All the other arguments must be treated by the specific interpreter itself.

Three different types of arguments can be mixed in a command:

• sub-command specifiers
• parameter arguments
• option specifiers

The second type of arguments, parameter arguments, are the most frequent ones. Usually they are position dependant and have a well known type. The main task of the interpreter, when an argument of this type is found, is to convert the string in an appropriate C type, signaling any error.

The third type of arguments, option specifiers, are the most difficult to treat when the interpreter is written by hand. They are position independent and can be present any number of times. Moreover, they are frequently followed by a parameter argument. The usual way to treat them is to assume they are present after the last argument of the previous types, and evaluate the remaining arguments one by one trying to identify the option each time.

After evaluating all the arguments, the command (sub-command) specific code is executed. This code has in input the parameters of correct type given by the interpreter and produces in output another parameter of a given type. The output parameter is then transformed in a string and passed as output of the command.

It could look odd that a command (sub-command) returns always the same type of output. It is not the case for generic programs. But the result of a Tcl command is normally used as input for other Tcl commands, so the type must be known in advance or this result cannot be used.

After this short introduction it should be evident that Tcl interpreters are very modular. Moreover, they are also very uniform inside a single argument type. An ideal condition for automatic code production.

TL is a strictly typed language. This is derived principally from the target language, the C. But there are also other reasons; specifying the types at definition level, the syntax of the final command is much more clear. Moreover, this is a good programming style.

The other interesting property of TL is its simplicity. Excluding the types, which are very rich, there are essentially only seven (7) commands present in TL. Nevertheless, these few commands cover all the spectrum of Tcl commands.

Let's now see the types:

There are different types in TL. The basic distinction is between the so called Intypes and the Outtypes. As can be foreseen from their names, the first type of types are the types of the arguments, while the second type of types are the types used to return a result. Two different types of types are necessary because some details that are obvious for argument decoding are not when a C type must be encoded, and vice versa. Let's see an example to understand the problem:

Although the two types of types are semantically two different objects, syntactically they are very similar. Moreover, even the logical structure is very similar so, from now on, they will be treated as they are two variants of the same type.

Moreover, the TL types can be divided in two categories:

• simple types
• compound types

Simple types represent basically numerical values (integer and floating), booleans, pointers and strings. They are the simpler types one can use inside a TL program.

Compound types are a bit more complicated types. They are record, case and list types whose elements are other types. These types of types are nearly impossible to be handled by hand, but can by easily coded by an interpreter.

2) TL definition:

Attention:
0.0 cannot be represented using floating point in binary format.
TL uses 0 for 0.0 and 0f... otherwise.

3) Compiler

The actual compiler compiles TL programs in C code for use in tcl interpreters.

The syntax is:

tlc [options] file.tl [docdir] [outdir] [indir]

where options are:
-n    :     do not create the html file
-n-   :     create the html file (default)
-l    :     set links to the userNAME_c.html generated by c2html
-l-   :     do not link (default)
-h
-?
?     :     this help

• tclNAME.h
• tclNAME.c
• userNAME.h
• NAME_tl.html

tclNAME.h contains the header of the tcl command interpreter, while tclNAME.c contains the real command interpreter.

userNAME.h contains the type declarations and the function prototypes. The actual functions must be supplied by the user/programmer.

4) History and Future plans

First working compiler.

Version 1.1

Some bugs fixed.

Version 1.5

A new variant of the constant definition added.

5) Examples

Example 1: Conversion tool

This conversion tool simplifies the conversion between different types supported by the TL.

The input files are: