On 8/15/24 13:34, Simon Clubley wrote:

On 2024-08-14, Arne Vajhøj <arne@vajhoej.dk> wrote:

On 8/14/2024 2:33 PM, Arne Vajhøj wrote:

And it has different size of long and pointers. Causing problems
for two cases:
* code that make implicit assumptions that those are 32 bit
* mixing C and C++

I am getting more and more convinced that C and C++
code should completely switch to the explicit length
model.

So:

#include <stdint.h>

or:

#include <cstdint>

and use:

int8_t
int16_t
int32_t
int64_t
uint8_t
uint16_t
uint32_t
uint64_t

and consider putting:

#define int ">>>> DO NOT USE INT <<<<"
#define short ">>>> DO NOT USE SHORT <<<<"
#define long ">>>> DO NOT USE LONG <<<<"

in as well to enforce.

Where did I put that asbestos suit to protect me
from the C/C++ crowd?

That works great until you need to interface to the OS unfortunately.

BTW, I've been writing my own code with explicit sizing for many years.

To extend this, I also know the difference between signed and unsigned variables and I have a default-unsigned approach unless I absolutely
_need_ a signed variable.

Unfortunately, a lot of the material out there doesn't seem to understand that designing a program is about modelling a real-world problem and that
it isn't OK to just use a signed integer to store an unsigned value.

Simon.

Absolutely, must have come from an assembler background, where the use
of signed branches and arithmetic, can get you into serious trouble.
The standard C library, of course, tends to use signed variables for everything, a gross error that has never been fixed...

Chris

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/19/2024 2:56 PM, chrisq wrote:

On 8/15/24 13:34, Simon Clubley wrote:

To extend this, I also know the difference between signed and unsigned
variables and I have a default-unsigned approach unless I absolutely
_need_ a signed variable.

Unfortunately, a lot of the material out there doesn't seem to understand
that designing a program is about modelling a real-world problem and that
it isn't OK to just use a signed integer to store an unsigned value.

 Absolutely, must have come from an assembler background, where the use
of signed branches and arithmetic, can get you into serious trouble.
The standard C library, of course, tends to use signed variables for everything, a gross error that has never been fixed...

At least the C people can define an unsigned variable.

Java does not have unsigned data types at all. OK - higher level
language and all that. But still a PITA.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/14/24 19:48, Arne Vajhøj wrote:

On 8/14/2024 2:33 PM, Arne Vajhøj wrote:

And it has different size of long and pointers. Causing problems
for two cases:
* code that make implicit assumptions that those are 32 bit
* mixing C and C++

I am getting more and more convinced that C and C++
code should completely switch to the explicit length
model.

So:

#include <stdint.h>

or:

#include <cstdint>

and use:

int8_t
int16_t
int32_t
int64_t
uint8_t
uint16_t
uint32_t
uint64_t

and consider putting:

#define int ">>>> DO NOT USE INT <<<<"
#define short ">>>> DO NOT USE SHORT <<<<"
#define long ">>>> DO NOT USE LONG <<<<"

in as well to enforce.

Where did I put that asbestos suit to protect me
from the C/C++ crowd?

:-)

Arne

For years in embedded work here, there is always a header file,
wordsize.h which aliases such as U8, U16, U32 etc, to the bit
sizes of the types related to the cpu variant and tools in
use. Pretty foolproof, and important for embedded work, where
you often need to know the width of hardware registers, and
the variables and pointers that interact with them...





--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-19 18:56:53 +0000, chrisq said:

On 8/15/24 13:34, Simon Clubley wrote:

That works great until you need to interface to the OS unfortunately.

BTW, I've been writing my own code with explicit sizing for many years.

To extend this, I also know the difference between signed and unsigned
variables and I have a default-unsigned approach unless I absolutely
_need_ a signed variable.

Unfortunately, a lot of the material out there doesn't seem to
understand that designing a program is about modelling a real-world
problem and that it isn't OK to just use a signed integer to store an
unsigned value.

Unfortunately a lot of apps are implemented in C or C++ when they
probably shouldn't, too.

Package management is another area where C, C++, and OpenVMS itself all
get into trouble.

Same for concurrency, strings, and various other topics.

Absolutely, must have come from an assembler background, where the use
of signed branches and arithmetic, can get you into serious trouble.
The standard C library, of course, tends to use signed variables for everything, a gross error that has never been fixed...

The C compiler promotes unsigned to signed, as well. And this promotion
"fun" includes uint*_t variables quite possibly getting promoted to
signed.

q.v.: C11 6.3.1.1: "If an int can represent all values of the original
type (as restricted by the width, for a bit-field), the value is
converted to an int; otherwise, it is converted to an unsigned int.
These are called the integer promotions."
Also q.v.: C11 6.3.18: "Usual arithmetic conversions"

strings and character encoding are more "fun": https://thephd.dev/the-c-c++-rust-string-text-encoding-api-landscape

apropos of nothing, OpenVMS has a whole pile of tooling to avoid
changing constants: https://devblogs.microsoft.com/cppblog/how-we-used-cpp20-to-eliminate-an-entire-class-of-runtime-bugs/


Porting is hard: https://github.com/ziglang/zig/pull/13560 (And
sometimes creative.)

And if you're coexisting with C and C++ (incrementally or otherwise): https://kristoff.it/blog/maintain-it-with-zig/

And if you're deep into C++, the following might interest (Apache 2.0): https://github.com/abseil/abseil-cpp

Swift as a replacement for issues with C and C++ (and deterministic
testing, and cross-language optimization): https://www.youtube.com/watch?v=ZQc9-seU-5k

This won't be happening anytime soon if ever of course, as VSI has
beyond more than enough work in their pending queue.

--
Pure Personal Opinion | HoffmanLabs LLC

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Mon, 19 Aug 2024 15:07:36 -0400, Arne Vajhøj wrote:

At least the C people can define an unsigned variable.

Java does not have unsigned data types at all. OK - higher level
language and all that. But still a PITA.

Beat me to it. Java’s lack of unsigned integer types is indeed a downright pain. Along with its omission of typedefs. I think they were trying to
come up with a simpler language than C++, but that was a) (at least a
partial) failure, and b) at the cost of leaving out too many useful
things.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Mon, 19 Aug 2024 16:05:59 -0400, Stephen Hoffman wrote:

strings and character encoding are more "fun":

If a system/library call is going to return a dynamic amount of data, it
is good if it can give some indication of how much data it is going to
return first.

The best calls are the ones that, if you pass NULL for the buffer, they
will return the number of bytes they would have put in the buffer. So you allocate that size of buffer and do a second call, and get back the actual buffer data.

I did a Python wrapper for Fribidi, and unfortunately its text-encoding conversion calls didn’t work that way. But then, they probably
couldn’t ...

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-19, chrisq <devzero@nospam.com> wrote:

On 8/15/24 13:34, Simon Clubley wrote:

To extend this, I also know the difference between signed and unsigned
variables and I have a default-unsigned approach unless I absolutely
_need_ a signed variable.

Unfortunately, a lot of the material out there doesn't seem to understand
that designing a program is about modelling a real-world problem and that
it isn't OK to just use a signed integer to store an unsigned value.

Absolutely, must have come from an assembler background, where the use
of signed branches and arithmetic, can get you into serious trouble.
The standard C library, of course, tends to use signed variables for everything, a gross error that has never been fixed...

From both ends of the scale actually. :-)

In my early days, I had a _lot_ of assembly language experience.

That was then followed by Wirth language and then Ada experience.

The Wirth languages and then Ada was where my experience to date turned
into a preference for strict data types and the importance of modelling
as accurately as possible the real-world problem you are implementing.

BTW, I still consider classic ARM to be the most elegant assembly language
I have encountered (although those with M68K and similar experience tend
say they are somewhat better).

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-19, Arne Vajh�j <arne@vajhoej.dk> wrote:

On 8/19/2024 8:38 AM, Simon Clubley wrote:

One of the nice things about higher-level languages such as C (when
compared to Macro-32/BLISS and their associated OS APIs) is that the
pointer types are abstracted so the programmer doesn't need to worry
about pointer size differences in many cases unless they start using
VMS-specific APIs.

Of course, that all changes if you are porting crappy software that
tries to stuff addresses into integers or if you are doing device
driver/hardware work where things like bounce buffers may come into play.

Or if the application is passing pointers between code compiled
with different languages/compilers/compiler settings.

Of course, that is what ABIs are _supposed_ to be for...

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-19, Arne Vajh�j <arne@vajhoej.dk> wrote:

On 8/19/2024 2:56 PM, chrisq wrote:

On 8/15/24 13:34, Simon Clubley wrote:

To extend this, I also know the difference between signed and unsigned
variables and I have a default-unsigned approach unless I absolutely
_need_ a signed variable.

Unfortunately, a lot of the material out there doesn't seem to understand >>> that designing a program is about modelling a real-world problem and that >>> it isn't OK to just use a signed integer to store an unsigned value.

�Absolutely, must have come from an assembler background, where the use
of signed branches and arithmetic, can get you into serious trouble.
The standard C library, of course, tends to use signed variables for
everything, a gross error that has never been fixed...

At least the C people can define an unsigned variable.

Java does not have unsigned data types at all. OK - higher level
language and all that. But still a PITA.

Don't get me bloody started on that. :-) Currently doing some Java
development as part of a personal non-work project on Android.

On the plus side, I do like the ease of been able to send messages in
a message queue between threads however and the clean integration of
threads into the language. See:

