Re: Mneson announcement and help request

["Randy Brukardt" <randy@rrsoftware.com>]

"Martin Dowie" <martin.dowie@btopenworld.com> wrote in message
news:c9melj$fg6$1@sparta.btinternet.com...
> "Randy Brukardt" <randy@rrsoftware.com> wrote in message
> news:xK-dnZHKcKOszSPdRVn-ug@megapath.net...
> > Well, yes, because End_of_File for Text_IO is very expensive (it has to
do
> > lookahead of as many as two characters, and doing so makes later Gets
> > expensive as well). But "End_of_File" (or indeed any function call)
misses
> > the point.
>
> My point was that EOF is relatively cheap compared to raising the
exception
> not that it is cheap per se. And if GNAT and ObjectAda (the 2 compilers I
> have any source for) are typical of most implementations then this is
certainly
> true. OA even includes lots of local instantiations of the sort that MAA
was
> finding very slow (assuming OA is also "slow" in this regard).

My point was that as long as you keep the exception handler and raising out
of the loop (which is certainly true for EOF), it can be quite efficient. In
the normal case (where you read many characters before reaching the end of
the file), it's almost always better to handle the exception. That's because
one exception raise/handling pair is a lot cheaper than 10,000 function
calls, especially one as expensive as EOF. (And EOF is more expensive than
exception handling on Janus/Ada if it has to read lookahead, because system
calls always are more expensive than code that doesn't require system calls,
like exception handling. And I'd expect that to be true on most compilers,
as that is more of a function of the OS, not really of the compiler).

Now, the code you originally described (which did the exception raise and
handing inside the loop) would be awful on any compiler. But replacing it
with an expensive function (essentially any that aren't inlined) is not
going to be much help.

                        Randy.