Random Input-Size and recognizing ENTER-press

Random Input-Size and recognizing ENTER-press

[xadian]

Hi all

Here's my problem:
I need to to Get() a random number of characters (typed by the user) in 
an array.
I could loop with a Get() statement and exit when all the inputs are in 
the array, but for that I'd need to know the number of inputs before. Is 
there a way to do that without knowing the input number?!
It would be possible if there is a way to recognize when the user 
presses the ENTER button (s.th. like captureEvent()). Is that possible?

Ty already
Xadian

Re: Random Input-Size and recognizing ENTER-press

[Marius Amado Alves]

> I need to to Get() a random number of characters (typed by the user) in 
> an array.
> I could loop with a Get() statement and exit when all the inputs are in 
> the array, but for that I'd need to know the number of inputs before.

If this is your only problem then it its no problem. Use an unbounded 
array. For characters that would be an Unbounded_String.

And use Get_Immediate if you want to test explicitly for CR (as the 
usual representation of Enter).

Since you say you want an array (for characters that would be a String), 
encapsulate the reading procedure inside a function returning a String.

On a silver plater:

    function Get_String return String is
       U : Unbounded_String;
    begin
       loop
          Get_Immediate (C);
          exit when C = CR;
          Append (U, C);
       end loop;
       return To_String (U);
    end;

Re: Random Input-Size and recognizing ENTER-press

[Jeffrey Carter]

Marius Amado Alves wrote:

>    function Get_String return String is
>       U : Unbounded_String;
>    begin
>       loop
>          Get_Immediate (C);
>          exit when C = CR;
>          Append (U, C);
>       end loop;
>       return To_String (U);
>    end;

You might want to take a look at the source for Ada.Strings.Unbounded 
from GNAT before advocating an approach such as this. Every addition of 
a Character allocates a new String, copies the old String + new 
Character into the new String, and deallocates the old String. For a 
string of N Characters, that's N allocations and deallocations. Using 
Get_Line to obtain the Characters can improve that to N / Buffer'Length + 1.

It's not clear that the OP really requires Get_Immediate; the only 
requirement stated is the need to read an arbitrary-length String. The 
discussion of recognizing when the Enter key is pressed is part of a 
proposed solution, not the problem.

-- 
Jeff Carter
"C++: The power, elegance and simplicity of a hand grenade."
Ole-Hjalmar Kristensen
90

Re: Random Input-Size and recognizing ENTER-press

[Pascal Obry]

Jeffrey Carter <spam@spam.com> writes:

> You might want to take a look at the source for Ada.Strings.Unbounded from
> GNAT before advocating an approach such as this. Every addition of a
> Character allocates a new String, copies the old String + new Character into
> the new String, and deallocates the old String. For a string of N
> Characters, that's N allocations and deallocations. Using Get_Line to obtain
> the Characters can improve that to N / Buffer'Length + 1.

That's not right. There is a buffer that is allocated when there is no more
space into an Unbounded_String. So there is far less that N allocation when
adding N characters into an Unbounded_String.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|              http://www.obry.org
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Random Input-Size and recognizing ENTER-press

[Jeffrey Carter]

Pascal Obry wrote:

> That's not right. There is a buffer that is allocated when there is no more
> space into an Unbounded_String. So there is far less that N allocation when
> adding N characters into an Unbounded_String.

Here's what I have:

    Null_String : aliased String := "";

    function To_Unbounded (S : String) return Unbounded_String
      renames To_Unbounded_String;

    type Unbounded_String is new AF.Controlled with record
       Reference : String_Access := Null_String'Access;
    end record;

    procedure Append
      (Source   : in out Unbounded_String;
       New_Item : in Character)
    is
       S_Length : constant Integer := Source.Reference.all'Length;
       Length   : constant Integer := S_Length + 1;
       Tmp      : String_Access;

    begin
       Tmp := new String (1 .. Length);
       Tmp (1 .. S_Length) := Source.Reference.all;
       Tmp (S_Length + 1) := New_Item;
       Free (Source.Reference);
       Source.Reference := Tmp;
    end Append;

Starting with a null string, that certainly looks like N allocations.

-- 
Jeff Carter
"I was hobbling along, minding my own business, all of a
sudden, up he comes, cures me! One minute I'm a leper with
a trade, next minute my livelihood's gone! Not so much as a
'by your leave!' You're cured, mate. Bloody do-gooder!"
Monty Python's Life of Brian
76

Re: Random Input-Size and recognizing ENTER-press

[Steve]

IMHO it's silly to worry about the number of allocations an deallocations 
when you're talking about keeping up with someone typing at a keyboard 
(especially at todays processor speeds).

Steve
(The Duck)

"Jeffrey Carter" <spam@spam.com> wrote in message 
news:qBhxd.4359$RH4.2409@newsread1.news.pas.earthlink.net...
> Marius Amado Alves wrote:
>
>>    function Get_String return String is
>>       U : Unbounded_String;
>>    begin
>>       loop
>>          Get_Immediate (C);
>>          exit when C = CR;
>>          Append (U, C);
>>       end loop;
>>       return To_String (U);
>>    end;
>
> You might want to take a look at the source for Ada.Strings.Unbounded from 
> GNAT before advocating an approach such as this. Every addition of a 
> Character allocates a new String, copies the old String + new Character 
> into the new String, and deallocates the old String. For a string of N 
> Characters, that's N allocations and deallocations. Using Get_Line to 
> obtain the Characters can improve that to N / Buffer'Length + 1.
>
> It's not clear that the OP really requires Get_Immediate; the only 
> requirement stated is the need to read an arbitrary-length String. The 
> discussion of recognizing when the Enter key is pressed is part of a 
> proposed solution, not the problem.
>
> -- 
> Jeff Carter
> "C++: The power, elegance and simplicity of a hand grenade."
> Ole-Hjalmar Kristensen
> 90 

Re: Random Input-Size and recognizing ENTER-press

[Jeffrey Carter]

Steve wrote:

> IMHO it's silly to worry about the number of allocations an deallocations 
> when you're talking about keeping up with someone typing at a keyboard 
> (especially at todays processor speeds).

True, but fragmentation of the heap is a different matter.

-- 
Jeff Carter
"This trial is a travesty. It's a travesty of a mockery of a
sham of a mockery of a travesty of two mockeries of a sham. ...
Do you realize there's not a single homosexual on that jury?"
Bananas
27

Re: Random Input-Size and recognizing ENTER-press

[Jeffrey Carter]

xadian wrote:
> 
> Here's my problem:
> I need to to Get() a random number of characters (typed by the user) in 
> an array.
> I could loop with a Get() statement and exit when all the inputs are in 
> the array, but for that I'd need to know the number of inputs before. Is 
> there a way to do that without knowing the input number?!

An array of characters is a string. In Ada, you can use the predefined 
type String.

Input of an arbitrary length String is easily done with a function such 
as PragmARC.Get_Line.

You can obtain the PragmAda Reusable Components at

http://home.earthlink.net/~jrcarter010/pragmarc.htm

-- 
Jeff Carter
"C++: The power, elegance and simplicity of a hand grenade."
Ole-Hjalmar Kristensen
90