Re: Ada and string literals

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 13-01-30 13:50 , Mart van de Wege wrote:
> Niklas Holsti <niklas.holsti@tidorum.invalid> writes:
> 
>> On 13-01-30 02:44 , codeallergy wrote:
>>> hi comp.lang.ada, 
>>>
>>> question from a newcomer: Why ada does not allow using a string
>>> literal with access type ?
>>>
>>> abc : access string := "LITERAL"; -- error.
>>
>> Because, unlike C, Ada does not confuse arrays with pointers.
>>
>> This is the closest Ada equivalent:
>>
>>    Literal : aliased constant String := "LITERAL";
>>    abc     : access constant String := Literal'Access;
> 
> More importantly, I cannot see why you would want an access to a string
> literal.
> 
> Just use the string literal as a normal parameter, and let the compiler
> worry about how to handle that.

I don't know why the OP wants an access, but I can image a situation
where one needs, for example, to call a subprogram with several string
parameters, which should have different values depending on different
logical conditions, in various combinations. It is then easier to
represent each parameter by local variable that can be assigned
different values in different if-then-else statements, and then use the
local variables as actual parameters in the call.

For example, assume you must call a procedure Foo (A, B: in String), and
A can be either "James" or "John" depending on condition Alpha, while B
can be either "Jill" or "Jennie" depending on condition Beta. You would
like to write something like this:

   -- The following does NOT work:
   ..
   is
      A, B : String;
   begin
      if Alpha then A := "James"; else A := "John"  ; end if;
      if Beta  then B := "Jill";  else B := "Jennie"; end if;
      Foo (A, B);
   ..

That doesn't work, because the declaration of A and B must specify a
length for the string, and then you cannot assign literal strings of
different length to A and B.

If you use string literals directly as parameters, you need different
calls for all combinations:

   if Alpha then
      if Beta then
         Foo ("James", "Jill");
      else
         Foo ("James", "Jennie");

and so on, for a combinatorial number of cases.

Of course you can use Ada.Strings.Unbounded or Ada.Strings.Bounded,
which let you assign strings of different lengths to the same variable,
but accesses to strings are another solution.

In the above simple example one could also use Ada 2012 conditional
expressions:

   Foo (A => (if Alpha then "James" else "John"  ),
        B => (if Beta  then "Jill"  else "Jennie"));

but in more complex cases that no longer works, or not as well as
assigning the actual parameter values to local variables before the call.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .