On 5/27/2022 10:36 AM, Bill Gunshannon wrote:
> On 5/27/22 08:47, Simon Clubley wrote:
>> On 2022-05-26, Bill Gunshannon <bill.gunshannon@gmail.com> wrote:
>>> On 5/26/22 15:16, Simon Clubley wrote:
>>>>
>>>> Aware of peek and poke in some microcontroller Basic implementations.
>>>> They return/set bytes/words/longwords at the memory location specified.
>>>> You are not writing kernel code (or application code) in 2022 by doing
>>>> the equivalent of "uint32_t *ptr" only in your code instead of using
>>>> structures/records that model the memory block at the given location.
>>>>
>>>> As per the question I just asked, how would you define a record
>>>> structure and access a block of memory through the record structure
>>>> at a random memory location and how would you chain together instances
>>>> of these structures in memory ?
>>>>
>>>> In C, it's easy. You define a struct data type with forward links within
>>>> the structure as required and with pointers of that data type outside
>>>> of the structure as required.
>>>
>>> So, tell me, would you consider a complete Virtual Machine that emulates
>>> a hardware architecture and contains all the primitives for I/O, math
>>> and other necessary function to be an Operating System?
>>>
>>
>> No.
>>
>> The operating system is what runs on top of that emulated environment.
>
> The example I am thinking of contains the emulated architecture and
> everything right up to the user interface. So, it does contain "what
> runs on top of that emulated environment".
>
>>
>> I don't understand how this is related to this thread however.
>
> Tiny Pascal by Herbert Yuen and Kin-Man Chung. Compiler and Pcode
> Interpreter with User Interface all done in NorthStar Basic. In the
> September, October and November 1978 issues of Byte Magazine.
>
> bill
>
>

Was Simon around in 1978 ???

--
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

On 5/27/22 11:14, Dave Froble wrote:
> On 5/27/2022 10:36 AM, Bill Gunshannon wrote:
>> On 5/27/22 08:47, Simon Clubley wrote:
>>> On 2022-05-26, Bill Gunshannon <bill.gunshannon@gmail.com> wrote:
>>>> On 5/26/22 15:16, Simon Clubley wrote:
>>>>>
>>>>> Aware of peek and poke in some microcontroller Basic implementations.
>>>>> They return/set bytes/words/longwords at the memory location
>>>>> specified.
>>>>> You are not writing kernel code (or application code) in 2022 by doing
>>>>> the equivalent of "uint32_t *ptr" only in your code instead of using
>>>>> structures/records that model the memory block at the given location.
>>>>>
>>>>> As per the question I just asked, how would you define a record
>>>>> structure and access a block of memory through the record structure
>>>>> at a random memory location and how would you chain together instances
>>>>> of these structures in memory ?
>>>>>
>>>>> In C, it's easy. You define a struct data type with forward links
>>>>> within
>>>>> the structure as required and with pointers of that data type outside
>>>>> of the structure as required.
>>>>
>>>> So, tell me, would you consider a complete Virtual Machine that
>>>> emulates
>>>> a hardware architecture and contains all the primitives for I/O, math
>>>> and other necessary function to be an Operating System?
>>>>
>>>
>>> No.
>>>
>>> The operating system is what runs on top of that emulated environment.
>>
>> The example I am thinking of contains the emulated architecture and
>> everything right up to the user interface.  So, it does contain "what
>> runs on top of that emulated environment".
>>
>>>
>>> I don't understand how this is related to this thread however.
>>
>> Tiny Pascal by Herbert Yuen and Kin-Man Chung.  Compiler and Pcode
>> Interpreter with User Interface all done in NorthStar Basic. In the
>> September, October and November 1978 issues of Byte Magazine.
>>
>> bill
>>
>>
>
> Was Simon around in 1978 ???
>

Hmmm.. Good point.

How about this one. The Software Tools Virtual Operating System.
Paper published in September of 1980 in Communications of the ACM.
Written originally in RATFOR but for those of us who know RATFOR
and Fortran it would be easy to redo in BASIC. Actually, it would
be rather trivial to write a RATFOR compiler that churned out BASIC
instead of Fortran.

While all this stuff is something BASIC was not intended to do
one should never underestimate the power of any language in the
hands of a competent programmer.

bill

On 2022-05-27, Dave Froble <davef@tsoft-inc.com> wrote:
>
> Was Simon around in 1978 ???
>

Yes I was, but I wasn't even in secondary school yet at that point. :-)

Simon.

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

On 2022-05-27, Dave Froble <davef@tsoft-inc.com> wrote:
>
> Unable to stifle all my defiance, I'm sure I could do it in Macro-32.
>
>:-)
>

You can do anything you want in Macro-32 if you spend long enough
at it and are stubborn enough. :-)

You already know what I think about whether you should... :-)

Simon.

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

On 2022-05-27, Simon Clubley <clubley@remove_me.eisner.decus.org-Earth.UFP> wrote:
> On 2022-05-27, Dave Froble <davef@tsoft-inc.com> wrote:
>>
>> Was Simon around in 1978 ???
>>
>
> Yes I was, but I wasn't even in secondary school yet at that point. :-)
>

Sorry, that should have said not in _upper_ secondary school at that point.

In the UK, there's primary school, then secondary school (which can be
split between lower secondary school and upper secondary school as it
was for me), and then the sixth form. After that, there's university.

Simon.

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

On Fri, 27 May 2022 17:40:21 +0000, Simon Clubley wrote:

> On 2022-05-27, Simon Clubley
> <clubley@remove_me.eisner.decus.org-Earth.UFP> wrote:
>> On 2022-05-27, Dave Froble <davef@tsoft-inc.com> wrote:
>>>
>>> Was Simon around in 1978 ???
>>>
>>>
>> Yes I was, but I wasn't even in secondary school yet at that point.
>>
>>
> Sorry, that should have said not in _upper_ secondary school at that
> point.
>
> In the UK, there's primary school, then secondary school (which can be
> split between lower secondary school and upper secondary school as it
> was for me), and then the sixth form. After that, there's university.

With an alternative to sixth form being 'college', just to confuse
matters.

--
My posts are my copyright and if @diy_forums or Home Owners' Hub
wish to copy them they can pay me £1 a message.
Use the BIG mirror service in the UK: http://www.mirrorservice.org
*lightning surge protection* - a w_tom conductor

On 5/26/2022 3:16 PM, Simon Clubley wrote:
> As per the question I just asked, how would you define a record
> structure and access a block of memory through the record structure
> at a random memory location and how would you chain together instances
> of these structures in memory ?

We are talking a fictive Basic compiler right? Pretty easy I would say.

Some VB.NET inspired syntax:

Structure Foobar
Dim S1 As UInt16
Dim S2 As UInt16
Dim I As Int32
End Structure
....
Dim fbptr As Pointer To Foobar
....
fbptr = UncheckedCast(integerpointingtosomerandomplaceinmemory, Pointer
To Foobar)
....
fbptr.S1 = 1
fbptr.S2 = 2
fbptr.I = 3

Arne

On 5/25/2022 4:34 AM, Johnny Billquist wrote:
> On 2022-05-25 01:55, Arne Vajhøj wrote:
>> On 5/24/2022 1:03 PM, Johnny Billquist wrote:
>>> On 2022-05-23 14:29, Simon Clubley wrote:
>>>> On 2022-05-20, Stephen Hoffman <seaohveh@hoffmanlabs.invalid> wrote:
>>>>> On 2022-05-20 17:44:50 +0000, Simon Clubley said:
>>>>>> These days, I avoid this problem in my C code by using the
>>>>>> uint[8/16/32]_t (and friends) data types.
>>>>>>
>>>>>
>>>>> Same here, where I need to care that much about the integer types.
>>>>>
>>>>
>>>> Person who likes Ada here, remember ? :-)
>>>>
>>>> I always care about my types... :-)
>>>
>>> In a sense, this is something Ada really got right. You don't declare
>>> how many bits, signedness and so on you want. You declare your
>>> integers with the range you need them to have, and let the
>>> language/compiler figure out how to represent and store them.
>>
>> Ada and the rest of that "language family" including Pascal and Modula-2.
>
> It's similar in some sense to Pascal, yes (I don't really know Modula),
> but from just my recollection right now, Ada is not the same as Pascal
> here.

Pascal and Modula-2 certainly has:

type
foobar = 1..52;

and:

TYPE
foobar = [1..52];

>>> And two "integer" types with different ranges are not the same type,
>>> or even closely related, and you cannot just assign from one type to
>>> another.
>>
>> That applies for Ada type. Not for Ada subtype and Pascal.
>
> Maybe that is what my recollection is about. In Pascal, they are all
> subtypes, while in Ada they are usually not, unless you specifically say
> so.

Yes.

>> But yes - it is a really really strong feature in Ada. True strict
>> type check.
>
> Yes. While it can be a headache sometimes, it do make a lot of sense.
> Especially when working on larger software with lots of people involved.

And if software errors result in large number of deaths.

>>> However, if you want to interface with hardware, it becomes a little
>>> messy, since then you do want to specify things in number of bits and
>>> bytes. Since that's what the hardware have.
>>
>> It can also be a problem if the code make certain assumptions about
>> when integer overflow happens.
>
> Well, since it's Ada, you don't make any assumptions. You'll always get
> exceptions on overflow, as far as I can remember.

I thought that was implementation specific.

But then I don't really do Ada.

Arne

Moving the discussion to alt.folklore.computers, because it's gone way beyond
the interest levels at comp.os.vms by now, I'm sure.

gah4 <gah4@u.washington.edu> writes:

> On Thursday, May 26, 2022 at 2:54:31 PM UTC-7, Rich Alderson wrote:

> (snip)

>>> Looking at an actual IBM manual, it seems that the 64 opcodes map to
>>> the 64 characters in the character set, and those characters are used
>>> to represent them. That is, base 64.

>>> Some others might represent those in octal, but yes I don't see IBM doing
>>> it.

>> Yeah, it wasn't called "base 64". It was called "BCD", and they were simply
>> treated as alphanumerics and special characters.

>> The B bit corresponds to the 11 zone punch on a card, the A bit to the 0
>> zone punch, and BA corresponds to the 12 zone punch.

>> All 0's is the SPACE character; the "0" character is the 8+2 bits.

> The 704 uses a 48 character version of BCD, though I didn't match
> up the character codes. The documentation of opcodes uses octal.

The 704 is completely irrelevant to the previous discussion, since it is a word
addressed (36 bits/word) scientific computer, where the 14xx family are
character addressed business computers. The only thing they have in common is
the name of the manufacturer.

> I didn't see actual assembler output for either one, but in the instruction
> tables the BCD character is used as the numeric opcode for the 1401,
> where others would put the octal (or later hexadecimal) opcode.

Yeah, that's what I said.

> Now, since the 704 only has 48 characters in its BCD, not enough for
> all the opcodes, maybe that isn't so surprising.

>> NB: The card codes on the "96 column cards" used by the System/3 are the
>> same as the 14xx BCD representation in memory.

> It seems that System/3 cards can be either six bit BCD, or 8 bit EBCDIC. In
> the latter case, the extra two rows of punches go above, where the printed
> text goes. I am not sure how the two codes work together.

Interesting. I only encountered the System/3 in passing, and used to have a
small stack of the cards with the numerically ordered punches. That's how I
learned about the correspondence.

> I do remember knowing, not so many years ago, that there was a System/3 card
> read/punch for the 360/20, but never saw one.

> The 704 has some strange features with its character code. Among others, they
> used even parity tape (must have seemed like a good idea) where you can't
> write the character with all bits zero. (No transitions means no clock.)

The 1401 also used 7-bit even parity NRZ tape, IIRC. We didn't have tapes on
our machine, just a 1402 reader/punch and a pair of 1311 disk drives.

> I didn't look to see what the 1401 ALU generates for its decimal output,
> but I presume the 8-2 code.

--
Rich Alderson news@alderson.users.panix.com
Audendum est, et veritas investiganda; quam etiamsi non assequamur,
omnino tamen proprius, quam nunc sumus, ad eam perveniemus.
--Galen

Bill Gunshannon <bill.gunshannon@gmail.com> writes:

> On 5/27/22 08:47, Simon Clubley wrote:

>> The operating system is what runs on top of that emulated environment.

> The example I am thinking of contains the emulated architecture and
> everything right up to the user interface. So, it does contain "what
> runs on top of that emulated environment".

>> I don't understand how this is related to this thread however.

> Tiny Pascal by Herbert Yuen and Kin-Man Chung. Compiler and Pcode
> Interpreter with User Interface all done in NorthStar Basic. In the
> September, October and November 1978 issues of Byte Magazine.

Ah! The articles which turned me away from historical linguistics and towards
a career working with computers for the next 44 years (and counting).

--
Rich Alderson news@alderson.users.panix.com
Audendum est, et veritas investiganda; quam etiamsi non assequamur,
omnino tamen proprius, quam nunc sumus, ad eam perveniemus.
--Galen

On 2022-05-28 02:14, Arne Vajhøj wrote:
> On 5/25/2022 4:34 AM, Johnny Billquist wrote:
>> On 2022-05-25 01:55, Arne Vajhøj wrote:
>>> On 5/24/2022 1:03 PM, Johnny Billquist wrote:
>>>> On 2022-05-23 14:29, Simon Clubley wrote:
>>>>> On 2022-05-20, Stephen Hoffman <seaohveh@hoffmanlabs.invalid> wrote:
>>>>>> On 2022-05-20 17:44:50 +0000, Simon Clubley said:
>>>>>>> These days, I avoid this problem in my C code by using the
>>>>>>> uint[8/16/32]_t (and friends) data types.
>>>>>>>
>>>>>>
>>>>>> Same here, where I need to care that much about the integer types.
>>>>>>
>>>>>
>>>>> Person who likes Ada here, remember ? :-)
>>>>>
>>>>> I always care about my types... :-)
>>>>
>>>> In a sense, this is something Ada really got right. You don't
>>>> declare how many bits, signedness and so on you want. You declare
>>>> your integers with the range you need them to have, and let the
>>>> language/compiler figure out how to represent and store them.
>>>
>>> Ada and the rest of that "language family" including Pascal and
>>> Modula-2.
>>
>> It's similar in some sense to Pascal, yes (I don't really know
>> Modula), but from just my recollection right now, Ada is not the same
>> as Pascal here.
>
> Pascal and Modula-2 certainly has:
>
> type
>     foobar = 1..52;
>
> and:
>
> TYPE
>     foobar = [1..52];

Yeah. Which are implicitly integers, just with a defined range. Which is
way less than what Ada do. But there is certainly a similarity, I agree.

>>> But yes - it is a really really strong feature in Ada. True strict
>>> type check.
>>
>> Yes. While it can be a headache sometimes, it do make a lot of sense.
>> Especially when working on larger software with lots of people involved.
>
> And if software errors result in large number of deaths.

That would be one reason why you'd want to be strict, yes.

>>>> However, if you want to interface with hardware, it becomes a little
>>>> messy, since then you do want to specify things in number of bits
>>>> and bytes. Since that's what the hardware have.
>>>
>>> It can also be a problem if the code make certain assumptions about
>>> when integer overflow happens.
>>
>> Well, since it's Ada, you don't make any assumptions. You'll always
>> get exceptions on overflow, as far as I can remember.
>
> I thought that was implementation specific.
>
> But then I don't really do Ada.

Leaving that as "implementation specific" would really be against the
spirit of the language, if you think about it...

And you also get that exception if you have a type declared with a range
of 0..1000, and you try 1000+1 (of course).

Johnny

On 5/28/2022 10:04 AM, Johnny Billquist wrote:
> On 2022-05-28 02:14, Arne Vajhøj wrote:
>> On 5/25/2022 4:34 AM, Johnny Billquist wrote:
>>> On 2022-05-25 01:55, Arne Vajhøj wrote:
>>>> On 5/24/2022 1:03 PM, Johnny Billquist wrote:
>>>>> On 2022-05-23 14:29, Simon Clubley wrote:
>>>>>> On 2022-05-20, Stephen Hoffman <seaohveh@hoffmanlabs.invalid> wrote:
>>>>>>> On 2022-05-20 17:44:50 +0000, Simon Clubley said:
>>>>>>>> These days, I avoid this problem in my C code by using the
>>>>>>>> uint[8/16/32]_t (and friends) data types.
>>>>>>>>
>>>>>>>
>>>>>>> Same here, where I need to care that much about the integer types.
>>>>>>>
>>>>>>
>>>>>> Person who likes Ada here, remember ? :-)
>>>>>>
>>>>>> I always care about my types... :-)
>>>>>
>>>>> In a sense, this is something Ada really got right. You don't
>>>>> declare how many bits, signedness and so on you want. You declare
>>>>> your integers with the range you need them to have, and let the
>>>>> language/compiler figure out how to represent and store them.
>>>>
>>>> Ada and the rest of that "language family" including Pascal and
>>>> Modula-2.
>>>
>>> It's similar in some sense to Pascal, yes (I don't really know
>>> Modula), but from just my recollection right now, Ada is not the same
>>> as Pascal here.
>>
>> Pascal and Modula-2 certainly has:
>>
>> type
>>      foobar = 1..52;
>>
>> and:
>>
>> TYPE
>>      foobar = [1..52];
>
> Yeah. Which are implicitly integers, just with a defined range. Which is
> way less than what Ada do. But there is certainly a similarity, I agree.

I believe it is somewhat similar to Ada:

subtype foobar is Integer range 1..52;

>>>>> However, if you want to interface with hardware, it becomes a
>>>>> little messy, since then you do want to specify things in number of
>>>>> bits and bytes. Since that's what the hardware have.
>>>>
>>>> It can also be a problem if the code make certain assumptions about
>>>> when integer overflow happens.
>>>
>>> Well, since it's Ada, you don't make any assumptions. You'll always
>>> get exceptions on overflow, as far as I can remember.
>>
>> I thought that was implementation specific.
>>
>> But then I don't really do Ada.
>
> Leaving that as "implementation specific" would really be against the
> spirit of the language, if you think about it...

I would tend to agree with that.

But then:

$ type ovf.adb
with Ada.Text_IO, Ada.Integer_Text_IO;

use Ada.Text_IO, Ada.Integer_Text_IO;

procedure ovf is

n : Integer;

begin
n := 2147483647;
Put(n);
New_Line;
n := n + 1;
Put(n);
New_Line;
end ovf;
$ gnat make ovf.adb
gcc -c ovf.adb
gnatbind -x ovf.ali
gnatlink ovf.ali
$ r ovf
2147483647
-2147483648

> And you also get that exception if you have a type declared with a range
> of 0..1000, and you try 1000+1 (of course).

That does get caught:

$ type ovf2.adb
with Ada.Text_IO, Ada.Integer_Text_IO;

use Ada.Text_IO, Ada.Integer_Text_IO;

procedure ovf2 is

type one_to_thousand is range 1..1000;

n : one_to_thousand;

begin
n := 1000;
Put(Integer(n));
New_Line;
n := n + 1;
Put(Integer(n));
New_Line;
end ovf2;
$ gnat make ovf2.adb
gcc -c ovf2.adb
gnatbind -x ovf2.ali
gnatlink ovf2.ali
$ r ovf2
1000

raised CONSTRAINT_ERROR : ovf2.adb:15

$ type ovf3.adb
with Ada.Text_IO, Ada.Integer_Text_IO;

use Ada.Text_IO, Ada.Integer_Text_IO;

procedure ovf3 is

subtype one_to_thousand is Integer range 1..1000;

n : one_to_thousand;

begin
n := 1000;
Put(n);
New_Line;
n := n + 1;
Put(n);
New_Line;
end ovf3;
$ gnat make ovf3.adb
gcc -c ovf3.adb
gnatbind -x ovf3.ali
gnatlink ovf3.ali
$ r ovf3
1000

raised CONSTRAINT_ERROR : ovf3.adb:15

Arne

On 2022-05-29 03:16, Arne Vajhøj wrote:
> On 5/28/2022 10:04 AM, Johnny Billquist wrote:
>> On 2022-05-28 02:14, Arne Vajhøj wrote:
>>> On 5/25/2022 4:34 AM, Johnny Billquist wrote:
>>>> On 2022-05-25 01:55, Arne Vajhøj wrote:
>>>>> On 5/24/2022 1:03 PM, Johnny Billquist wrote:
>>>>>> On 2022-05-23 14:29, Simon Clubley wrote:
>>>>>>> On 2022-05-20, Stephen Hoffman <seaohveh@hoffmanlabs.invalid> wrote:
>>>>>>>> On 2022-05-20 17:44:50 +0000, Simon Clubley said:
>>>>>>>>> These days, I avoid this problem in my C code by using the
>>>>>>>>> uint[8/16/32]_t (and friends) data types.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Same here, where I need to care that much about the integer types.
>>>>>>>>
>>>>>>>
>>>>>>> Person who likes Ada here, remember ? :-)
>>>>>>>
>>>>>>> I always care about my types... :-)
>>>>>>
>>>>>> In a sense, this is something Ada really got right. You don't
>>>>>> declare how many bits, signedness and so on you want. You declare
>>>>>> your integers with the range you need them to have, and let the
>>>>>> language/compiler figure out how to represent and store them.
>>>>>
>>>>> Ada and the rest of that "language family" including Pascal and
>>>>> Modula-2.
>>>>
>>>> It's similar in some sense to Pascal, yes (I don't really know
>>>> Modula), but from just my recollection right now, Ada is not the
>>>> same as Pascal here.
>>>
>>> Pascal and Modula-2 certainly has:
>>>
>>> type
>>>      foobar = 1..52;
>>>
>>> and:
>>>
>>> TYPE
>>>      foobar = [1..52];
>>
>> Yeah. Which are implicitly integers, just with a defined range. Which
>> is way less than what Ada do. But there is certainly a similarity, I
>> agree.
>
> I believe it is somewhat similar to Ada:
>
> subtype foobar is Integer range 1..52;

Yeah.

