ChatGPT writes a GEM program...

[mfro]

OpenGPT chat protocol:

M: write a short C program that opens a GEM AES window on an atari st, does a small GEM VDI drawing inside, maintains its movements and closes it
O: Here's an example C program that opens a GEM AES window on an Atari ST, does a small GEM VDI drawing inside, maintains its movements, and closes it:

Code: Select all

#include <aes.h>
#include <vdi.h>

int main(int argc, char *argv[]) {
    int handle;
    int x, y;
    int movx, movy;
    int button;

    /* Open a new AES window */
    handle = wind_create(NAME | MOVER | CLOSER, 0, 0, 0, 0);
    wind_open(handle, 50, 50, 300, 200);
    wind_set(handle, WF_NAME, "My GEM AES Window", 0, 0);

    /* Open a new VDI workstation */
    handle = graf_handle(&x, &y, &w, &h);
    v_opnvwk(work_in, &handle, work_out);
    v_clrwk(handle);

    /* Draw a small rectangle */
    v_bar(handle, 10, 10, 20, 20);

    /* Wait for the user to move or close the window */
    do {
        evnt_mesag(msg_buf);
        switch (msg_buf[0]) {
            case WM_MOVED:
                wind_get(handle, WF_CURRXYWH, &movx, &movy, &w, &h);
                break;
            case WM_CLOSED:
                break;
            case WM_MOUSE:
                if (msg_buf[4] == 1) {
                    button = msg_buf[3];
                }
                break;
        }
    } while (msg_buf[0] != WM_CLOSED);

    /* Close the VDI workstation */
    v_clsvwk(handle);

    /* Exit the program */
    return 0;
}

This program opens an AES window with the title "My GEM AES Window", sets it to be movable by the user, and sets it to have a close button. It also creates a VDI workstation and draws a small rectangle in it. It then enters a loop that waits for events from the AES, such as the user moving the window or clicking the close button. When the user closes the window, the program closes the VDI workstation and exits.


Although not entirely correct (it clears the screen instead of the window contents only), this appears to be a valid GEM program.

I find this pretty impressive (considering the fact that the amount of information available on the internet about GEM programming still seems to be enough to train a neuronal net to write nearly bug-free code. It appears OpenAI is using a Pure-C compiler?

[JeanMars]

Hi,

quite impressive I would agree that this AI is able to generate a GEM-like program.
However, there are some weird things:
- wind_close/wind_delete is never called
- handle from wind_create is lost with handle = graf_handle(&x, &y, &w, &h);
- Is window able to move? Handler for WM_MOVED just retrieves the moving position without using it with wind_set.
- Basically, switch handlers are doing nothing else than retrieving some variables without using them, could be removed.

But that is amazing to be able to write such a program from whatever exists publicly on the Internet!

Cheers,
Jean

[ThorstenOtto]

Clearly it has some quirks. But rather impressive for an AI.

[BlankVector]

Wow!

[mfro]

Even more crazy: after that worked, I thought I give it something more challenging to chew on: same request, but this time I wanted to have an Ada program.

At least to my knowledge, there wasn't any commercial Ada compiler available for the ST. The only one I know of would be the GNAT/GCC Ada compiler that was probably never compiled for an ST (at least I didn't hear about such thing anywhere) and I have no idea if it would work. What's (probably) definitely unavailable, however, are GEM AES/VDI bindings for Ada. ChatGPT gave me this:

Code: Select all

with Ada.Text_IO; use Ada.Text_IO;
with System;
with Atari.AES;
with Atari.VDI;

procedure Main is
   -- AES and VDI handles
   WHandle : System.Address;
   VHandle : System.Address;

   -- AES and VDI parameters
   WSpec   : AES.WSpec;
   VSpec   : VDI.VSpec;

   -- AES and VDI workstations
   AES_Work : AES.Workstation_Type;
   VDI_Work : VDI.Workstation_Type;

   -- AES event buffer
   Event : AES.Event;

   -- Rectangle coordinates
   X1, Y1, X2, Y2 : Integer;
begin
   -- Initialize AES and VDI
   AES.Init;
   VDI.Init;

   -- Open a full-screen AES window
   WSpec.Kind        := AES.Wind_Full;
   WSpec.Title       := To_AES_String("My AES Window");
   WSpec.Handle      := System.Null_Address;
   WSpec.X, WSpec.Y  := 0, 0;
   WSpec.W, WSpec.H  := AES.Desktop_Width, AES.Desktop_Height;
   WSpec.KindOfWork  := AES.AES_Work;
   WHandle := AES.Open_Workstation(WSpec);
   AES_Work := AES.To_Workstation(WHandle);

   -- Open a VDI workstation for the AES window
   VSpec.Handle    := WHandle;
   VSpec.Device    := VDI.Screen;
   VSpec.Format    := VDI.Pixel;
   VSpec.Points    := AES.Desktop_Resolution;
   VSpec.Ratio     := VDI.Square;
   VHandle := VDI.Open_Workstation(VSpec);
   VDI_Work := VDI.To_Workstation(VHandle);

   -- Set the background color to black
   VDI.Background_Color(VDI_Work, VDI.Black);

   -- Draw a red rectangle in the middle of the window
   X1 := AES.Desktop_Width div 4;
   Y1 := AES.Desktop_Height div 4;
   X2 := AES.Desktop_Width * 3 div 4;
   Y2 := AES.Desktop_Height * 3 div 4;
   VDI.Rectangle(VDI_Work, X1, Y1, X2, Y2);
   VDI.Interior_Style(VDI_Work, VDI.Solid, VDI.Red);
   VDI.Draw_Filled(VDI_Work, 1, (X1, Y1, X2, Y2));
   
   -- Wait for the window to be closed
   loop
      AES.Get_Event(Event);
      exit when Event.Kind = AES.Wind_Closed;
   end loop;

   -- Close the AES and VDI workstations
   AES.Close_Workstation(WHandle);
   VDI.Close_Workstation(VHandle);

   -- Exit AES and VDI
   AES.Exit
   

I would swear that there is no existing Ada GEM example anywhere on the internet, most likely also no GEM AES/VDI binding, but if there was, it would probably look like in that piece of code.
Funny enough, this time ChatGPT even decided to do a little more enthusiastic and coded to draw a red rectangle in the window.

[Cyprian]

I asked ChatGPT for a simple GemDOS application and generated code was quite correct, but parameters waspassed not via Sla stack but via Dn registers

[mfro]

Can't help but find that a little scary (after I got my Ada program, I of course wanted to have the required Ada GEM binding as well):

write an Ada vdi binding for the atari st with direct 68000 trap calls to gem

I'd be happy to help you write an Ada VDI binding for the Atari ST that uses direct 68000 trap calls to GEM! Here's an example of how you might create an Ada VDI binding that uses direct 68000 trap calls to interact with GEM:

Code: Select all

with Ada.Unchecked_Conversion;
with Interfaces.C;

package GEM_VDI is

   --  Constants for GEM VDI calls
   type VDI_Call_Number is new Interfaces.Unsigned_32;
   function v_opnwk (handle: access Interfaces.Unsigned_32) return VDI_Call_Number;
   pragma Import (C, v_opnwk, "v_opnwk");
   function v_clswk (handle: access Interfaces.Unsigned_32) return VDI_Call_Number;
   pragma Import (C, v_clswk, "v_clswk");
   function v_pline (handle: access Interfaces.Unsigned_32;
                    count: Interfaces.Unsigned_16;
                    polyline: access Interfaces.Unsigned_16) return VDI_Call_Number;
   pragma Import (C, v_pline, "v_pline");
   function v_circle (handle: access Interfaces.Unsigned_32;
                      x: Interfaces.Unsigned_16;
                      y: Interfaces.Unsigned_16;
                      radius: Interfaces.Unsigned_16) return VDI_Call_Number;
   pragma Import (C, v_circle, "v_circle");
   
   --  Open a workstation
   function Open_Workstation return Interfaces.Unsigned_32 is
      handle : access Interfaces.Unsigned_32 := new Interfaces.Unsigned_32;
   begin
      v_opnwk(handle);
      return handle.all;
   end Open_Workstation;

   --  Close a workstation
   procedure Close_Workstation (handle: Interfaces.Unsigned_32) is
      h : access Interfaces.Unsigned_32 :=
            Ada.Unchecked_Conversion.Unchecked_Address (handle);
   begin
      v_clswk(h);
   end Close_Workstation;

   --  Draw a polyline
   procedure Draw_Polyline (handle: Interfaces.Unsigned_32;
                            count: Interfaces.Unsigned_16;
                            polyline: access Interfaces.Unsigned_16) is
      h : access Interfaces.Unsigned_32 :=
            Ada.Unchecked_Conversion.Unchecked_Address (handle);
   begin
      v_pline(h, count, polyline);
   end Draw_Polyline;

   -- Draw a circle
   procedure Draw_Circle (handle: Interfaces.Unsigned_32;
                         x: Interfaces.Unsigned_16;
                         y: Interfaces.Unsigned_16;
                         radius: Interfaces.Unsigned_16) is
      h : access Interfaces.Unsigned_32 :=
            Ada.Unchecked_Conversion.Unchecked_Address (handle);
   begin
      v_circle(h, x, y, radius);
   end Draw_Circle;