https://developer.android.com/reference/android/os/Handler

On the negative side, some things can be so bureaucratic in the Android
and Java world. For example, the Android documentation keeps trying to force you into using Fragments (and the associated Activity) when simple Views
are a lot easier to handle.

At times, Java itself seems to "feel" like it has been designed by theorists with little real-world experience. All the classes-upon-classes when doing
I/O come to mind here.

And BTW, Java, is it .size() or .length() ??? Pick one and stick with it
when you design your classes. :-(

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/19/24 20:07, Arne Vajhøj wrote:

On 8/19/2024 2:56 PM, chrisq wrote:

On 8/15/24 13:34, Simon Clubley wrote:

To extend this, I also know the difference between signed and unsigned
variables and I have a default-unsigned approach unless I absolutely
_need_ a signed variable.

Unfortunately, a lot of the material out there doesn't seem to
understand
that designing a program is about modelling a real-world problem and
that
it isn't OK to just use a signed integer to store an unsigned value.

  Absolutely, must have come from an assembler background, where the
use of signed branches and arithmetic, can get you into serious trouble.
The standard C library, of course, tends to use signed variables for
everything, a gross error that has never been fixed...

At least the C people can define an unsigned variable.

Java does not have unsigned data types at all. OK - higher level
language and all that. But still a PITA.

Arne

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

Chris

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/24 00:33, Lawrence D'Oliveiro wrote:

On Mon, 19 Aug 2024 16:05:59 -0400, Stephen Hoffman wrote:

strings and character encoding are more "fun":

If a system/library call is going to return a dynamic amount of data, it
is good if it can give some indication of how much data it is going to
return first.

The best calls are the ones that, if you pass NULL for the buffer, they
will return the number of bytes they would have put in the buffer. So you allocate that size of buffer and do a second call, and get back the actual buffer data.

I did a Python wrapper for Fribidi, and unfortunately its text-encoding conversion calls didn’t work that way. But then, they probably
couldn’t ...

For work here, all functions that return data have a parameter that
limits the byte count. Usually pass a pointer to a buffer, with the size parameter equal to or less than the buffer size. Some C library
functions are just not safe to use in that respect.

Local spun string copy and other functions use the same sort of size
limiting.

Chris

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/24 13:36, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

The way to get round that here, for many functions
with multiple parameters, is to declare a structure,
with the args, status and even status qualifier.
Can include buffer pointers and lengths as well.
Fill in the args, then pass a pointer to that
for the call. Not only is it efficient, as it
can be passed using single register, but it's
also easy to add structure elements without affecting
other code that calls it. It can help to
make code fully rentrant and is a way to get some
abstraction for little effort. Also seems like good
practice, as one of the key design tasks should
be to accurately define and encapsulate the
interfaces to the code.

Quite a bit of unix code that uses such techniques,
as does vms with descriptors, if that'a the
right name for it.

Chris

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

Simon.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

Few languages support multiple return values.

And a few other languages support tuples with named fields
or anonymous classes with named properties, which is almost as good.

And almost all newer high level languages support
map/dictionary/associative array.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 8:04 AM, Simon Clubley wrote:

On 2024-08-19, Arne Vajhøj <arne@vajhoej.dk> wrote:

On 8/19/2024 8:38 AM, Simon Clubley wrote:

One of the nice things about higher-level languages such as C (when
compared to Macro-32/BLISS and their associated OS APIs) is that the
pointer types are abstracted so the programmer doesn't need to worry
about pointer size differences in many cases unless they start using
VMS-specific APIs.

Of course, that all changes if you are porting crappy software that
tries to stuff addresses into integers or if you are doing device
driver/hardware work where things like bounce buffers may come into play. >>

Or if the application is passing pointers between code compiled
with different languages/compilers/compiler settings.

Of course, that is what ABIs are _supposed_ to be for...

Yes.

But that is the point.

The ABI is right by definition. The compilers pointer size is
just usually right.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 8:29 AM, Simon Clubley wrote:

At times, Java itself seems to "feel" like it has been designed by theorists with little real-world experience. All the classes-upon-classes when doing I/O come to mind here.

JCP is just like ANSI, ISO and ECMA.

Java is literally designed by committee.

And there are some horror decisions. The compiler API comes
to my mind - it takes 200 lines to do what you can do in 5 lines
in C#.

The java.io package may seem a bit complex, but it makes perfect
sense when you learn the structure.

The basics is:

InputStream - read bytes from anything
FileInputStream - read bytes from file
ByteArrayInputStream - read bytes from byte array
...
OutputStream - write bytes to anything
FileOutputStream - write bytes to file
ByteArrayOutputStream - write bytes to byte array
...
Reader - read chars according to encoding from anything
FileReader - read chars according to encoding from file
CharArrayReader - read chars according to encoding from char array
...
Writer - write chars according to encoding to anything
FileWriter - write chars according to encoding to file
CharArrayWriter - write chars according to encoding to char array
...

All very systematic.

On top of that there are two convenience classes to work with text
files:
* BufferedReader that wraps any Reader and provides a readLine method
* PrintWriter that wraps any Writer and provides print, println and
printf methods

Remember that and you can handle 98% of cases.

For the last 2% reading the docs will be needed.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 2024-08-20 at 12:36 +0000, Simon Clubley wrote:

One thing I wish was available in all languages is the ability to
return multiple values from a function call so you can return both a
status and the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I
simulate this by returning an associative array from a function call
with both status and value fields. Makes coding _so_ much cleaner and
robust.

Rust does this very well:

pub fn swap(a: u32, b: u32) -> (u32, u32)
{
(b, a)
}

--
Tactical Nuclear Kittens

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20, Arne Vajh�j <arne@vajhoej.dk> wrote:

On 8/20/2024 8:29 AM, Simon Clubley wrote:

At times, Java itself seems to "feel" like it has been designed by theorists >> with little real-world experience. All the classes-upon-classes when doing >> I/O come to mind here.

JCP is just like ANSI, ISO and ECMA.

Java is literally designed by committee.

It shows. :-)

And there are some horror decisions. The compiler API comes
to my mind - it takes 200 lines to do what you can do in 5 lines
in C#.

Also, no dynamic arrays built into the language itself. You need ArrayList()
to implement them or things like ByteArrayOutputStream().

The java.io package may seem a bit complex, but it makes perfect
sense when you learn the structure.

The basics is:

InputStream - read bytes from anything
FileInputStream - read bytes from file
ByteArrayInputStream - read bytes from byte array
...
OutputStream - write bytes to anything
FileOutputStream - write bytes to file
ByteArrayOutputStream - write bytes to byte array
...
Reader - read chars according to encoding from anything
FileReader - read chars according to encoding from file
CharArrayReader - read chars according to encoding from char array
...
Writer - write chars according to encoding to anything
FileWriter - write chars according to encoding to file
CharArrayWriter - write chars according to encoding to char array
...

All very systematic.

On top of that there are two convenience classes to work with text
files:
* BufferedReader that wraps any Reader and provides a readLine method
* PrintWriter that wraps any Writer and provides print, println and
printf methods

Remember that and you can handle 98% of cases.

For the last 2% reading the docs will be needed.

You forgot about InputStreamReader() to turn an InputStream into a Reader. :-) After all, why miss the opportunity to have two parallel sets of APIs
(byte versus character) instead of just the one API ? :-)

Goodness knows why they didn't just add something like String's getBytes() method to the character APIs or add character support to the byte APIs...

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20, bill <bill.gunshannon@gmail.com> wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return
multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

Huh ? Well that shows you haven't done this kind of thing. :-)

If you are talking about PHP, you construct an associative array
in the return statement of the function and then access the keys
in the caller. Very clean.

If you are talking about some future thing based on C, you simply
extend the function prototype to include a list of return types
instead of the single type it is at the moment and you just return
the list in the function's return statement.

$ set response/mode=good_natured

Or are associative arrays and other higher-level data structures an alien concept to you ? :-)

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20, bill <bill.gunshannon@gmail.com> wrote:

On 8/20/2024 8:29 AM, Simon Clubley wrote:

I stopped working with Java almost a decade ago. (it coincided with
my retirement when I no longer had to do work for others!)
But, here goes....

At times, Java itself seems to "feel" like it has been designed by theorists >> with little real-world experience.

What makes you think it wasn't? Kinda like Ada. The USAF came up
with an idea because they needed it for their jets. Others got
involved resulting in a product that no longer met their needs.
DOD mandated Ada usage. The USAF said no thank you and went back
to Jovial. :-)

Huh ? Ada has seen a _lot_ of use in safety-critical applications,
including in areas where there is no government mandate.

I can't speak to going back to Jovial (assuming you have not got
the details wrong), but the other choices such as C++ seemed to be
more political in nature once the mandate was dropped.

All the classes-upon-classes when doing >> I/O come to mind here.

And BTW, Java, is it .size() or .length() ??? Pick one and stick with it
when you design your classes. :-(

To me size and length are not the same thing. Strings have length.
Data types, pointers and the like have size. Anything trying to
make the two interchangeable is just wrong. :-)

And to confuse this further, in Java an array has a .length variable
(not method), while ArrayList has a .size() method. :-)

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 2:37 PM, Arne Vajhøj wrote:

The second transfer between an in memory sequence of
sequence of chars aka Unicode code points (0..65536 values)
usually in the form of String objects

Correction.

That was how it was when it was designed.