>>>>>> However, if you want to interface with hardware, it becomes a
>>>>>> little messy, since then you do want to specify things in number
>>>>>> of bits and bytes. Since that's what the hardware have.
>>>>>
>>>>> It can also be a problem if the code make certain assumptions about
>>>>> when integer overflow happens.
>>>>
>>>> Well, since it's Ada, you don't make any assumptions. You'll always
>>>> get exceptions on overflow, as far as I can remember.
>>>
>>> I thought that was implementation specific.
>>>
>>> But then I don't really do Ada.
>>
>> Leaving that as "implementation specific" would really be against the
>> spirit of the language, if you think about it...
>
> I would tend to agree with that.
>
> But then:

[...]

Hmm. So either my memory is bad (it's been a long time since I was truly
working in Ada), or gnat have some issues. More likely my brain is bad,
and simple integers don't have that property. But at the same time,
implementation specific sounds so unlike Ada. Maybe they have it just
defined to behave like 2s complement with a defined size? I would have
to go and look it up, but I'm too lazy right now. :-)

Johnny

On 2022-05-28, Arne Vajhøj <arne@vajhoej.dk> wrote:
>
> But then:
>
> $ type ovf.adb
> with Ada.Text_IO, Ada.Integer_Text_IO;
>
> use Ada.Text_IO, Ada.Integer_Text_IO;
>
> procedure ovf is
>
> n : Integer;
>
> begin
> n := 2147483647;
> Put(n);
> New_Line;
> n := n + 1;
> Put(n);
> New_Line;
> end ovf;
> $ gnat make ovf.adb
> gcc -c ovf.adb
> gnatbind -x ovf.ali
> gnatlink ovf.ali
> $ r ovf
> 2147483647
> -2147483648
>

Recompile your code with the "-gnato" option (without quotes!) and try again.

Not one of the finest defaults decisions ever made by AdaCore. :-(

I am surprised that you were not warned at compile time however. Are you
running a really old version of GNAT on VMS ?

Simon.

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

On 5/30/2022 8:09 AM, Simon Clubley wrote:
> On 2022-05-28, Arne Vajhøj <arne@vajhoej.dk> wrote:
>> But then:
>>
>> $ type ovf.adb
>> with Ada.Text_IO, Ada.Integer_Text_IO;
>>
>> use Ada.Text_IO, Ada.Integer_Text_IO;
>>
>> procedure ovf is
>>
>> n : Integer;
>>
>> begin
>> n := 2147483647;
>> Put(n);
>> New_Line;
>> n := n + 1;
>> Put(n);
>> New_Line;
>> end ovf;
>> $ gnat make ovf.adb
>> gcc -c ovf.adb
>> gnatbind -x ovf.ali
>> gnatlink ovf.ali
>> $ r ovf
>> 2147483647
>> -2147483648
>
> Recompile your code with the "-gnato" option (without quotes!) and try again.
>
> Not one of the finest defaults decisions ever made by AdaCore. :-(
>
> I am surprised that you were not warned at compile time however. Are you
> running a really old version of GNAT on VMS ?

Yes. Very old.

Arne

On Mon, 2022-05-30 at 12:09 +0000, Simon Clubley wrote:
> Recompile your code with the "-gnato" option (without quotes!) and
> try again.
>
> Not one of the finest defaults decisions ever made by AdaCore. :-(
>
> I am surprised that you were not warned at compile time however. Are
> you running a really old version of GNAT on VMS ?

$ gnatmake-10.3.1 ovf
gcc-10.3.1 -c ovf.adb
ovf.adb:12:16: warning: value not in range of type "Standard.Integer"
[enabled by default]
ovf.adb:12:16: warning: "Constraint_Error" will be raised at run time
[enabled by default]
gnatbind-10.3.1 -x ovf.ali
gnatlink-10.3.1 ovf.ali

Looks like it works fine for me on Linux. :-D
--
Tactical Nuclear Kittens

On 5/30/22 05:07, Johnny Billquist wrote:
> On 2022-05-29 03:16, Arne Vajhøj wrote:
>> On 5/28/2022 10:04 AM, Johnny Billquist wrote:
>>> On 2022-05-28 02:14, Arne Vajhøj wrote:
>>>> On 5/25/2022 4:34 AM, Johnny Billquist wrote:
>>>>> On 2022-05-25 01:55, Arne Vajhøj wrote:
>>>>>> On 5/24/2022 1:03 PM, Johnny Billquist wrote:
>>>>>>> On 2022-05-23 14:29, Simon Clubley wrote:
>>>>>>>> On 2022-05-20, Stephen Hoffman <seaohveh@hoffmanlabs.invalid>
>>>>>>>> wrote:
>>>>>>>>> On 2022-05-20 17:44:50 +0000, Simon Clubley said:
>>>>>>>>>> These days, I avoid this problem in my C code by using the
>>>>>>>>>> uint[8/16/32]_t (and friends) data types.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Same here, where I need to care that much about the integer types.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Person who likes Ada here, remember ? :-)
>>>>>>>>
>>>>>>>> I always care about my types... :-)
>>>>>>>
>>>>>>> In a sense, this is something Ada really got right. You don't
>>>>>>> declare how many bits, signedness and so on you want. You declare
>>>>>>> your integers with the range you need them to have, and let the
>>>>>>> language/compiler figure out how to represent and store them.
>>>>>>
>>>>>> Ada and the rest of that "language family" including Pascal and
>>>>>> Modula-2.
>>>>>
>>>>> It's similar in some sense to Pascal, yes (I don't really know
>>>>> Modula), but from just my recollection right now, Ada is not the
>>>>> same as Pascal here.
>>>>
>>>> Pascal and Modula-2 certainly has:
>>>>
>>>> type
>>>>      foobar = 1..52;
>>>>
>>>> and:
>>>>
>>>> TYPE
>>>>      foobar = [1..52];
>>>
>>> Yeah. Which are implicitly integers, just with a defined range. Which
>>> is way less than what Ada do. But there is certainly a similarity, I
>>> agree.
>>
>> I believe it is somewhat similar to Ada:
>>
>> subtype foobar is Integer range 1..52;
>
> Yeah.
>
>>>>>>> However, if you want to interface with hardware, it becomes a
>>>>>>> little messy, since then you do want to specify things in number
>>>>>>> of bits and bytes. Since that's what the hardware have.
>>>>>>
>>>>>> It can also be a problem if the code make certain assumptions about
>>>>>> when integer overflow happens.
>>>>>
>>>>> Well, since it's Ada, you don't make any assumptions. You'll always
>>>>> get exceptions on overflow, as far as I can remember.
>>>>
>>>> I thought that was implementation specific.
>>>>
>>>> But then I don't really do Ada.
>>>
>>> Leaving that as "implementation specific" would really be against the
>>> spirit of the language, if you think about it...
>>
>> I would tend to agree with that.
>>
>> But then:
>
> [...]
>
> Hmm. So either my memory is bad (it's been a long time since I was truly
> working in Ada), or gnat have some issues. More likely my brain is bad,
> and simple integers don't have that property. But at the same time,
> implementation specific sounds so unlike Ada.

