@InProceedings{stoddart02, author = {Bill Stoddart}, title = {Efficient ``Reversibility'' with Guards and Choice}, crossref = {euroforth02}, pages = {3--15}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/bill.rev.ps.gz}, abstract = {We describe reversibility mechanisms incorporated into a native code Forth used an an intermediate language for a B-GSL compiler. In contrast to our previous work, information preservation is limited to what is needed to implement the B-GSL semantics for non-deterministic choice and guard. Design choices are discussed with reference to the Pentium architecture. The use of guards and choice in Forth is illustrated with the Knight's Tour.} } @InProceedings{stoddart&zeyda02, author = {Bill Stoddart and Frank Zeyda}, title = {Implementing Sets for Reversible Computation}, crossref = {euroforth02}, pages = {16--23}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/bill.sets.ps.gz}, abstract = {Sets provide a very general tool for representing information and modelling the behaviour of systems. We consider their implementation and associated problems of garbage collection in the context of reversible computation. We describe our implementation technique, which uses ordered arrays, and discuss scalability of performance.} } @InProceedings{gregg&waldron02, author = {David Gregg and John Waldron}, title = {Primitive Sequences in General Purpose Forth Programs}, crossref = {euroforth02}, pages = {24--32}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/gregg.ps.gz}, note = {Refereed}, abstract = {Instruction dispatch is responsible for most of the running time of Forth interpreters, especially on modern pipelined processors. Superinstructions are an important optimisation to reduce the number of instruction dispatches. Superinstructions have been used for many years to optimise interpreters, but an open problem is the choice of superinstructions to include in the interpreter. In this paper we propose a number of heuristics for choosing superinstructions, and evaluate them for general purpose Forth programs. We find that static measures of frequency perform well for superinstruction selection. As few as eight superinstructions can reduce the number of instruction dispatches by an average of 15\%, and reductions of up to 45\% are possible with large numbers of superinstructions.} } @InProceedings{ertl02ef, author = {M. Anton Ertl}, title = {The Evolution of Vmgen}, crossref = {euroforth02}, pages = {33--37}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/ertl.ps.gz}, note = {Slides} } @InProceedings{poial02, author = {Jaanus P\"oial}, title = {Stack Effect Calculus with Typed Wildcards, Polymorphism and Inheritance}, crossref = {euroforth02}, pages = {38}, slides-url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/poial.ps.gz}, abstract-url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/poial.txt}, note = {Abstract in hardcopy proceedings}, abstract = {In early 1990s author introduced a formal stack effect calculus for verification of compilers that translated high level languages (Fortran, Modula) into Forth, see [PST90],[P90a],[P90h]. The calculus was partially applicable to static type checking of Forth programs, but this was not the primary goal these days. Stack effects (formal specifications of input and output parameters for stack operations) were defined using flat type space where different types were considered incompatible and no subtyping or inheritance was allowed. The so called wildcard types were introduced by sets of stack effects, see [P91]. This framework does not suite well with abstract stack machines that use principles of object orientation (see, for example, [AG98] about type checking in Java Virtual Machine). Peter Knaggs and Bill Stoddart improved the type signature algebra and introduced a lot of useful things (type variables, subtyping, reference types, wildcards, etc.), see [SK93], [K93].\par In this presentation a modified framework for type checking is proposed to support typed wildcards and inheritance. Now it is possible to perform little more exact type calculations and express polymorphic operations. Every type symbol has its place in the type hierarchy and, at the same time, it may be treated as a wildcard symbol. Earlier approaches matched wildcards to concrete symbols (resulting in this concrete symbol) or to other wildcards (resulting in a new wildcard); this approach is more general allowing stepwise refinement of types. Not only the type checking is target here, but also the (static) choice of the right version for polymorphic operations (known as method overloading in object oriented languages). Given a type hierarchy, formal specifications for operations and a program we can refine the type signatures in the program according to the context where an operation appears. Experimental implementation of this framework is in progress.} } @InProceedings{ceballos02udp, author = {Federico de Ceballos}, title = {UDP/IP over {Ethernet} for 8-Bit Microcontrollers}, crossref = {euroforth02}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/ceballos-udp.ps.gz}, pdf-url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/ceballos-udp.pdf}, note = {Late paper, not in hard copy} } @InProceedings{ceballos02qnx, author = {Federico de Ceballos}, title = {Forth for the {QNX} Realtime Platform}, crossref = {euroforth02}, url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/ceballos-qnx.ps.gz}, pdf-url = {http://www.complang.tuwien.ac.at/anton/euroforth2002/papers/ceballos-qnx.pdf}, note = {Late paper, not in hard copy} } @InProceedings{ertl02efb, author = {M. Anton Ertl}, title = {Superinstructions in {Gforth}}, crossref = {euroforth02}, note = {Demonstration only, no paper} } @Proceedings{euroforth02, title = {18th EuroForth Conference}, booktitle = {18th EuroForth Conference}, year = {2002}, key = {EuroForth'02}, editor = {M. Anton Ertl} }