@InProceedings{frenger06, author = {Paul Frenger}, title = {Fifteen Years of {Forth} Publishing with {ACM}}, crossref = {euroforth06}, pages = {5--12}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/frenger.pdf}, OPTnote = {refereed}, abstract = {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.} } @InProceedings{shannon&bailey06, author = {Mark Shannon and Chris Bailey}, title = {Register Allocation for Stack Machines}, crossref = {euroforth06}, pages = {13--20}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/shannon.pdf}, OPTnote = {refereed}, abstract = {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.} } @InProceedings{tayeb&niar06, author = {Jamel Tayeb and Smail Niar}, title = {Adapting the {EPIC} Register Stack for an Efficient Execution of {Forth}}, crossref = {euroforth06}, pages = {21--26}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/tayeb.pdf}, OPTnote = {refereed}, abstract = {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.} } @InProceedings{lynas&stoddart06, author = {Angel Robert Lynas and Bill Stoddart}, title = {Adding {Lambda} Expressions to {Forth}}, crossref = {euroforth06}, pages = {27--39}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/lynas.pdf}, OPTnote = {not refereed}, abstract = {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.} } @InProceedings{poial06, author = {Jaanus P\"oial}, title = {Typing Tools for Typeless Stack Languages}, crossref = {euroforth06}, pages = {40--46}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/poial.pdf}, OPTnote = {not refereed}, keywords = {Type Systems, Stack Languages, Program Analysis}, abstract = {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.\par 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.).\par 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.} } @InProceedings{ertl06, author = {M. Anton Ertl}, title = {A Portable {C} Function Call Interface}, crossref = {euroforth06}, pages = {47--51}, url = {http://www.complang.tuwien.ac.at/papers/ertl06.ps.gz}, pdfurl = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/ertl.pdf}, OPTnote = {not refereed}, abstract = {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.} } @InProceedings{nelson06, author = {N.J. Nelson}, title = {The Nearly Invisible Database or {ForthQL}}, crossref = {euroforth06}, pages = {52--57}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/nelson.pdf}, OPTnote = {not refereed}, abstract = {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.} } @InProceedings{swiatlowski06, author = {K.B. Swiatlowski}, title = {Database access for illiterate programmers}, crossref = {euroforth06}, pages = {58--63}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/swiatlowski.pdf}, OPTnote = {not refereed}, abstract = {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.} } @InProceedings{guzeman06a, author = {David Guzeman}, title = {A 21st Century Sea Change Taking Place in Embedded Microprocessors}, crossref = {euroforth06}, pages = {64--77}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/guzeman06a.pdf}, OPTnote = {not refereed}, } @InProceedings{guzeman06b, author = {David Guzeman}, title = {Defining Processing Solutions for Mesh Computing Environments}, crossref = {euroforth06}, pages = {78--85}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/guzeman06b.pdf}, OPTnote = {not refereed}, } @Proceedings{euroforth06, title = {22nd EuroForth Conference}, booktitle = {22nd EuroForth Conference}, year = {2006}, key = {EuroForth'06}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/proceedings.pdf} }