Today it is:

... UTF-16 code units (0..65536 values) ...

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 1:34 PM, bill wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

It is easy to understand if reasonable descriptive key names are chosen.

Example:

$ type mr.php
<?php

function four_ops($a, $b) {
return array('plus' => $a + $b, 'minus' => $a - $b, 'multiply' =>
$a * $b, 'divide' => $a / $b);
}

$a = 3.0;
$b = 2.0;
$res = four_ops($a, $b);
echo sprintf("%f + %f = %f\r\n", $a, $b, $res['plus']);
echo sprintf("%f - %f = %f\r\n", $a, $b, $res['minus']);
echo sprintf("%f * %f = %f\r\n", $a, $b, $res['multiply']);
echo sprintf("%f / %f = %f\r\n", $a, $b, $res['divide']);


$ php mr.php
3.000000 + 2.000000 = 5.000000
3.000000 - 2.000000 = 1.000000
3.000000 * 2.000000 = 6.000000
3.000000 / 2.000000 = 1.500000

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 1:38 PM, Simon Clubley wrote:

Also, no dynamic arrays built into the language itself. You need ArrayList() to implement them or things like ByteArrayOutputStream().

At the level of Java then I think that is to be expected. A
dynamic data structure requires a collection type. In C#
List<T> and T[] are different. In C++ vector<T> and T[] are
different.

But Java developers should consider ArrayList<T> to be their
default choice instead of T[].

The java.io package may seem a bit complex, but it makes perfect
sense when you learn the structure.

The basics is:

InputStream - read bytes from anything
FileInputStream - read bytes from file
ByteArrayInputStream - read bytes from byte array
...
OutputStream - write bytes to anything
FileOutputStream - write bytes to file
ByteArrayOutputStream - write bytes to byte array
...
Reader - read chars according to encoding from anything
FileReader - read chars according to encoding from file
CharArrayReader - read chars according to encoding from char array
...
Writer - write chars according to encoding to anything
FileWriter - write chars according to encoding to file
CharArrayWriter - write chars according to encoding to char array
...

All very systematic.

On top of that there are two convenience classes to work with text
files:
* BufferedReader that wraps any Reader and provides a readLine method
* PrintWriter that wraps any Writer and provides print, println and
printf methods

Remember that and you can handle 98% of cases.

For the last 2% reading the docs will be needed.

You forgot about InputStreamReader() to turn an InputStream into a Reader. :-)

There are InputStreamReader to convert from InputStream to Reader and OutputStreamWriter to convert from OutputStream to Writer.

And they are actually used, because some API's has classes that only has getInputStream()/getOutputStream() methods and not
getReader()/getWriter() methods.

All follow the model.

After all, why miss the opportunity to have two parallel sets of APIs
(byte versus character) instead of just the one API ? :-)

Goodness knows why they didn't just add something like String's getBytes() method to the character APIs or add character support to the byte APIs...

Because InputStream/OutputStream and Reader/Writer are fundamentally
different.

The first transfer between an in memory sequence of bytes
(-128..127 values) to an external form of same sequence of
bytes (-128..127 values).

The second transfer between an in memory sequence of
sequence of chars aka Unicode code points (0..65536 values)
usually in the form of String objects to an external form
of sequence of bytes (-128..127) values often of a different
length according to some encoding (UTF-8 is most common but
there are hundreds of possibilities: UTF-16, UTF-32, ISO-8859-x,
ASCII, EBCDIC, various non-latin).

In C then wprintf/wscanf are not the same as printf/scanf either.

The difference is that very few use wide in C while everybody is
more or less forced to use wide in Java.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 2:37 PM, Arne Vajhøj wrote:

Because InputStream/OutputStream and Reader/Writer are fundamentally different.

The first transfer between an in memory sequence of bytes
(-128..127 values) to an external form of same sequence of
bytes (-128..127 values).

The second transfer between an in memory sequence of
sequence of chars aka Unicode code points (0..65536 values)
usually in the form of String objects to an external form
of sequence of bytes (-128..127) values often of a different
length according to some encoding (UTF-8 is most common but
there are hundreds of possibilities: UTF-16, UTF-32, ISO-8859-x,
ASCII, EBCDIC, various non-latin).

Demo:

$ type OSDemo.java
import java.io.*;

public class OSDemo {
public static void main(String[] args) throws Exception {
try(OutputStream os = new FileOutputStream("os.dat")) {
os.write(1);
os.write(2);
os.write(3);
}
}
}
$ javac OSDemo.java
$ java OSDemo
$ dump os.dat

Dump of file DKA0:[arne]os.dat;2 on 20-AUG-2024 15:05:50.22
File ID (52122,13,0) End of file block 1 / Allocated 16

Virtual block number 1 (00000001), 512 (0200) bytes

00000000 00000000 00000000 00000000 00000000 00000000 00000000
00030201 ................................ 000000

$ type WrtDemo.java
import java.io.*;

public class WrtDemo {
public static void main(String[] args) throws Exception {
try(PrintWriter pw = new PrintWriter("pw_" +
args[0].toLowerCase() + ".txt", args[0])) {
pw.printf("%d %d %d\n", 1, 2, 3);
}
}
}
$ javac WrtDemo.java
$ java WrtDemo "UTF-8"
$ dump pw_utf-8.txt

Dump of file DKA0:[arne]pw_utf-8.txt;2 on 20-AUG-2024 15:06:00.26
File ID (52124,20,0) End of file block 1 / Allocated 16

Virtual block number 1 (00000001), 512 (0200) bytes

00000000 00000000 00000000 00000000 00000000 00000000 00000A33
20322031 1 2 3........................... 000000

$ java WrtDemo "UTF-16"
$ dump pw_utf-16.txt

Dump of file DKA0:[arne]pw_utf-16.txt;2 on 20-AUG-2024 15:06:02.38
File ID (52126,11,0) End of file block 1 / Allocated 16

Virtual block number 1 (00000001), 512 (0200) bytes

00000000 00000000 00000000 00000000 00000A00 33002000 32002000
3100FFFE þ..1. .2. .3.................... 000000

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Copy: clubley@remove_me.eisner.decus.org-Earth.UFP (Simon Clubley)

Hello All ,

On Mon, 19 Aug 2024, Simon Clubley via Info-vax wrote:

On 2024-08-18, Michael Kraemer <m.kraemer@gsi.de> wrote:

On 18.08.2024 03:59, Dave Froble wrote:

Well, one could argue that paper and ink are also "not VMS" ...

VMS is the OS ...
Documentation is, well, whatever it is ...

well, one could argue that a real OS should not depend on another one to
be fully functional.

That has not been true for VMS since physical terminals were replaced
with terminal emulators.

Simon.

Heck , Even then , the terminals were software driven .
eeproms on some of them & even some of those not promed had ariable fonts ...

Twyl , JimL

--
+---------------------------------------------------------------------+
| James W. Laferriere | System Techniques | Give me VMS |
| Network & System Engineer | 3237 Holden Road | Give me Linux |
| jiml@system-techniques.com | Fairbanks, AK. 99709 | only on AXP | +---------------------------------------------------------------------+

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/24 1:45 PM, Arne Vajhøj wrote:

On 8/20/2024 2:37 PM, Arne Vajhøj wrote:

The second transfer between an in memory sequence of
sequence of chars aka Unicode code points (0..65536 values)
usually in the form of String objects

Correction.

That was how it was when it was designed.

Today it is:

... UTF-16 code units (0..65536 values) ...

That was UCS-2, which was fixed width. UTF-16 can encode all the code
points in Unicode because it is varying width.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/18/24 14:03, Arne Vajhøj wrote:

On 8/18/2024 6:05 AM, Michael Kraemer wrote:

On 18.08.2024 03:59, Dave Froble wrote:

Well, one could argue that paper and ink are also "not VMS" ...

VMS is the OS ...
Documentation is, well, whatever it is ...

well, one could argue that a real OS should not depend on another one
to be fully functional.
At least it should be able to present its own documentation.
In this context, paper and ink are agnostic.

Maybe the concept "OS" is too general here.

I would expect a "client OS" to be able to display
HTML, PDF, video etc..

I would expect a "server OS" to be able to serve
that content to clients.

Arne

A properly sorted os should be able to do any of those things,
with the appropriate packages. The os is merely there to provide
services to applications...

Chris

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 5:56 PM, chrisq wrote:

On 8/18/24 14:03, Arne Vajhøj wrote:

On 8/18/2024 6:05 AM, Michael Kraemer wrote:

On 18.08.2024 03:59, Dave Froble wrote:

Well, one could argue that paper and ink are also "not VMS" ...

VMS is the OS ...
Documentation is, well, whatever it is ...

well, one could argue that a real OS should not depend on another one
to be fully functional.
At least it should be able to present its own documentation.
In this context, paper and ink are agnostic.

Maybe the concept "OS" is too general here.

I would expect a "client OS" to be able to display
HTML, PDF, video etc..

I would expect a "server OS" to be able to serve
that content to clients.

A properly sorted os should be able to do any of those things,
with the appropriate packages. The os is merely there to provide
services to applications...

True.

But packages does not get ported to an OS by magic - someone
needs to do the work.

VSI see VMS as a server OS and spend money on server stuff
not client stuff.

Given that a large part of the client stuff is open source,
then VMS users could in theory add the client stuff. But
we all know that is not going to happen.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 5:12 PM, Craig A. Berry wrote:

