announce: release 4.0 of 'term processor' Kimwitu (Axel Belinfante)
23 Jul 1996 23:20:27 -0400

          From comp.compilers

Related articles
announce: release 4.0 of 'term processor' Kimwitu (1996-07-23)
| List of all articles for this month |

From: (Axel Belinfante)
Newsgroups: comp.compilers
Date: 23 Jul 1996 23:20:27 -0400
Organization: Univ. of Twente, Dept. of Computer Science, Tele Informatics group
Keywords: tools

I'm happy to announce release 4.0 of our 'term processor' Kimwitu.

The source is available at:
Documentation at:
(this contains the complete latex source of the manual, and
  the read-made postsscript version of it, as file:
Examples at:

Wrt previous versions, the most important change is that you can now define
functions using 'ANSI-C' style function definitions, in addition to the
'K&R' style that we offered before. Other changes include a slightly nicer
installation (cleaned up the Makefile), somewhat better debugging support
thanks to more (better placed?) generated #line directives, some cleanup in
the generated code. Also, we now have (in a separate tar.gz file) the
examples of the manual in ready-to-make directories.

For those of you who are new to Kimwitu, below follows a short introduction
to it (the about-kimwitu file from the distribution).

* What is Kimwitu?

Kimwitu is a system that supports the construction of programs that use
trees or terms as their main data structure. It is a `meta-tool' in the
development process of tools. Its input is an abstract description of terms,
annotated with implementation directives, plus a definition of functions on
these terms. The output consists of a number of C-files that contain
data-structure definitions for the terms, a number of standard functions on
those terms, and a translation (in C) of the function definitions in the
input (eg. term rewriting). The standard functions can be used to create
terms, compare them for equality, read and write them on files and do
manipulations like list concatenation.

It can easily be interfaced with Yacc and Lex - the idea is that yacc and
lex are used to do the parsing, and Kimwitu routines are used to built and
manipulate the parse tree.

It can also be used to 'link' components in a toolset - the idea is to
define an abstract syntax tree (or more) that will be the interface object,
the thing which will be passed between the tools. The various tools then
read such an object from file, manipulate it and write the result to file,
to be processed by another tool. Only one tool has to do the actual parsing,
to build the tree used by the rest of the toolset. The tool builder does not
have to worry about the file format: from the abstract description of the
interface object Kimwitu generates the read and write routines.

* What kind of functions can be defined?

Functions in plain C, with the extension of a 'with' statement in which
pattern matching can be expressed, and a 'foreach' statement that loops over
the elements of a list.

Rewrite rules.

Unparse rules.

* More information (and examples) can be found in the Kimwitu manual.

Feedback is very welcome, either at my address below, or at the
'constant' address <> !

  <> <URL:>
    University of Twente, Dept. of C.S., Tele-Informatics & Open Systems Group
  P.O. Box 217; NL-7500 AE Enschede. Phone: +31 53 4893774; Fax: +31 53 4893247

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.