Re: TenDRA

Bruce Stephens <bruce@cenderis.demon.co.uk> wrote
> As far as I understand it, the technology failed to sell particularly
> well, and there was no further funding within DRA to support it.
>
> In the hope of encouraging the take up of it, TenDRA was released to
> the world under a BSD-like license. (I've just had a look at the
> license, and (although IANAL) it looks pretty liberal: if you wanted
> to use it today in commercial compilers, I think you could.)


The "official" TenDRA site is down for an unspecified amount of time.
However, an insider has recently brought up an "unofficial" TenDRA
site at http://members.xoom.com/tendra. Check it out.


> The code looks relatively clean; it has a bunch of tools which may
> well be neat (for generating parsers from grammars and so on)---I just
> don't know enough to judge.


The SID tool is an LR parser generator technology that was originally
developed back in the late 60's, although has evolved a great deal
since then. Most of the other tools are in support of TenDRA itself.


> As other people have commented, what it really lacks is a C++ library.
> It's allegedly possible to use GNU iostreams with hacking, and I
> presume SGI's STL could then be used, but I couldn't get it to work.


The GNU C++ libraries contain a number of G++-isms, making it
difficult to compile them with a non-GNU compiler. The TenDRA C++
producer does not support these GCC/G++-isms. What they need is a
"portable" C++ library. I know of at least two, but they are both
commercial products, and the source licenses are expensive. Is anyone
aware of a freeware C++ library, other than GNU?


> The i386 generated code is apparently not particularly good. There's
> a paper describing a TDF "installer" based on the gcc backend; it's a
> shame things like that weren't released with the rest of TenDRA.


Back when we were benchmarking these compilers (1992-1995 time frame),
the x86 code generator actually did quite well, compared to both GCC
(2.3.3 at the time) and the compiler distributed with SCO. I am sure
that things have improved in the x86 compiler space since that time,
and the TenDRA installer has probably not changed much since that time
(they were busy adding additional languages, tools, and target
architectures).


> The "producers" and API descriptions strike me as potentially valuable
> as the basis for souped-up lints; the C++ one is of limited value
> without the standard library, of course.


A comment above mentioned the TenDRA/ANDF-to-GCC installer. This was
built under DARPA funding at the OSF Research Institute. It basically
translated the TenDRA program into the internal GCC tree-structure
(not RTL), expanding the TenDRA "tokens" with their target-specific
representations along the way. It was freely available for
downloading from OSF, but at the time was distributed with just binary
executables of the matching TenDRA producer, since the TenDRA source
was under a very strict license. I will see if some other FTP server
still has a copy of the GANDF port, since it appears to have
disappeared from the Open Group (nee OSF) FTP server. Unfortunately,
GANDF was also based on a 2.3.3 version of GCC, although I had later
upgraded it to integrate with GCC-2.5.x. It would take even more
changes to merge the GANDF changes with the GCC-2.9.x technology,
since the GCC compiler has been significantly reorganized since 2.5.
We tried to create a set of context diffs (much like the early
distributions of G77) but found it unworkable between significant GCC
revs. I believe that this work was also based on Issue 3.0 of the
TenDRA specification, whereas the current tools are based on Issue
4.0. This "installer" was funded so that any platform which was not
directly supported by a TenDRA installer could be supported by this
one, since there was (and is) a GCC nearby for virtually any current
machine architecture. Benchmarks of GANDF vs. TenDRA-supplied
installers showed that this solution was sub-optimal, since many of
the patterns which the TenDRA installers recognized (and optimized)
were not picked up by the then existing GCC optimization technology.

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