On 8/20/24 1:45 PM, Arne Vajhøj wrote:

On 8/20/2024 2:37 PM, Arne Vajhøj wrote:

The second transfer between an in memory sequence of
sequence of chars aka Unicode code points (0..65536 values)
usually in the form of String objects

Correction.

That was how it was when it was designed.

Today it is:

... UTF-16 code units (0..65536 values) ...

That was UCS-2, which was fixed width.  UTF-16 can encode all the code points in Unicode because it is varying width.

The distinction I was trying to make is between
(Unicode) code points and (UTF-16) code units.

A code point can be encoded in a variable number of code units.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 20 Aug 2024 14:11:04 +0100, chrisq wrote:

Quite a bit of unix code that uses such techniques, as does vms with descriptors, if that'a the right name for it.

Umm, you might be thinking of item lists?

Wonderful things ... you could tell the terminal driver was getting
complex in VMS V4, I think it was, when they introduced QIO calls done
with item lists ...

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 20 Aug 2024 10:15:03 -0400, Arne Vajhøj wrote:

And there are some horror decisions. The compiler API comes to my mind -
it takes 200 lines to do what you can do in 5 lines in C#.

Java is full of stuff like that.

The java.io package may seem a bit complex, but it makes perfect sense
when you learn the structure.

Until you try to include niceties like select/poll. Then you get into a
whole mess of extra classes/methods.

I suppose, given its origin in the 1990s, the Java designers thought all nonblocking I/O should be handled through threads ...

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 9:18 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 10:15:03 -0400, Arne Vajhøj wrote:

The java.io package may seem a bit complex, but it makes perfect sense
when you learn the structure.

Until you try to include niceties like select/poll. Then you get into a
whole mess of extra classes/methods.

I suppose, given its origin in the 1990s, the Java designers thought all nonblocking I/O should be handled through threads ...

That stuff is not in java.io but in java.nio and added
in Java 1.4 (2002).

Not that many classes, but a totally different set of classes.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 9:25 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Yes. But that is returning a single value - just a composite value.

It works fine, but it requires a custom type.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 9:19 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 14:11:04 +0100, chrisq wrote:

Quite a bit of unix code that uses such techniques, as does vms with
descriptors, if that'a the right name for it.

Umm, you might be thinking of item lists?

Wonderful things ... you could tell the terminal driver was getting
complex in VMS V4, I think it was, when they introduced QIO calls done
with item lists ...

Where are SYS$QIO(W) using item lists?

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 20 Aug 2024 21:31:33 -0400, Arne Vajhøj wrote:

On 8/20/2024 9:19 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 14:11:04 +0100, chrisq wrote:

Quite a bit of unix code that uses such techniques, as does vms with
descriptors, if that'a the right name for it.

Umm, you might be thinking of item lists?

Wonderful things ... you could tell the terminal driver was getting
complex in VMS V4, I think it was, when they introduced QIO calls done
with item lists ...

Where are SYS$QIO(W) using item lists?

OpenVMS v8.4 I/O User’s Reference, section 5.3.1.3, “Itemlist Read Operations”.

<https://support.hpe.com/hpsc/doc/public/display?docId=emr_na-c04622349>

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 20 Aug 2024 21:29:13 -0400, Arne Vajhøj wrote:

On 8/20/2024 9:18 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 10:15:03 -0400, Arne Vajhøj wrote:

The java.io package may seem a bit complex, but it makes perfect sense
when you learn the structure.

Until you try to include niceties like select/poll. Then you get into a
whole mess of extra classes/methods.

I suppose, given its origin in the 1990s, the Java designers thought
all nonblocking I/O should be handled through threads ...

That stuff is not in java.io but in java.nio and added in Java 1.4
(2002).

Not that many classes, but a totally different set of classes.

Even worse.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 20 Aug 2024 21:35:44 -0400, Arne Vajhøj wrote:

On 8/20/2024 9:25 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Yes. But that is returning a single value - just a composite value.

The distinction between “multiple value” versus “single composite value”
is an artificial one specific to languages like Lisp. Python, for example,
is quite happy with constructs like

a, b = struct.unpack("hh", b"\x00\x00\xff\xff")

And I think also JavaScript works that way.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 9:51 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 21:35:44 -0400, Arne Vajhøj wrote:

On 8/20/2024 9:25 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Yes. But that is returning a single value - just a composite value.

The distinction between “multiple value” versus “single composite value”
is an artificial one specific to languages like Lisp. Python, for example,
is quite happy with constructs like

a, b = struct.unpack("hh", b"\x00\x00\xff\xff")

If the language supports tuples or has a generic tuple class
or an other way to avoid creating a type for each
type combo of return values, then it is pretty much the same.

But with languages like C and Fortran there is a big difference.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/15/2024 1:58 AM, Arne Vajhøj wrote:

On 8/14/2024 7:47 PM, Lawrence D'Oliveiro wrote:

On Wed, 14 Aug 2024 14:33:27 -0400, Arne Vajhøj wrote:

And it has different size of long and pointers.

If you wanted an integer type that is compatible with pointers, that was
always intptr_t and uintptr_t, surely

I am not being particular clear.

I am not saying that:

default sizeof long C++ x64 <> default sizeof pointer C++ x64

I am saying that:

default sizeof long C++ x64 <> default sizeof long C++ Itanium & Alpha default sizeof pointer C++ x64 <> default sizeof pointer C++ Itanium &
Alpha

and later:

default sizeof long C++ x64 <> default sizeof long C x64
default sizeof pointer C++ x64 <> default sizeof pointer C x64

Arne

Yes, all good points. The size_t and offset_t = 32-bits and ptrdiff_t = 32-bits on Alpha/Itanium started the mess years ago.

Personally, I would have kept all the defaults the same as Itanium but
got "convinced" to go wider. The first attempt was ONLY 64-bit pointers
on x86 with C++ but things like those pesky descriptors and itemlists
got in the way.

I did suggest an LP64, ILP32, etc qualifier but mostly got blank stares
from other engineers as "too nerdy"

long == 64-bits has caused us to make changes as prior header writers
assumed that long was 32-bits. They should have all followed Arne's
advice and used int32_t and int64_t when specifying their ABIs.

I'll can take some ownership on the changes, but I suffered with years
of "John, why is size_t 32-bits? Why does subtracting two 64-bit
pointers only give me a 32-bit result?"

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 4:21 AM, John Reagan wrote:

Yes, all good points.  The size_t and offset_t = 32-bits and ptrdiff_t = 32-bits on Alpha/Itanium started the mess years ago.

Personally, I would have kept all the defaults the same as Itanium but
got "convinced" to go wider.  The first attempt was ONLY 64-bit pointers
on x86 with C++ but things like those pesky descriptors and itemlists
got in the way.

I did suggest an LP64, ILP32, etc qualifier but mostly got blank stares
from other engineers as "too nerdy"

long == 64-bits has caused us to make changes as prior header writers
assumed that long was 32-bits.  They should have all followed Arne's
advice and used int32_t and int64_t when specifying their ABIs.

I'll can take some ownership on the changes, but I suffered with years
of "John, why is size_t 32-bits?  Why does subtracting two 64-bit
pointers only give me a 32-bit result?"

Hindsight is always easy.

:-)

Knowing what we know now then I think that:
* an option to change size of long
* having CXX command default to 32 bit pointers and 32 bit long
with two options to go 64 bit (pointer do already have it)
* having clang command go more pure 64 bit
may have been the right path.

But too late.

Well - not too late for /LONG=32 and /LONG=64 !

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20, Arne Vajh�j <arne@vajhoej.dk> wrote:

On 8/20/2024 1:38 PM, Simon Clubley wrote:

You forgot about InputStreamReader() to turn an InputStream into a Reader. :-)

There are InputStreamReader to convert from InputStream to Reader and OutputStreamWriter to convert from OutputStream to Writer.

And they are actually used, because some API's has classes that only has getInputStream()/getOutputStream() methods and not
getReader()/getWriter() methods.

All follow the model.

After all, why miss the opportunity to have two parallel sets of APIs
(byte versus character) instead of just the one API ? :-)

Goodness knows why they didn't just add something like String's getBytes() >> method to the character APIs or add character support to the byte APIs...

Because InputStream/OutputStream and Reader/Writer are fundamentally different.

I may not have stated that clearly enough.

The character model is built in top of a byte model, with character-specific knowledge in the character classes.

The traditional Java way to add this additional functionality is to extend
a class in a subclass and implement the additional functionality in the subclass.

I am having a hard time seeing why they didn't just extend the byte I/O
classes in this way to implement additional character functionality so
that both character and byte I/O directly uses an InputStream (and likewise
for an OutputStream). There should be no need for a character-specific
Reader concept or an InputStreamReader() converter.

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

Chris

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 8:18 AM, Simon Clubley wrote:

On 2024-08-20, Arne Vajhøj <arne@vajhoej.dk> wrote:

On 8/20/2024 1:38 PM, Simon Clubley wrote:

After all, why miss the opportunity to have two parallel sets of APIs
(byte versus character) instead of just the one API ? :-)

Goodness knows why they didn't just add something like String's getBytes() >>> method to the character APIs or add character support to the byte APIs... >>

Because InputStream/OutputStream and Reader/Writer are fundamentally
different.

I may not have stated that clearly enough.

The character model is built in top of a byte model, with character-specific knowledge in the character classes.

The traditional Java way to add this additional functionality is to extend
a class in a subclass and implement the additional functionality in the subclass.

