EuroForth 2006 announced talks

Accepted Refereed papers (Academic Stream)

Paul Frenger M.D.

Fifteen Years of Forth Publishing with ACM

The author has written numerous Forth programming language articles
for various publications of the Association for Computing Machinery
(ACM). These principally include the SIGForth Newsletter (1989 ­ 1994)
and Sigplan Notices (1996 ­ 2006). These ACM journals also have
included the work of several guest authors writing about Forth. This
paper discusses some of the highlights of this fifteen-year epoch,
which has informed a generation of computer professionals about the
Forth language.


Mark Shannon, Chris Bailey (University of York)

Register Allocation for Stack Machines

Register allocation is a critical part of any compiler, yet register
allocation for stack machines has received little attention in the
past. We present a framework for the analysis of register allocation
methods for stack machines which has allowed us to analyse current
methods.  We have used this framework to design the first truly global
register allocation methods. We have designed two such methods, both
of which outperform current techniques.


Jamel Tayeb, Smail Niar (University of Valenciennes & du Hainaut-Cambrésis)

Adapting the EPIC Register Stack for an Efficient Execution of Forth

Forth is a canonical stack machine and is therefore well adapted to
use the Explicit Parallel Instruction Computer (EPIC) architecture's
register stack (RS). In this paper we will introduce a new calling
mechanism using the RS to implement a Forth system more
efficiently. Based upon our performance measurements, we will show
that the new calling mechanism is a promising technique to improve the
performance of stack-based interpretative languages such as Forth. The
limitation in EPIC's Register Stack Engine (RSE) makes the need for
the hardware to improve performance and possibly close the gap with
specialized stack processors. We will define also an adjustment to
Itanium 2 processor's (ITP2) instruction set to accommodate the new
calling mechanism and present a conservative architectural
implementation over the current ITP2 pipeline.

Non-Refereed papers (Industrial Stream)

M. Anton Ertl (TU Wien)

A Portable C Function Call Interface

Many Forth systems provide means to call C functions, but these
interfaces are not designed to be portable between platforms: A call
to a C library function that works on one platform may fail on the
next platform, because the parameter and return value types of the C
function may be different.  In this paper, we present an interface
that avoids this problem: In particular, the actual calls can be made
platform-independent; a part of the declarations is
platform-dependent, but can be generated automatically from C
.h-files.


Angel Robert Lynas, Bill Stoddart (University of Teesside)

Adding Lambda Expressions to Forth

We examine the addition of Lambda expressions to Forth. We briefly
review the Lambda calculus and introduce a postfix version of Lambda
notation to guide our approach to a Forth implementation. The
resulting implementation provides the basic facilities of an early
binding functional language, allowing the treatment of functions as
first-class objects, manipulation of anonymous functions, and
closures.


Jaanus Pöial (The Estonian Information Technology College)

Typing Tools for Typeless Stack Languages

Many low-level runtime engines and virtual machines are stack based -
instructions take parameters from the stack and leave their results
on the stack. Stack language is a common name for several languages
used to program stack based (virtual) machines - like CLR, JVM,
Forth, Postscript, etc. We chose the Forth language as an example to
represent the class of stack languages, partially because this
language is typeless, partially because there exists a big amount of
industrial legacy Forth code that needs to be validated.

Usually applications that take advantage of stack machines are
minimalistic and designed to run on restricted environments like
electronic devices, smartcards, embedded systems, etc. Sometimes
these components are used to build safety critical systems where
software errors are inadmissible. Type checking allows to locate
possible errors of stack usage that most often occur in stack
language programs. Limited resources give preference to a static
solution - run-time type information is expensive to manage and quite
useless in turnkey applications. Static type checking is based on a
type system that is introduced here for originally typeless stack
languages. This external type system is flexible enough to perform
several tasks. Static program analysis can be used both for finding
errors and performing useful transformations on programs
(optimization, parallelization, etc.).

In this paper a type system to perform the so called must-analysis is
described that allows to locate the stack language code where the
strong stack discipline is violated. Experimental implementation of
the analysis framework is written in Java.

Keywords: Type Systems, Stack Languages, Program Analysis


N.J. Nelson (Micross)
The Nearly Invisible Database  or  ForthQL

Structured Query Language (SQL) is a strange thing to Forth
programmers, since it is neither structured, nor confined to queries,
nor a language in the Turing sense of the word. It requires an
interface written in another language in order to do anything. This
paper describes our attempts to provide an SQL-Forth interface which
is so smooth that you hardly know which side of it you're on.


K.B.Swiatlowski (Micross)
Database access for illiterate programmers

Writing an SQL statement can be difficult for people used to accessing
data stored in flat files. Furthermore existing software code may
already have a lots of places where flat file interfaces have been
used. In order to avoid re-writing existing software and providing
transparent, flat-file-like access to SQL database the functionality
of file access words had to be extended. This approach to databases
will be presented.


David Guzeman (Intellasys)
A 21st Century Sea Change Taking Place in Embedded Microprocessors


David Guzeman (Intellasys)
Defining Processing Solutions for Mesh Computing Environments


Chris Bailey
Embedded Arrays Venture Forth