-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Hi,

I'm curious about how you are using string. I think string are quite
useful, but how they are fixed size, I'm often defining them in the
declare part.

I don't know if it's a good practice, but I got code like this:

urio: constant AWS.URL.Object := AWS.Status.URI(request);
host_raw: constant String := AWS.Status.Host(request);
host: constant String := host_raw(host_raw'First ..
First_Index(host_raw, ':'));
www: constant String := SCMAL.Httpd.Servers.GetWWW(host);
Filename: constant String := AWS.URL.Abs_Path(urio);

and so on.

So the main problem is error management. If one function raise
exception, the exception can't be catch except with the following trick:

Dmitry A. Kazakov wrote:

Me too. I think it's one of those mistakes that sticks in the mind.

Dmitry A. Kazakov wrote:

It might make tracing elaboration errors easier. :)

Niklas Holsti writes:

Sure, that's right, but the syntax doesn't make it clear.
We have ample proof that this syntax is confusing:
More than one person in this thread has admitted to
being confused -- QED. ;-)

I think it was a mistake to attach exception handlers
to declare blocks and procedures and so forth. Instead,
there should be a single statement for handling exceptions,
as in Java and other languages. Something like:

And it's what exactly I don't think pretty nice and easy to maintain. Other
solution proposed by previous post is to separate the code with nested function:

procedure Patati_Patata is

On 8 Cze, 20:32, Robert A Duff shell01.TheWorld.com> wrote:

You did not state it explicitly, but I presume that you allow mixing
declarations with executable code ("as in Java and other languages")?
After all, with the possibility to initialize the new variable with
arbitrarily complex expression (including function call), this is
already the case and the whole declare-begin-end block is just
reflecting some artificial separation.

Maciej Sobczak gmail.com> writes:

Yes, if I ran the circus, I would allow that. I really find it annoying
that I have to add 3 useless lines of code (declare/begin/end) and an
extra level of indentation, when all I wanted to do was declare
a very-local object.

I also find it annoying that I can't add a statement at the beginning of
a procedure, without moving everything into a local block. E.g. I have:

procedure P (X : Integer) is
Local : constant String := ...;
begin
...

and I want add:

if X = 0 then
raise Blah;
end if;

and I want that to come first.

On Sun, 08 Jun 2008 17:19:11 -0400, Robert A Duff wrote:

I disagree. I think it does make sense because it clearly defines the scope
of the declared variable. Expression (result) /= named object. And
reversely, if you don't need the variable, you are free to put expressions
anywhere outside the declaration part.

On Sun, 08 Jun 2008 20:17:33 +0300, Niklas Holsti wrote:

Nothing can reveal all errors.

But errors in exceptions became painful in Ada. I permanently run into the
stuff, like when an unhandled exception winds up controlled objects,
causing secondary exceptions in Finalizes (which may not happen if the
primary exception were handled). It is very difficult to trace back.

[...]

I think that partitions could be a better candidate for such things.

Maybe it is a "philosophy" again, but to me failed declarations is a
correctness problem, rather than an exceptional state. As such it should
not be handled inside itself.

Dmitry A. Kazakov schrieb:

Still, a somewhat *new* kind kind of handling exceptions in single
declarations looks interesting?