Reader/Writer does not extend InputStream/OutputStream. They do not
add functionality - they provide different functionality.

They may use/encapsulate an InputStream/OutputStream, but that is implementation and invisible to the public API.

I am having a hard time seeing why they didn't just extend the byte I/O classes in this way to implement additional character functionality so
that both character and byte I/O directly uses an InputStream (and likewise for an OutputStream). There should be no need for a character-specific
Reader concept or an InputStreamReader() converter.

Mixing byte IO and character IO can be very dangerous (at least
for encodings where characters can be multiple bytes).

Having such a mixed API would create lots of problems for users
actually mixing.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not
a struct.

It looks like VSI Fortran cannot return a structure as function
result, but VSI Pascal can return a record as function result.

And it is returned as a pointer argument under the hood.

$ type s.pas
module s;

type
iiituple = record
a : integer;
b : integer;
c : integer;
end;

[global]
function get : iiituple;

var
res : iiituple;

begin
res.a := 123;
res.b := 456;
res.c := 789;
get := res;
end;

end.
$ pas s
$ type m.c
#include <stdio.h>

struct iiituple
{
int a;
int b;
int c;
};

void get(struct iiituple *res);

int main()
{
struct iiituple res;
get(&res);
printf("%d %d %d\n", res.a, res.b, res.c);
return 0;
}
$ cc m
$ link m + s
$ run m
123 456 789

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 2:13 PM, Arne Vajhøj wrote:

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not
a struct.

It looks like VSI Fortran cannot return a structure as function
result, but VSI Pascal can return a record as function result.

And it is returned as a pointer argument under the hood.

Unless it fits in a register, then it is returned
as a true function result:

$ type s2.pas
module s2;

type
iituple = record
a : integer;
b : integer;
end;

[global]
function get : iituple;

var
res : iituple;

begin
res.a := 123;
res.b := 456;
get := res;
end;

end.
$ pas s2
$ type m2.c
#include <stdio.h>

struct iituple
{
int a;
int b;
};

struct iituple get();

int main()
{
struct iituple res = get();
printf("%d %d\n", res.a, res.b);
return 0;
}
$ cc m2
$ link m2 + s2
$ run m2
123 456

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Wed, 21 Aug 2024 13:26:12 +0100, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer to it. Much tidier.

But not so convenient for functional programming style.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 2:13 PM, Arne Vajhøj wrote:

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not
a struct.

It looks like VSI Fortran cannot return a structure as function
result, but VSI Pascal can return a record as function result.

And it is returned as a pointer argument under the hood.

$ type s.pas
module s;

type
   iiituple = record
                 a : integer;
                 b : integer;
                 c : integer;
             end;

[global]
function get : iiituple;

void get(struct iiituple *res);

int main()
{
    struct iiituple res;
    get(&res);

Note that C follow the same convention, so:

struct iiituple get();

int main()
{
struct iiituple res = get();

works just as well.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

Simon.

Is there any real difference between your practice, and including a completion status parameter in the function call?

--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 9:35 PM, Arne Vajhøj wrote:

On 8/20/2024 9:25 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Yes. But that is returning a single value - just a composite value.

It works fine, but it requires a custom type.

Arne

Hmmm ... what is wrong with a "custom type", or what I'd call a structure?

--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 9:51 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 21:35:44 -0400, Arne Vajhøj wrote:

On 8/20/2024 9:25 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Yes. But that is returning a single value - just a composite value.

The distinction between “multiple value” versus “single composite value”
is an artificial one specific to languages like Lisp. Python, for example,
is quite happy with constructs like

a, b = struct.unpack("hh", b"\x00\x00\xff\xff")

That's kind of ugly, isn't it?


--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 1:34 PM, bill wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return
multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

bill

Would that not be rather clear with adequate comments about what is being done?

--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 10:16 PM, Dave Froble wrote:

On 8/20/2024 9:35 PM, Arne Vajhøj wrote:

On 8/20/2024 9:25 PM, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Yes. But that is returning a single value - just a composite value.

It works fine, but it requires a custom type.

Hmmm ...  what is wrong with a "custom type", or what I'd call a structure?

It adds code. Unnecessary code.

It is a types added not because they exist in the business domain, but
because there is a need to return a bundle of values.

And the number of possible bundle types is huge.

Multiple return values, generic tuple classes, real tuple etc. avoid
all that.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 1:47 PM, Simon Clubley wrote:

On 2024-08-20, bill <bill.gunshannon@gmail.com> wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return >>> multiple values from a function call so you can return both a status and >>> the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

Huh ? Well that shows you haven't done this kind of thing. :-)

If you are talking about PHP, you construct an associative array
in the return statement of the function and then access the keys
in the caller. Very clean.

If you are talking about some future thing based on C, you simply
extend the function prototype to include a list of return types
instead of the single type it is at the moment and you just return
the list in the function's return statement.

$ set response/mode=good_natured

Or are associative arrays and other higher-level data structures an alien concept to you ? :-)

Uh ... sometimes ...

:-)


--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/2024 10:22 PM, Dave Froble wrote:

On 8/20/2024 1:47 PM, Simon Clubley wrote:

$ set response/mode=good_natured

Or are associative arrays and other higher-level data structures an alien
concept to you ? :-)

Uh ... sometimes ...

:-)

You did do a little VB6/VB.NET many years ago?

PHP associative arrays = VB6/VB.NET dictionaries

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-21, Dave Froble <davef@tsoft-inc.com> wrote:

On 8/20/2024 1:34 PM, bill wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a
complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return >>> multiple values from a function call so you can return both a status and >>> the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

Would that not be rather clear with adequate comments about what is being done?

Look at the example Arne posted. Very clean and very easy to understand
without having to use comments (and I am actually a fan of the liberal
use of comments. :-) ).

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-21, Dave Froble <davef@tsoft-inc.com> wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

One thing I wish was available in all languages is the ability to return
multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

Is there any real difference between your practice, and including a completion
status parameter in the function call?

Yes. It's conceptually not a parameter. It's a result status that determines
if the result returned is valid. Returning multiple values is also a lot cleaner and much more generic than having to add a parameter for each out
value to be returned.

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/22/2024 1:39 PM, Simon Clubley wrote:

On 2024-08-21, Dave Froble <davef@tsoft-inc.com> wrote:

On 8/20/2024 1:34 PM, bill wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

In languages with dynamic associative arrays (such as PHP), I simulate >>>> this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

Would that not be rather clear with adequate comments about what is being done?

Look at the example Arne posted. Very clean and very easy to understand without having to use comments (and I am actually a fan of the liberal
use of comments. :-) ).

The same example in older VB.NET:

Imports System
Imports System.Collections.Generic

Namespace MR
Public Class Program
Public Shared Function FourOps(a As Double, b As Double) As IDictionary(Of String, Double)
Dim res As New Dictionary(Of String, Double)()
res("plus") = a + b
res("minus") = a - b
res("multiply") = a * b
res("divide") = a / b
Return res
End Function
Public Shared Sub Main(args As String())
Dim a As Double = 3.0
Dim b As Double = 2.0
Dim res As IDictionary(Of String, Double) = FourOps(a, b)
Console.WriteLine("{0} + {1} = {2}", a, b, res("plus"))
Console.WriteLine("{0} - {1} = {2}", a, b, res("minus"))
Console.WriteLine("{0} * {1} = {2}", a, b, res("multiply"))
Console.WriteLine("{0} / {1} = {2}", a, b, res("divide"))
Console.ReadKey()
End Sub
End Class
End Namespace

In newer VB.NET it looks like:

Imports System
Imports System.Collections.Generic

Namespace MR
Public Class Program
Public Shared Function FourOps(a As Double, b As Double) As IDictionary(Of String, Double)
Return New Dictionary(Of String, Double)() From { _
{"plus", a + b}, _
{"minus", a - b}, _
{"multiply", a * b}, _
{"divide", a / b} _
}
End Function
Public Shared Sub Main(args As String())
Dim a As Double = 3.0
Dim b As Double = 2.0
Dim res As IDictionary(Of String, Double) = FourOps(a, b)
Console.WriteLine("{0} + {1} = {2}", a, b, res("plus"))
Console.WriteLine("{0} - {1} = {2}", a, b, res("minus"))
Console.WriteLine("{0} * {1} = {2}", a, b, res("multiply"))
Console.WriteLine("{0} / {1} = {2}", a, b, res("divide"))
Console.ReadKey()
End Sub
End Class
End Namespace

But I suspect that David as a Basic connoisseur consider that dictionary initializer syntax copied directly from C# an abomination - curly
brackets is not real Basic.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/21/24 19:13, Arne Vajhøj wrote:

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not

Problem is that of you return a pointer, that suggests that the
struct has been declared static inside the called function. That
would be a fail for reentant code that might be called from
elsewhere, say, from an interrupt handler, or another thread.
The struct would typically be on the stack or heap, and would
disappear on return from the call, making the return value
invalid. Ideally, in a multitasking os, all code should be
designed to be fully reentrant, to make it safe in all
situations.

Chris

a struct.

It looks like VSI Fortran cannot return a structure as function
result, but VSI Pascal can return a record as function result.

And it is returned as a pointer argument under the hood.

$ type s.pas
module s;

type
   iiituple = record
                 a : integer;
                 b : integer;
                 c : integer;
             end;

[global]
function get : iiituple;

var
   res : iiituple;