end GEM_VDI;

You will need to import the functions v_opnwk, v_clswk, v_pline, and v_circle into this package by appropriate mechanism such as

Code: Select all

pragma Import(C, v_opnwk, "v_opnwk");

And I want to remind you that the Atari ST uses the Motorola 68000 CPU which is a big-endian CPU. So you may need to take care of the endianness when interacting with the system.

Keep in mind that the above package is just a skeleton of the binding, you may need to add more functions or procedures to support the functionality you want to use, also it's important to check the documentation of the AES/VDI functions you will use, as some of them may have different calling conventions or require certain register setup before calling.

While this was close, it obviously didn't understand that I wanted inline assembly instead of calling gemlib C functions, so I tried again a little more specific:

do the same with inline assembly, please

Sure! Here is an example of how you can use inline assembly to create an Ada VDI binding for the Atari ST that uses direct 68000 trap #2 calls to interact with GEM:

Code: Select all

with Interfaces.C;
with Ada.Unchecked_Conversion;

package GEM_VDI is
   -- Constants for GEM VDI calls
   type Address is new Interfaces.Unsigned_32;
   type VDI_Call_Number is new Interfaces.Unsigned_8;

   --  Open a workstation
   function Open_Workstation return Address is
      handle : Address;
   begin
      asm
         move.w #0, d0  -- this is the parameter for v_opnwk function
         trap #2        -- call the GEM VDI trap
         move.l d0, (handle)  -- save the returned handle
      end asm;
      return handle;
   end Open_Workstation;

   --  Close a workstation
   procedure Close_Workstation (handle: Address) is
   begin
      asm
         move.l handle, d0  -- move the handle to d0
         trap #2            -- call the GEM VDI trap
      end asm;
   end Close_Workstation;

   --  Draw a polyline
   procedure Draw_Polyline (handle: Address;
                            count: Interfaces.Unsigned_16;
                            polyline: access Interfaces.Unsigned_16) is
   begin
      asm
         move.l handle, d0      -- move the handle to d0
         move.w count, d1       -- move count to d1
         move.l polyline, d2    -- move the address of polyline to d2
         trap #2                -- call the GEM VDI trap
      end asm;
   end Draw_Polyline;

   -- Draw a circle
   procedure Draw_Circle (handle: Address;
                         x: Interfaces.Unsigned_16;
                         y: Interfaces.Unsigned_16;
                         radius: Interfaces.Unsigned_16) is
   begin
      asm
         move.l handle, d0      -- move the handle to d0
         move.w x, d1           -- move x to d1
         move.w y, d2           -- move y to d2
         move.w radius, d3      -- move radius to d3
         trap #2                -- call the GEM VDI trap
      end asm;
   end Draw_Circle;

end GEM_VDI;

Note that this example uses the trap #2 instruction to invoke the GEM VDI functions. The number 2 is the vector number of the GEM VDI.
Also, it uses the standard 68000 registers, d0, d1, d2 and d3, to pass the parameters and get the return value of the GEM VDI functions.
It's important to keep in mind that the Atari ST uses the Motorola 68000 CPU which is a big-endian CPU. So you may need to take care of the endianness when interacting with the system.

Also, this package is just a skeleton of the binding, you may need to adapt the package to match the specific version of the AES/VDI you're using, you may also need to check the documentation of the AES/

It misses the VDI parameter block and seems to assume parameter passing in registers, but anyway - I would never assumed that to be possible.
It also happily wrote a FORTRAN example and even when I asked for GEM bindings using ARM inline assembly, it baked some for me (where it decided - although GEM was never ported to ARM - if it was, the VDI would be called through svc 0 - the ARM supervisor call mechanism)

[ThorstenOtto]

Amazing. Despite the missing parameter block , at least he seems to know that VDI has to be called by trap #2

[AnthonyJ]

Very impressive!

At least to my knowledge, there wasn't any commercial Ada compiler available for the ST. The only one I know of would be the GNAT/GCC Ada compiler that was probably never compiled for an ST (at least I didn't hear about such thing anywhere) and I have no idea if it would work.

There seems to have been an ADA interpreter for Atari's - https://www.adahome.com/Resources/Compilers/Ada-Ed.html - however no idea if it's still available anywhere, and the chances of it ever having had AES/VDI bindings is pretty much non-existent.