I haven't played with Ada for quite some time but according to the
older standards (that I still have the docs for) "implementation
specific" is definitely common in Ada. It was one of the things
that reduced my interest in the language. It makes programs non-
deterministic.

> Maybe they have it just
> defined to behave like 2s complement with a defined size? I would have
> to go and look it up, but I'm too lazy right now. :-)
>

Ada was a good idea destroyed by committee.

bill

On 5/30/2022 9:38 AM, Single Stage to Orbit wrote:
> On Mon, 2022-05-30 at 12:09 +0000, Simon Clubley wrote:
>> Recompile your code with the "-gnato" option (without quotes!) and
>> try again.
>>
>> Not one of the finest defaults decisions ever made by AdaCore. :-(
>>
>> I am surprised that you were not warned at compile time however. Are
>> you running a really old version of GNAT on VMS ?
>
> $ gnatmake-10.3.1 ovf
> gcc-10.3.1 -c ovf.adb
> ovf.adb:12:16: warning: value not in range of type "Standard.Integer"
> [enabled by default]
> ovf.adb:12:16: warning: "Constraint_Error" will be raised at run time
> [enabled by default]
> gnatbind-10.3.1 -x ovf.ali
> gnatlink-10.3.1 ovf.ali
>
> Looks like it works fine for me on Linux. :-D

They must have become better.

I was using 3.12p from 1999.

:-)

Arne