begin
   res.a := 123;
   res.b := 456;
   res.c := 789;
   get := res;
end;

end.
$ pas s
$ type m.c
#include <stdio.h>

struct iiituple
{
    int a;
    int b;
    int c;
};

void get(struct iiituple *res);

int main()
{
    struct iiituple res;
    get(&res);
    printf("%d %d %d\n", res.a, res.b, res.c);
    return 0;
}
$ cc m
$ link m + s
$ run m
123 456 789

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/22/2024 7:12 PM, chrisq wrote:

On 8/21/24 19:13, Arne Vajhøj wrote:

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not

Problem is that of you return a pointer, that suggests that the
struct has been declared static inside the called function. That
would be a fail for reentant code that might be called from
elsewhere, say, from an interrupt handler, or another thread.
The struct would  typically be on the stack or heap, and would
disappear on return from the call, making the return value
invalid. Ideally, in a multitasking os, all code should be
designed to be fully reentrant, to make it safe in all
situations.

My assumption would be that the struct was malloc'ed in
the function.

That obvious also has its problem. One can write in
72 point bold red blinking font that it is the callers
responsibility to call free and it will still be
forgotten in some cases.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 00:12:18 +0100, chrisq wrote:

Problem is that of you return a pointer, that suggests that the struct
has been declared static inside the called function. That would be a
fail for reentant code that might be called from elsewhere, say, from an interrupt handler, or another thread. The struct would typically be on
the stack or heap, and would disappear on return from the call, making
the return value invalid. Ideally, in a multitasking os, all code should
be designed to be fully reentrant, to make it safe in all situations.

One notorious POSIX-related example is the crypt(3) function <https://manpages.debian.org/3/crypt.3.en.html>.

I was helping a client reinstall some old proprietary app that had
been running on an ancient machine that had crashed. For the new
setup, we thought we’d try a slightly less ancient version of Debian
(I think the original machine had been running Debian 4). But logins
wouldn’t work. Even worse, the errors didn’t make sense: instead of
saying that the username or password was invalid, it was reporting
something crazy like errors to do with SELinux or something (we
weren’t using SELinux).

Finally, I made a wild, desperate guess: the code was copying the
result from the crypt call into a fixed-size buffer, which wasn’t big
enough to hold the hash for newer password algorithms. This was
leading to a buffer overflow when hashing perfectly valid passwords,
which in turn was corrupting some data elsewhere and triggering the
spurious errors.

So I had to try and find an older algorithm that the system still
supported, which would bring the hash size within range, and use that
hash for the relevant passwords.

And that worked.

You’ll see from the above man page that POSIX has no official solution
to this problem: there are calls available in Linux (courtesy of the
Openwall project) that will use dynamically-allocated buffers; but of
course they will likely not be available on other systems that claim
to be POSIX-compatible.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/22/2024 1:39 PM, Simon Clubley wrote:

On 2024-08-21, Dave Froble <davef@tsoft-inc.com> wrote:

On 8/20/2024 1:34 PM, bill wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

On 2024-08-20, chrisq <devzero@nospam.com> wrote:

I guess another complication is that some functions return
-1, which implies a signed variable. To fix all that would require a >>>>> complete rewrite of the library and probably most of the os and
applications as well, so it will never happen. Just have to write
unsigned equivalents, or slip functions with casts, but it's a lot
of additional work.

One thing I wish was available in all languages is the ability to return >>>> multiple values from a function call so you can return both a status and >>>> the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate >>>> this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

And probably much harder to understand in anything but the most
trivial usage.

Would that not be rather clear with adequate comments about what is being done?

Look at the example Arne posted. Very clean and very easy to understand without having to use comments (and I am actually a fan of the liberal
use of comments. :-) ).

Simon.

I find it rather difficult to determine WHY something is being done, just from the code.

--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Thu, 22 Aug 2024 19:21:07 -0400
Arne Vajh�j <arne@vajhoej.dk> wrote:

On 8/22/2024 7:12 PM, chrisq wrote:

On 8/21/24 19:13, Arne Vajh�j wrote:

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajh�j wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not

Problem is that of you return a pointer, that suggests that the
struct has been declared static inside the called function. That
would be a fail for reentant code that might be called from
elsewhere, say, from an interrupt handler, or another thread.
The struct would� typically be on the stack or heap, and would
disappear on return from the call, making the return value
invalid. Ideally, in a multitasking os, all code should be
designed to be fully reentrant, to make it safe in all
situations.

My assumption would be that the struct was malloc'ed in
the function.

That obvious also has its problem. One can write in
72 point bold red blinking font that it is the callers
responsibility to call free and it will still be
forgotten in some cases.

Arne

Just admit that you was wrong and that the best option in C is the same
as in many other languages - return the structure itself.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/2024 4:14 AM, Michael S wrote:

On Thu, 22 Aug 2024 19:21:07 -0400
Arne Vajhøj <arne@vajhoej.dk> wrote:

On 8/22/2024 7:12 PM, chrisq wrote:

On 8/21/24 19:13, Arne Vajhøj wrote:

On 8/21/2024 8:26 AM, chrisq wrote:

On 8/21/24 02:25, Lawrence D'Oliveiro wrote:

On Tue, 20 Aug 2024 09:47:36 -0400, Arne Vajhøj wrote:

Few languages support multiple return values.

Even in C and Fortran, a function can return a struct.

Better to declare the struct externally, then pass a pointer
to it. Much tidier.

In C one should definitely return a pointer to struct and not

Problem is that of you return a pointer, that suggests that the
struct has been declared static inside the called function. That
would be a fail for reentant code that might be called from
elsewhere, say, from an interrupt handler, or another thread.
The struct would  typically be on the stack or heap, and would
disappear on return from the call, making the return value
invalid. Ideally, in a multitasking os, all code should be
designed to be fully reentrant, to make it safe in all
situations.

My assumption would be that the struct was malloc'ed in
the function.

That obvious also has its problem. One can write in
72 point bold red blinking font that it is the callers
responsibility to call free and it will still be
forgotten in some cases.

Just admit that you was wrong

I am often wrong so that is no big deal.

and that the best option in C is the same
as in many other languages - return the structure itself.

Returning the struct itself result in a copy of the struct. The
time to do the copy is probably insignificant though.

Languages like (VMS) Pascal and (VMS) Basic do indeed return
the record and make the copy.

But newer languages (on VMS that would mostly be Java and other
JVM languages but other platforms have more languages in this
category) would dynamic allocate, return a reference/pointer
and not worry about free because they use GC.

I am not quite convinced yet.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20 12:04:13 +0000, Simon Clubley said:

On 2024-08-19, Arne Vajh�j <arne@vajhoej.dk> wrote:

Or if the application is passing pointers between code compiled with
different languages/compilers/compiler settings.

Of course, that is what ABIs are _supposed_ to be for...

Or Swift and C/C++, or Zig and C/C++, which are intended to interoperate.


--
Pure Personal Opinion | HoffmanLabs LLC

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20 12:36:43 +0000, chrisq said:

For work here, all functions that return data have a parameter that
limits the byte count. Usually pass a pointer to a buffer, with the
size parameter equal to or less than the buffer size. Some C library functions are just not safe to use in that respect.

Local spun string copy and other functions use the same sort of size limiting.

That, or preferably not transferring the data at all.

Whether that happens with page table modifications, or shared buffers.