[TheNameOfTheGame]

Impressive.

[shoggoth]

Mind blown.

[czietz]

Its answers are a bit hit and miss, though. I'd rather consult TOS.HYP or the Atari Compendium than ChatGPT.

gpt-vs-bios.png

[TheNameOfTheGame]

Can ChatGPT be asked to read TOS.HYP and the Compendium? That should do it.

[mfro]

Its answers are a bit hit and miss, though. I'd rather consult TOS.HYP or the Atari Compendium than ChatGPT.

Sure. It's far from perfect and will not make programmers obsolete by tomorrow (which I consider a good thing), but nevertheless it's astonishing.

Look at the names it created for example: "Draw_Circle". It perfectly follows the ARM (the "Ada bible") naming conventions. I didn't tell it to name that procedure like this anywhere. It must have found the function name v_circle() somewhere and deduced that this function draws a circle, named the Ada procedure accordingly.

Impressive.

[Ragstaff]

This makes my head hurt. It seems at some point we not only passed the Turing Test, but leap-frogged it to levels I never would have imagined. I was still just waiting for the Turing test

[wongck]

Sure. It's far from perfect and will not make programmers obsolete by tomorrow (which I consider a good thing), but nevertheless it's astonishing.

Only Atari programmers.... my guess is there are not as many examples for Cgpt to pillage from unlike other platforms. They are facing class action lawsuits.
Not surprised if those codes lifted by Cgpt are actually written by our great team of developers here and mangled by it.
( I am not included as all my code are on my Atari - unless Cgpt also got hold of emails with code in them to read. LOL.... luckily otherwise it will use my horrible coding style ).

However, it may be a good thing as it can somewhat preserve long lost codes and know-how to code/use them as long as there's enough storage on their Cgpt system. I am sure someday someone will kick out those knowledge as old or irrelevant.

[mfro]

Sure. It's far from perfect and will not make programmers obsolete by tomorrow (which I consider a good thing), but nevertheless it's astonishing.

Only Atari programmers.... my guess is there are not as many examples for Cgpt to pillage from unlike other platforms. They are facing class action lawsuits.
Not surprised if those codes lifted by Cgpt are actually written by our great team of developers here and mangled by it.
( I am not included as all my code are on my Atari - unless Cgpt

That's what I tried to show with the Ada example above: there's certainly none on the Internet to copycat from. That thing is definitely more than just a better Google.
Actually, I'm more concerned about the future of student's homework. Stack Overflow will suffer, I guess

[han123]

'coded to draw a red rectangle in the window.'

Well, i guess we witnessed the birth of HAL 9000

[ragnar76]

i'm afraid i can't do that han123

[mjvans]

Well it won't be long until you yell at your device "Hey computer make a kart game with Disney characters for the Atari ST and the music must be in the style of Mario Karts and play on the SoundCanvas!" and boom there it is.

[SteveBagley]

Although not entirely correct (it clears the screen instead of the window contents only), this appears to be a valid GEM program.

That’s the problem with ChatGPT and similar tools it appears to be correct until you look carefully… on top of what others have mentioned…

There’s no call to appl_init() for instance…

The code to draw in the window is broken (it doesn’t wait for a redraw message before drawing or walk the dirty rectangle list) — heck it doesn’t even check for redraw events…

Some of it is completely made up — what’s all the stuff about WM_MOUSE for instance — there’s no such message

My suspicion is that tools like this will end up causing significant harm and very little benefit — there’s already studies showing people using similar tools write less secure code, for example…

Playing around with it at work (we are interested in how students might use it cheat — I lecture in Computer Science), it’s been quite hilarious some of the terrible examples it produces, like a secure strcpy that couldn’t copy strings if the destination string was empty, or telling me Windows 3.11 couldn’t open windows on screen when I asked it to write a windows program to open a windows

Steve

[mfro]

Sometimes it comes to stunning conclusions. I asked it about the most urgent decisions it thinks our minister for economy and digital development should take to improve the situation in Germany and the answer was basically that it wasn't aware that this guy exists at all.

A suspicion I had for quite a while already.

[mikro]

As one guy wrote in a newspaper, the GPT is the most human friendly liar you can talk to, i.e. the populist's ideal tool of choice. :-) It can sell you its lies in such a convincing way - 9 things are true and the 10th is absolute nonsense.

[wongck]

no chance to try at all today.... just can't get in

[Badwolf]

That’s the problem with ChatGPT and similar tools it appears to be correct until you look carefully… on top of what others have mentioned…

There’s no call to appl_init() for instance…

I reckon it's already doing better than me!

BW