On 2022-05-30, Single Stage to Orbit <alex.buell@munted.eu> wrote:
> On Mon, 2022-05-30 at 12:09 +0000, Simon Clubley wrote:
>> Recompile your code with the "-gnato" option (without quotes!) and
>> try again.
>>
>> Not one of the finest defaults decisions ever made by AdaCore. :-(
>>
>> I am surprised that you were not warned at compile time however. Are
>> you running a really old version of GNAT on VMS ?
>
> $ gnatmake-10.3.1 ovf
> gcc-10.3.1 -c ovf.adb
> ovf.adb:12:16: warning: value not in range of type "Standard.Integer"
> [enabled by default]
> ovf.adb:12:16: warning: "Constraint_Error" will be raised at run time
> [enabled by default]
> gnatbind-10.3.1 -x ovf.ali
> gnatlink-10.3.1 ovf.ali
>
> Looks like it works fine for me on Linux. :-D

You may be seeing a compile time check because there's enough information
in the source code to determine that at compile time (which is the kind
of thing that GNAT is good at even when runtime checks are disabled), or
you may be seeing AdaCore turning on -gnato by default which is something
that was promised a while back:

https://stackoverflow.com/questions/23529857/is-this-a-bug-in-gnat-that-i-should-report

I haven't really paid close attention to this because I am running an
older GNAT compiler and because I always have -gnato on anyway.

This is what used to happen:

https://gcc.gnu.org/onlinedocs/gcc-4.4.7/gnat_ugn_unw/Run_002dTime-Checks.html

You want the -gnato section, which follows the -gnatp section.

Like I said, not exactly one of the finest decisions ever made by AdaCore.

Simon.

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

On 5/30/2022 1:39 PM, Arne Vajhøj wrote:
> On 5/30/2022 9:38 AM, Single Stage to Orbit wrote:
>> On Mon, 2022-05-30 at 12:09 +0000, Simon Clubley wrote:
>>> Recompile your code with the "-gnato" option (without quotes!) and
>>> try again.
>>>
>>> Not one of the finest defaults decisions ever made by AdaCore. :-(
>>>
>>> I am surprised that you were not warned at compile time however. Are
>>> you running a really old version of GNAT on VMS ?
>>
>> $ gnatmake-10.3.1 ovf
>> gcc-10.3.1 -c ovf.adb
>> ovf.adb:12:16: warning: value not in range of type "Standard.Integer"
>> [enabled by default]
>> ovf.adb:12:16: warning: "Constraint_Error" will be raised at run time
>> [enabled by default]
>> gnatbind-10.3.1 -x ovf.ali
>> gnatlink-10.3.1 ovf.ali
>>
>> Looks like it works fine for me on Linux. :-D
>
> They must have become better.
>
> I was using 3.12p from 1999.
>
> :-)

BTW, I get the same as your Linux GCC with ACT Gnat 2017 on Windows:

C:\Work>gnat make ovf.adb
gcc -c ovf.adb
ovf.adb:13:12: warning: value not in range of type "Standard.Integer"
ovf.adb:13:12: warning: "Constraint_Error" will be raised at run time
gnatbind -x ovf.ali
gnatlink ovf.ali

C:\Work>ovf
2147483647

raised CONSTRAINT_ERROR : ovf.adb:13 overflow check failed

And a few more.

jgnat 1.1p:

C:\Work>jgnatmake ovf.adb
jgnat -c ovf.adb
jgnatbind -x ovf.ali
jgnatlink ovf.ali

C:\Work>java -cp .;jgnat.jar ovf
2147483647
-0./,),(-*,(

(something went really bad here - not only did it not catch the
overflow - it could not print the number!)

ACT Gnat 2013 for JVM:

C:\Work>jvm-gnat make ovf.adb
jvm-gnatcompile -c ovf.adb
ovf.adb:13:12: warning: value not in range of type "Standard.Integer"
ovf.adb:13:12: warning: "Constraint_Error" will be raised at run time
jvm-gnatbind -x ovf.ali
jvm-gnatlink ovf.ali

C:\Work>java -cp .;jgnat.jar ovf
2147483647

CONSTRAINT_ERROR ovf.adb:13 overflow check failed

Arne

On Mon, 2022-05-30 at 13:39 -0400, Arne Vajhøj wrote:
> > Looks like it works fine for me on Linux. :-D
>
> They must have become better.
>
> I was using 3.12p from 1999.

3.12p! Wow, that's based on GCC 2.8.1. First GCC compiler I used was
2.7.2.3 when buillding the early Linux 2.x kernels in the late 90s.
--
Tactical Nuclear Kittens

On 5/30/2022 3:10 PM, Single Stage to Orbit wrote:
> On Mon, 2022-05-30 at 13:39 -0400, Arne Vajhøj wrote:
>>> Looks like it works fine for me on Linux. :-D
>>
>> They must have become better.
>>
>> I was using 3.12p from 1999.
>
> 3.12p! Wow,

There was a working version for VMS Alpha that I picked
up many years ago and still has.

I don't do Ada so it really doesn't matter that it is old.

> that's based on GCC 2.8.1. First GCC compiler I used was
> 2.7.2.3 when buillding the early Linux 2.x kernels in the late 90s.

I did play a little with GCC 1.4x on VMS VAX and 2.8.x on VMS Alpha
way back.

Arne