Parts of OpenVMS are just chock full of buffer copies. (q.v. previous discussions of the buffer overhead incurred with faster network
connections. From discussions here most of a decade ago: https://lwn.net/Articles/629155/ )

And OpenVMS and apps have not-particularly-reentrant and not-particularly-performant code that calls some system service to
first size the data and then allocate the buffer and then calls again
to return the data. (Which is more glue code, as compared with
returning an object containing the data, too. OpenVMS itself doesn't particularly have that concept, however.)

OpenVMS has ~no concept of languages, either. Yeah, the C abd C++ I18N
giblets, Java and its own little world, maybe using the existing and
older ICU or maybe you ported a newer ICU, and the deprecated Terminal
Fallback Facility (TFF) and National (Replacement) Character Set (NCS) giblets, sure. All of which make things more interesting for apps that
want or need to deal with the UTF-8 and post-ASCII world.




--
Pure Personal Opinion | HoffmanLabs LLC

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/2024 9:02 AM, Arne Vajhøj wrote:

On 8/23/2024 4:14 AM, Michael S wrote:

                    and that the best option in C is the same
as in many other languages - return the structure itself.

Returning the struct itself result in a copy of the struct. The
time to do the copy is probably insignificant though.

I am not quite convinced yet.

It seems like one frequently provided reason for using pointer
is ABI compatibility.

I don't know about that. It is not that easy to create the
problem.

But it is possible:

$ type i.h
struct data
{
int a;
int b;
#ifdef NEWVERSION
int c;
#endif
};

$ type s1.c
#include "i.h"

struct data get()
{
struct data res;
res.a = 123;
res.b = 456;
#ifdef NEWVERSION
res.c = 0x7FFFFFFF;
#endif
return res;
}

$ type m1.c
#include <stdio.h>

#include "i.h"

struct data get();

int main()
{
struct data res = get();
printf("%d %d\n", res.a, res.b);
return 0;
}
$ type s2.c
#include <stdlib.h>

#include "i.h"

struct data *get()
{
struct data *res = malloc(sizeof(struct data));
res->a = 123;
res->b = 456;
#ifdef NEWVERSION
res->c = 0x7FFFFFFF;
#endif
return res;
}

$ type m2.c
#include <stdio.h>
#include <stdlib.h>

#include "i.h"

struct data *get();

int main()
{
struct data *res = get();
printf("%d %d\n", res->a, res->b);
free(res);
return 0;
}
$ cc s1
$ cc m1
$ link m1 + s1
$ run m1
123 456
$ cc/define="NEWVERSION" s1
$ link m1 + s1
$ run m1
99108 0
$ cc s2
$ cc m2
$ link m2 + s2
$ run m2
123 456
$ cc/define="NEWVERSION" s2
$ link m2 + s2
$ run m2
123 456

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 11:33:41 -0400, Stephen Hoffman wrote:

On 2024-08-20 12:04:13 +0000, Simon Clubley said:

On 2024-08-19, Arne Vajhøj <arne@vajhoej.dk> wrote:

Or if the application is passing pointers between code compiled with
different languages/compilers/compiler settings.

Of course, that is what ABIs are _supposed_ to be for...

Or Swift and C/C++, or Zig and C/C++, which are intended to
interoperate.

There is a generic library called libffi to support this sort of thing for
any language. For example, Python’s ctypes module is built on this.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 11:32:03 -0400, Stephen Hoffman wrote:

And OpenVMS and apps have not-particularly-reentrant and not-particularly-performant code that calls some system service to first
size the data and then allocate the buffer and then calls again to
return the data.

I can mention examples from the Linux world, too. How else would you do
it?

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/2024 11:32 AM, Stephen Hoffman wrote:

OpenVMS has ~no concept of languages, either. Yeah, the C abd C++ I18N giblets, Java and its own little world, maybe using the existing and
older ICU or maybe you ported a newer ICU, and the deprecated Terminal Fallback Facility (TFF) and National (Replacement)  Character Set (NCS) giblets, sure. All of which make things more interesting for apps that
want or need to deal with the UTF-8 and post-ASCII world.

Regarding UTF-8 support, then my take is that:

UTF-8 in file names, in usernames, in logicals, in identifiers and in programs/scripts: not really needed.

UTF-8 in file content and in databases: very much needed.

And support for the latter fall in 3 groups:
* JVM languages (Java, Groovy etc.) and I believe Python - does
support unicode and can read/write using any encoding including UTF-8
* C, C++, PHP - developer keeps track of what encoding a byte
sequence is in but possible to explicit convert encodings
(C/C++ has wchar_t but it is neither much used nor UTF-8 friendly
AFAIK)
* the traditional native languages - very little support except what
can be done by calling C functions

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 19:34:18 -0400, Arne Vajhøj wrote:

UTF-8 in file names, in usernames, in logicals, in identifiers and in programs/scripts: not really needed.

I would say these are needed.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/2024 7:41 PM, Lawrence D'Oliveiro wrote:

On Fri, 23 Aug 2024 19:34:18 -0400, Arne Vajhøj wrote:

UTF-8 in file names, in usernames, in logicals, in identifiers and in
programs/scripts: not really needed.

I would say these are needed.

I can live without the ability to create:

blåbærsyltetøj.txt

:-)

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/24 6:34 PM, Arne Vajhøj wrote:

On 8/23/2024 11:32 AM, Stephen Hoffman wrote:

OpenVMS has ~no concept of languages, either. Yeah, the C abd C++ I18N
giblets, Java and its own little world, maybe using the existing and
older ICU or maybe you ported a newer ICU, and the deprecated Terminal
Fallback Facility (TFF) and National (Replacement)  Character Set
(NCS) giblets, sure. All of which make things more interesting for
apps that want or need to deal with the UTF-8 and post-ASCII world.

Regarding UTF-8 support, then  my take is that:

UTF-8 in file names, in usernames, in logicals, in identifiers and in programs/scripts: not really needed.

UTF-8 in file content and in databases: very much needed.

And support for the latter fall in 3 groups:
* JVM languages (Java, Groovy etc.) and I believe Python - does
  support unicode and can read/write using any encoding including UTF-8

Perl has excellent Unicode support. It even comes with piconv, an iconv application implemented in Perl that can do conversions.

I'm told Unicode support in Python 2.x was pretty shaky but Python 3 is
a lot better.

* C, C++, PHP - developer keeps track of what encoding a byte
  sequence is in but possible to explicit convert encodings
  (C/C++ has wchar_t but it is neither much used nor UTF-8 friendly
  AFAIK)
* the traditional native languages - very little support except what
  can be done by calling C functions

and what can be done calling C functions is limited by the data in SYS$I18N_ICONV, which is about 20 years out of date. There have been a
dozen major releases of the Unicode standard in that time.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 24/08/2024 00:59, Arne Vajhøj wrote:

On 8/23/2024 7:41 PM, Lawrence D'Oliveiro wrote:

On Fri, 23 Aug 2024 19:34:18 -0400, Arne Vajhøj wrote:

UTF-8 in file names, in usernames, in logicals, in identifiers and in
programs/scripts: not really needed.

I would say these are needed.

I can live without the ability to create:

blåbærsyltetøj.txt

:-)

Arne

Is that Norwegian, or Swedish?
:-)

--
Chris

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/2024 8:52 PM, Chris Townley wrote:

On 24/08/2024 00:59, Arne Vajhøj wrote:

On 8/23/2024 7:41 PM, Lawrence D'Oliveiro wrote:

On Fri, 23 Aug 2024 19:34:18 -0400, Arne Vajhøj wrote:

UTF-8 in file names, in usernames, in logicals, in identifiers and in
programs/scripts: not really needed.

I would say these are needed.

I can live without the ability to create:

blåbærsyltetøj.txt

:-)

Is that Norwegian, or Swedish?
:-)

Danish.

:-)

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 19:59:26 -0400, Arne Vajhøj wrote:

On 8/23/2024 7:41 PM, Lawrence D'Oliveiro wrote:

On Fri, 23 Aug 2024 19:34:18 -0400, Arne Vajhøj wrote:

UTF-8 in file names, in usernames, in logicals, in identifiers and in
programs/scripts: not really needed.

I would say these are needed.

I can live without the ability to create:

blåbærsyltetøj.txt

Even restricting oneself to English, I would say this betrays a certain naïveté ...

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/23/2024 10:20 PM, Lawrence D'Oliveiro wrote:

On Fri, 23 Aug 2024 20:10:44 -0500, Craig A. Berry wrote:

I'm told Unicode support in Python 2.x was pretty shaky but Python 3 is
a lot better.

That was the primary motivation behind the Python 2→3 transition.

Unicode was also the primary motivation behind PHP 5->6. But it
got cancelled and PHP did 5->7 without going unicode.

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 22:23:18 -0400, Arne Vajhøj wrote:

Unicode was also the primary motivation behind PHP 5->6. But it got
cancelled and PHP did 5->7 without going unicode.

To be fair, that little peccadillo does get lost in the avalanche of other reasons why PHP is bloody awful ...

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 23 Aug 2024 20:10:44 -0500, Craig A. Berry wrote:

I'm told Unicode support in Python 2.x was pretty shaky but Python 3 is
a lot better.

That was the primary motivation behind the Python 2→3 transition.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Fri, 2024-08-23 at 19:34 -0400, Arne Vajhøj wrote:

UTF-8 in file names, in usernames, in logicals, in identifiers and in programs/scripts: not really needed.

Everything needs to be utf8 aware. Not just text files. A good start
would be to add utf8 aware functionality to VMS.
--
Tactical Nuclear Kittens

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Sat, 2024-08-24 at 03:07 +0000, Lawrence D'Oliveiro wrote:

On Fri, 23 Aug 2024 22:23:18 -0400, Arne Vajhøj wrote:

Unicode was also the primary motivation behind PHP 5->6. But it got cancelled and PHP did 5->7 without going unicode.

To be fair, that little peccadillo does get lost in the avalanche of
other reasons why PHP is bloody awful ...

I'll drink to that.
--
Tactical Nuclear Kittens

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/20/2024 8:36 AM, Simon Clubley wrote:

One thing I wish was available in all languages is the ability to return
multiple values from a function call so you can return both a status and
the value(s) in one assignment. Ie: "a, b, c = demo_function(param1,
param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

On 8/20/2024 6:47 AM, Arne Vajhøj wrote:

Few languages support multiple return values.

And a few other languages support tuples with named fields
or anonymous classes with named properties, which is almost as good.

And almost all newer high level languages support
map/dictionary/associative array.

This is one of the many reasons I like PERL.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Sat, 24 Aug 2024 14:50:51 -0700, Lars Poulsen wrote:

This is one of the many reasons I like PERL.

Perl completely changed the game with its combination of good regular expressions, good string handling, and good data structures as well. I
credit Perl with popularizing the whole concept of regular expressions:
before that, they were considered something esoteric.

For example, BASIC was considered to have good string-handling facilities.
But it never had good regular expressions or hash tables; and the coming
of Perl made BASIC look quite old-fashioned indeed.

On the other hand, Perl has a lot of subtleties to it that I never quite understood. When I started learning Python, I found that was just as
powerful, but so much easier to understand.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/24/24 4:50 PM, Lars Poulsen wrote:

On 8/20/2024 8:36 AM, Simon Clubley wrote:

One thing I wish was available in all languages is the ability to return >>> multiple values from a function call so you can return both a status and >>> the value(s) in one assignment. Ie: "a, b, c = demo_function(param1,
param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

