Re: Your wish list for Ada 202X

[Adam Beneschan <adambeneschan@gmail.com>]

On Sunday, March 30, 2014 6:40:24 AM UTC-7, Luke A. Guest wrote:

> 
> > One wish to ease Input/output :
> 
> > To have some equivalent of C primitive : printf("%c %c %c %c %c \n %c %c %c %c %c \n",
> 
> God no. This requires parsing the string in every call, the Ada does it no
> is superior. 

I can't tell what you're trying to say here--it's not grammatical.  If you're trying to say something along the lines of "the Ada way to write this", I'm not sure just what that is.  I'm sure there are several opinions about what "the Ada way" is for this.

> Plus it requires parameter passing from the right rather than
> the left.

No, it wouldn't require parameter passing like that at all.  Some different mechanism would no doubt have to be invented, though.

The original C didn't have function prototypes at all.  Most of the time, you simply used the function, and the compiler would assume it existed.  If the return type were something other than "int", you might have to write an "extern" declaration to tell the compiler the function existed and its return type, but you still didn't tell it anything about the parameters.  The compiler assumed you knew the parameter types and got them right, and if you didn't, then you got to have fun debugging your error.  But functions with variable numbers of argument like printf() could be made to work because the compiler would push the arguments on the stack right-to-left, and the printf() function would read them from the stack like that.

But, certainly, if one were to design a mechanism to allow such parameter passing, one wouldn't be constrained to use the same mechanism adopted by an extremely low-level 1960s programming language like C.  There are many other possibilities, such as pushing the number of parameters and the number of bytes in each passed value as hidden parameters on the stack.  The assumption here would be that the printf function would be *declared* to take a variable-argument-list, and therefore the compiler would know, on *both* sides (when compiling the subprogram body, and when compiling the call), that the special mechanism for passing variable-argument lists would need to be in effect.  This assumption was *not* true for the original C, which is why the right-to-left thing was necessary.

In Java, for instance, methods with variable-length argument lists are just treated as arrays.  So when you say

    System.out.printf("Count=%d value=%8.2f\n", someInteger, someFloat);

printf will see two parameters: a String, and an array of two Objects, where the first element is an Integer and the second is a Float.  (All "objects" in Java are descended from Object, and non-objects like "int" will be automatically converted to Integer objects in some contexts.)  printf can then just traverse the array; it can also check to make sure the variable argument list has the correct number of parameters and parameter types.  

I'm not saying that Ada needs a feature like this, or that it should be implemented the way Java did it.  I'm just saying that it clearly is *not* necessary to use right-to-left parameter passing in order to add a feature like this to the language.  

                                 -- Adam