Re: Using Ada for device drivers? (Was: the Ada mandate, and why it collapsed and died)

["Robert I. Eachus" <rieachus@attbi.com>]

Dave Thompson wrote:

> Not quite.  Ada Get_Line is much closer to C fgets, 
> although it does store the newline character (if it fits) 
> and you must often deal with removing it, and it does 
> not return the length explicitly (you must strlen for it).

There are three errors here.  The first is a category error.  The 
description of Ada.Text_IO.Get was just to show that in Ada, you can 
never have a buffer overflow error.  (Unless of course you go very far 
out of your way to specifically program one.  It can be done, but many 
Ada programmer don't know how, and most Ada programmers would consider 
going out of your way to construct an Ada program that had a potential 
buffer overflow not as a challenge, but as a kind of pornography.

The second error is technical. If an Ada program copies a newline 
character as part of a Get, that is an error.  If the type of the text 
file was incorrectly specified, for example as one where LF (linefeed) 
is the representation of end of line, instead of CR LF, then you will 
read a CR character.  This occasionally used to happen when people 
ported files between Windows and Unix.  I think now thought that all Ada 
compilers accept any combination of CR and LF as end of line, while 
using the appropriate end of line marker for that system when writing 
text files.

Finally, in Ada the only cases where you need to call strlen is when 
converting a C or C++ string to an Ada String.  In Ada the name of the 
length of the string named Foo is Foo'Length.  But it is an explict 
property of the string, just like Foo'First and Foo'Last.  (Most Ada 
compilers only store two of the three attributes as part of the 
representation of a dynamic string. (A string whose length is not known 
at compile time.)  But that is an implementation detail.

The whole point here is that an Ada programmer never worries about the 
length of a string or the any of the implicit checking that needs to be 
explicit in C.  In fact in Ada 95 there are several library packages 
defined to make it easier to create string objects with different 
properties.  The objects of the standard String type have their 
attributes determined when the object is created.  The values of the 
String type can be of any size or bounds.  (Well subject to 
X'Last-X'First+1 = X'Length.)  However there is an explicit type 
Ada.Strings.Unbounded.Unbounded_String, which can store different length 
strings. (Yes, you can rename it if you want to use it. ;-) This is 
handy if you want to create "ragged" arrays of strings, or to  have a 
library level string object whose length changes.

There is also a Bounded_String type which corresponds to the PL/I char * 
varying, or what most C programmers thing that buffers are like.  (But 
assigning to long a string to a Bounded_String will cause an error. If 
you don't know what the limit should be, or can't figure out how to 
handle the exception, use Unbounded_String instead.)