On 8/20/2024 6:47 AM, Arne Vajhøj wrote:

Few languages support multiple return values.

And a few other languages support tuples with named fields
or anonymous classes with named properties, which is almost as good.

And almost all newer high level languages support
map/dictionary/associative array.

This is one of the many reasons I like PERL.

And it can also return multiple values from a function, which was the
start of this branch of the discussion:

$ perl -e 'sub a {return (1,2);} my @x=a(); for my $x (@x) {print
qq/$x\n/;}'
1
2

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/24/2024 8:37 PM, Lawrence D'Oliveiro wrote:

On Sat, 24 Aug 2024 20:21:12 -0400, Arne Vajhøj wrote:

On 8/24/2024 6:38 PM, Lawrence D'Oliveiro wrote:

On Sat, 24 Aug 2024 14:50:51 -0700, Lars Poulsen wrote:

This is one of the many reasons I like PERL.

Perl completely changed the game with its combination of good regular
expressions, good string handling, and good data structures as well. I
credit Perl with popularizing the whole concept of regular expressions:
before that, they were considered something esoteric.

For example, BASIC was considered to have good string-handling
facilities. But it never had good regular expressions or hash tables;
and the coming of Perl made BASIC look quite old-fashioned indeed.

80's and early 90's Basic flavors (and that include VMS Basic)
did not have those.

But later MS Basic flavors did have them:
* VB/VBS/VBA has RegExp class and Scripting.Dictionary
COM class
* VB.NET has System.Text.RegularExpressions.Regex and
System.Collections.Hashtable (later replaced by
System.Collections.Generic.Dictionary)

Did you really have to type those longwinded names that just to access
them?

In Python, it’s just “import re”.

VB.NET like most modern languages use hierarchical
packages/namespaces. That tend to make the names longer.

But else it is pretty similar.

Somewhere at the top:

Import System.Collections.Generic
Import System.Text.RegularExpressions

and then:

Dim d As New Dictionary(Of X,Y)()
Dim r As New Regex(someregexexpr)

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Sat, 24 Aug 2024 17:54:17 -0500, Craig A. Berry wrote:

And it can also return multiple values from a function ...

Why is that better than destructuring assignment?

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Sat, 24 Aug 2024 20:21:12 -0400, Arne Vajhøj wrote:

On 8/24/2024 6:38 PM, Lawrence D'Oliveiro wrote:

On Sat, 24 Aug 2024 14:50:51 -0700, Lars Poulsen wrote:

This is one of the many reasons I like PERL.

Perl completely changed the game with its combination of good regular
expressions, good string handling, and good data structures as well. I
credit Perl with popularizing the whole concept of regular expressions:
before that, they were considered something esoteric.

For example, BASIC was considered to have good string-handling
facilities. But it never had good regular expressions or hash tables;
and the coming of Perl made BASIC look quite old-fashioned indeed.

80's and early 90's Basic flavors (and that include VMS Basic)
did not have those.

But later MS Basic flavors did have them:
* VB/VBS/VBA has RegExp class and Scripting.Dictionary
COM class
* VB.NET has System.Text.RegularExpressions.Regex and
System.Collections.Hashtable (later replaced by
System.Collections.Generic.Dictionary)

Did you really have to type those longwinded names that just to access
them?

In Python, it’s just “import re”.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/24/2024 6:38 PM, Lawrence D'Oliveiro wrote:

On Sat, 24 Aug 2024 14:50:51 -0700, Lars Poulsen wrote:

This is one of the many reasons I like PERL.

Perl completely changed the game with its combination of good regular expressions, good string handling, and good data structures as well. I
credit Perl with popularizing the whole concept of regular expressions: before that, they were considered something esoteric.

For example, BASIC was considered to have good string-handling facilities. But it never had good regular expressions or hash tables; and the coming
of Perl made BASIC look quite old-fashioned indeed.

80's and early 90's Basic flavors (and that include VMS Basic)
did not have those.

But later MS Basic flavors did have them:
* VB/VBS/VBA has RegExp class and Scripting.Dictionary
COM class
* VB.NET has System.Text.RegularExpressions.Regex and
System.Collections.Hashtable (later replaced by
System.Collections.Generic.Dictionary)

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-20 12:36:51 +0000, Simon Clubley said:

One thing I wish was available in all languages is the ability to
return multiple values from a function call so you can return both a
status and the value(s) in one assignment. Ie: "a, b, c = demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

For those following along at home, C supports returning a struct.

Languages including Swift allow returning an "optional", where you
either get a value such as an object, or an indication or its absence.
Swift uses the concept of "unwrapping" a result marked optional, which
means you have to check before access.

Returning objects is more widely available, and hides a lot of this
mess, as well as hiding dealing with potentially-larger data buffers.
Objects and message-passing is akin to itemlist-based APIs, dragged
forward a few decades.

In other languages, support for an optional requires explicit code,
whether that might return a struct, or might return a value and a
sentinel, or ilk.


--
Pure Personal Opinion | HoffmanLabs LLC

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-23 23:34:18 +0000, Arne Vajhøj said:

On 8/23/2024 11:32 AM, Stephen Hoffman wrote:

OpenVMS has ~no concept of languages, either. Yeah, the C abd C++ I18N
giblets, Java and its own little world, maybe using the existing and
older ICU or maybe you ported a newer ICU, and the deprecated Terminal
Fallback Facility (TFF) and National (Replacement)  Character Set (NCS)
giblets, sure. All of which make things more interesting for apps that
want or need to deal with the UTF-8 and post-ASCII world.

Regarding UTF-8 support, then my take is that:

UTF-8 in file names, in usernames, in logicals, in identifiers and in programs/scripts: not really needed.

UTF-8 filenames — poorly documented — already exists and was necessary
for a key app or two, though the rendering is ugly.

Working on a system that supports UTF-8 ~everywhere including within
the shell and within various languages and apps makes things easier.

Systems that don't provide that support mean more work. It's feasible,
but it's work. Or it gets ignored, or implemented elsewhere.

With the state of TFF, NCS, ICU, and the rest (on OpenVMS), I'd expect
that all gets workarounds or hack-arounds, or gets ignored and ANSI /
ISO Latin-1 used. That at least until the app gets ported off OpenVMS,
or the app gets replaced.

UTF-8 in file content and in databases: very much needed.

And support for the latter fall in 3 groups:
* JVM languages (Java, Groovy etc.) and I believe Python - does support unicode and can read/write using any encoding including UTF-8
* C, C++, PHP - developer keeps track of what encoding a byte sequence
is in but possible to explicit convert encodings
(C/C++ has wchar_t but it is neither much used nor UTF-8 friendly AFAIK)

Quoth the standard: "The width of wchar_t is compiler-specific and can
be as small as 8 bits. Consequently, programs that need to be portable
across any C or C++ compiler should not use wchar_t for storing Unicode
text."

* the traditional native languages - very little support except what
can be done by calling C functions

--
Pure Personal Opinion | HoffmanLabs LLC

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/24/2024 9:33 PM, Stephen Hoffman wrote:

On 2024-08-20 12:36:51 +0000, Simon Clubley said:

One thing I wish was available in all languages is the ability to
return multiple values from a function call so you can return both a
status and the value(s) in one assignment. Ie: "a, b, c =
demo_function(param1, param2);".

In languages with dynamic associative arrays (such as PHP), I simulate
this by returning an associative array from a function call with both
status and value fields. Makes coding _so_ much cleaner and robust.

For those following along at home, C supports returning a struct.

Languages including Swift allow returning an "optional", where you
either get a value such as an object, or an indication or its absence.
Swift uses the concept of "unwrapping" a result marked optional, which
means you have to check before access.

Returning objects is more widely available, and hides a lot of this
mess, as well as hiding dealing with potentially-larger data buffers.
Objects and message-passing is akin to itemlist-based APIs, dragged
forward a few decades.

In other languages, support for an optional requires explicit code,
whether that might return a struct, or might return a value and a
sentinel, or ilk.

I don't know Swift but I will assume Swift optional is similar to
optional in other languages.

It solves the return both status and value problem. But it is
not a general multiple return value solution. And it is really
just a small evolution of the traditional "return null
indicate an error".

$ type OptionalDemo.java
import java.util.Optional;

public class OptionalDemo {
public static String oldStyleAPI(int v) {
if(v > 0) {
return Integer.toString(v);
} else {
return null;
}
}
public static Optional<String> newStyleAPI(int v) {
if(v > 0) {
return Optional.of(Integer.toString(v));
} else {
return Optional.empty();
}
}
public static void testOldStyleAPI(int v) {
String s = oldStyleAPI(v);
if(s != null) {
System.out.println(s);
} else {
System.out.println("No result");
}
}
public static void testNewStyleAPI(int v) {
Optional<String> s = newStyleAPI(v);
if(s.isPresent()) {
System.out.println(s.get());
} else {
System.out.println("No result");
}
}
public static void testNewStyleAPISmarter(int v) {
Optional<String> s = newStyleAPI(v);
System.out.println(s.orElse("No result"));
}
public static void main(String[] args) {
testOldStyleAPI(123);
testOldStyleAPI(0);
testNewStyleAPI(123);
testNewStyleAPI(0);
testNewStyleAPISmarter(123);
testNewStyleAPISmarter(0);
}
}
$ javac OptionalDemo.java
$ java "OptionalDemo"
123
No result
123
No result
123
No result

Arne

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)