comp.lang.ada
 help / color / mirror / Atom feed
* CONSTRAINT ERROR: erroneous memory access
@ 2020-06-06 23:40 jcupak
  2020-06-07  8:00 ` Egil H H
                   ` (2 more replies)
  0 siblings, 3 replies; 9+ messages in thread
From: jcupak @ 2020-06-06 23:40 UTC (permalink / raw)


It has been a few years since I have written Ada; I used and taught Ada 95 back when I was working for a defense contractor. But, now that I'm retired, I wanted to get up to speed with Ada 2012, so I decided to implement a main program to see how the Shortest_Paths generic package works (taken from A.18.31, pages 574-576). But, when I read in the data and call the Shortest_Path function, it returns with CONSTRAINT ERROR: erroneous memory access. I've tried multiple times, but can't seem to figure out what I'm doing (or NOT doing) wrong. 

Here's the main program:

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Float_Text_IO;   use Ada.Float_Text_IO;
with Ada.Text_IO;         use Ada.Text_IO;
with Shortest_Paths;
with Ada.Command_Line;    use Ada.Command_Line;
with DirectedEdge;        use DirectedEdge;
with Ada.Containers;      use Ada.Containers;
with Ada.Exceptions;

procedure Main_Test is

   Input_File : Ada.Text_IO.File_Type;

   Vertices   : Integer; -- Number of nodes
   Edges      : Integer; -- Number of paths

   Tail       : Integer; -- Node From
   Head       : Integer; -- Node To
   Weight     : Float;   -- Path Weight/Distance/Cost

   -- Instantiate Shortest Paths package with 0..Integer'Last subtype
   package SP is new Shortest_Paths(Node => Natural);
   
   -- Use Edge'Read to read the Edge components into Item
   
   -- Display directed edge components
   procedure Display(Edge : in SP.Edge) is
   begin
      Put(Edge.From, Width=>1); Put("->");
      Put(Edge.To,   Width=>1); Put(" ");
      Put(Float(Edge.Length), Fore => 0, Aft => 2, Exp => 0); Put(" ");
   end Display;

   -- Display directed edge components at cursor
   -- Replace List'Write with Display
   procedure Display(Cursor: in SP.Adjacency_Lists.Cursor)
   is
      Edge : SP.Edge := SP.Adjacency_Lists.Element(Cursor);
   begin
      Display(Edge); -- Let other procedure do all the work
   end Display;

begin

-- Open input file using arg 1
   Open (File => Input_File,
         Mode => In_File,
         Name => Argument(1)); -- ../tinyEWD.txt

   Set_Input(Input_File);        -- Redirect input
   New_Line;
   Put("Processing '"); Put(Argument(1)); Put_Line("'");

   -- Read number of nodes (vertices)
   Get(Vertices); New_Line;
   Put("Vertices: ");Put(Vertices, width=>2);New_Line;

   -- Read number of paths (edges)
   Get(Edges);
   Put("Edges:    ");Put(Edges, Width=>2);New_Line(2);

   declare
   
      -- Constrain Vertex to zero-based subrange
      subtype Vertex is Natural range 0..Vertices-1;
      
      -- Adj is DLL of Adjacency Lists for each Vertex
      Adj    : array (Vertex) of SP.Adjacency_Lists.List;
      
      -- Edge is a record of Tail, Head, and Weight components
      Edge   : SP.Edge;
   
   begin
   
      Put_Line("Creating Adjacency Lists"); New_Line;
   
      -- For each node, create empty list of adjacent nodes
      Create_Empty_Adjacency_Lists: for Node in Vertex loop
      
         -- Initialize each adjacency list to empty
         Adj(Node) := SP.Adjacency_Lists.Empty_List;
      
      end loop Create_Empty_Adjacency_Lists;
   
      -- Display and append new edge to adjacency list for node
      -- Constrain Edge index to natural subrange
      Append_New_Edge: for E in 0..Edges-1 loop
      
         Put("Edge:     ");Put(E, Width=>2);Put(" ");
      
         -- Get edge components from data file
         Get(Tail);   -- Tail
         Get(Head);   -- Head
         Get(Weight); -- Distance/Weight
      
         -- Set edge components
         Edge.From   := Tail;
         Edge.To     := Head;
         Edge.Length := SP.Distance(Weight);
      
         -- Display Edge
         Display(Edge);
         Put(" Appended to edge ");Put(Tail,1);
         New_Line;
      
         -- Append new edge to From adjacency list
         -- Indicating path to another node
         Adj(Edge.From).Append(Edge);
      
      end loop Append_New_Edge;
      New_Line;
   
      Close(Input_File);
      Set_Input(Standard_Input); -- Reset input source
   
      Put_Line("Node Adjacency Lists");
   
      -- Display contents of each adjacency list
      Display_Adjacency_Lists: for Node in Vertex loop
      
         Put("Adj[");Put(Node, Width=>1);Put("] ");
      
         declare
            Edges  : Ada.Containers.Count_Type;
         begin
         
            -- How many edges are in this node?
            Edges := SP.Adjacency_Lists.Length(Adj(Node));
            Put(Integer(Edges), Width => 1);
            if (Edges > 1) then
               Put(" Edges: ");
            else
               Put(" Edge:  ");
            end if;
         
            -- Iterate over all nodes in this adjacency list
            -- and Display each edge for each node
            SP.Adjacency_Lists.Iterate(Adj(Node), Process => Display'Access);
         
         end;
         New_Line;
      
      end loop Display_Adjacency_Lists;
      New_Line;
   
      -- Create Edge-Weighted Graph of Node and Adjacency List
      declare
         EWG    : SP.Graphs.Vector; -- Edge Weighted Graphs
         Path   : SP.Paths.List;    -- Shortest Path
      begin
      
         Put_Line("Creating Edge-Weighted Graphs.");
         EWG := SP.Graphs.Empty_Vector;
         Put_Line("EWG Empty_Vector created.");
         
         Put("Initializing Shortest Path to empty list...");
         Path := SP.Paths.Empty_List;
         Put_Line("done.");
         
         for Vertex in 0..Vertices-1 loop
            Put("Vertex: ");Put(Vertex, Width => 1);
            EWG.Append(Adj(Vertex));
            Put_Line(" appended to EWG.");
         end loop;
         New_Line;
         
         Put("EWG.Length = "); Put(Integer(EWG.Length), Width => 1);New_Line;
      
         Put_Line("Finding shortest path from node 0 to node 6");
         declare
            use Ada.Exceptions;
         begin
            -- Compute Shortest Path
            Path := SP.Shortest_Path
               (EWG, Source => 0, Target => 6);
            exception
               when Error: others =>
                  New_Line;
                  Put_Line(Exception_Name(Error));
                  Put_Line(Exception_Message(Error));
                  New_Line;
                  Return;
         end;
      
         Put("The Shortest Path from Node 0 to Node 6 ");
         Put("contains "); Put(Integer(Path.Length)); Put(" entries.");
         -- Display path
      end;
   
   
   end;

end Main_Test;

And here's the test data (taken from Algorithms, by Sedwick):

8
15
4 5 0.35
5 4 0.35
4 7 0.37
5 7 0.28
7 5 0.28
5 1 0.32
0 4 0.38
0 2 0.26
7 3 0.39
1 3 0.29
2 7 0.34
6 2 0.40
3 6 0.52
6 0 0.58
6 4 0.93

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access
  2020-06-06 23:40 CONSTRAINT ERROR: erroneous memory access jcupak
@ 2020-06-07  8:00 ` Egil H H
  2020-06-09  0:39   ` CONSTRAINT ERROR: erroneous memory access - SOLVED John Cupak
  2020-06-07  8:51 ` CONSTRAINT ERROR: erroneous memory access Jeffrey R. Carter
  2020-06-07 15:53 ` Anh Vo
  2 siblings, 1 reply; 9+ messages in thread
From: Egil H H @ 2020-06-07  8:00 UTC (permalink / raw)


On Sunday, June 7, 2020 at 1:40:04 AM UTC+2, jcu...@gmail.com wrote:
> It has been a few years since I have written Ada; I used and taught Ada 95 back when I was working for a defense contractor. But, now that I'm retired, I wanted to get up to speed with Ada 2012, so I decided to implement a main program to see how the Shortest_Paths generic package works (taken from A.18.31, pages 574-576). But, when I read in the data and call the Shortest_Path function, it returns with CONSTRAINT ERROR: erroneous memory access. I've tried multiple times, but can't seem to figure out what I'm doing (or NOT doing) wrong. 
>


If you look at the body of Shortest_Path, you'll see multiple declarations of arrays with Node as the Index type. In your case, Node is of type Natural, resulting in a huge stack allocation.

If you instead move the instantiation of SP (and the Display procedures, which depends on the instantiation) to after the declaration of the subtype Vertex, and then use that subtype as Node instead of Natural, the stack allocation will be reduced significantly.

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access
  2020-06-06 23:40 CONSTRAINT ERROR: erroneous memory access jcupak
  2020-06-07  8:00 ` Egil H H
@ 2020-06-07  8:51 ` Jeffrey R. Carter
  2020-06-07 10:20   ` Simon Wright
  2020-06-07 15:53 ` Anh Vo
  2 siblings, 1 reply; 9+ messages in thread
From: Jeffrey R. Carter @ 2020-06-07  8:51 UTC (permalink / raw)


On 6/7/20 1:40 AM, jcupak@gmail.com wrote:
> It has been a few years since I have written Ada; I used and taught Ada 95 back when I was working for a defense contractor. But, now that I'm retired, I wanted to get up to speed with Ada 2012, so I decided to implement a main program to see how the Shortest_Paths generic package works (taken from A.18.31, pages 574-576). But, when I read in the data and call the Shortest_Path function, it returns with CONSTRAINT ERROR: erroneous memory access. I've tried multiple times, but can't seem to figure out what I'm doing (or NOT doing) wrong.

Actually ARM A.18.32: 
http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-A-18-32.html

Since you're using Ada 12, you must be using GNAT. With its default options, 
GNAT is not an Ada compiler. You need to add -gnatan -fstack-check to obtain 
full Ada semantics. (Technically, you also need -gnatE, but that doesn't affect 
the behavior of a properly elaborated program.) With those options, I suspect 
you'll get Storage_Error, which might be easier to understand.

-- 
Jeff Carter
"How'd you like to hide the egg and gurgitate
a few saucers of mocha java?"
Never Give a Sucker an Even Break
101

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access
  2020-06-07  8:51 ` CONSTRAINT ERROR: erroneous memory access Jeffrey R. Carter
@ 2020-06-07 10:20   ` Simon Wright
  2020-06-07 14:47     ` Jeffrey R. Carter
  0 siblings, 1 reply; 9+ messages in thread
From: Simon Wright @ 2020-06-07 10:20 UTC (permalink / raw)


"Jeffrey R. Carter" <spam.jrcarter.not@spam.not.acm.org> writes:

> You need to add -gnatan -fstack-check to obtain full Ada semantics.

Not quibbling with -fstack-check, but why the others?

-gnata, enable assertions: the RM doesn't say what the effect of an
assertion should be absent any Assertion_Policy, and if
Assertion_Policy is present it overrides the absence of -gnata

-gnatn, enables pragma Inline across units: Inline only specifies that
inline expansion is desired.

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access
  2020-06-07 10:20   ` Simon Wright
@ 2020-06-07 14:47     ` Jeffrey R. Carter
  0 siblings, 0 replies; 9+ messages in thread
From: Jeffrey R. Carter @ 2020-06-07 14:47 UTC (permalink / raw)


On 6/7/20 12:20 PM, Simon Wright wrote:
> 
> Not quibbling with -fstack-check, but why the others?
> 
> -gnata, enable assertions: the RM doesn't say what the effect of an
> assertion should be absent any Assertion_Policy, and if
> Assertion_Policy is present it overrides the absence of -gnata

While it's true that the default assertion policy is implementation defined, the 
Ada Way (TM) is for all checks to be active by default, so I'm correcting the 
ARM. Also, it doesn't make sense to put in checks and not check them.

> -gnatn, enables pragma Inline across units: Inline only specifies that
> inline expansion is desired.

While inlining is always at the compiler's discretion, the ARM makes no 
distinction between inlining within a unit and inlining across units, so an Ada 
compiler doesn't, either.

-- 
Jeff Carter
"How'd you like to hide the egg and gurgitate
a few saucers of mocha java?"
Never Give a Sucker an Even Break
101

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access
  2020-06-06 23:40 CONSTRAINT ERROR: erroneous memory access jcupak
  2020-06-07  8:00 ` Egil H H
  2020-06-07  8:51 ` CONSTRAINT ERROR: erroneous memory access Jeffrey R. Carter
@ 2020-06-07 15:53 ` Anh Vo
  2020-06-07 16:17   ` Egil H H
  2 siblings, 1 reply; 9+ messages in thread
From: Anh Vo @ 2020-06-07 15:53 UTC (permalink / raw)


On Saturday, June 6, 2020 at 4:40:04 PM UTC-7, jcu...@gmail.com wrote:
> It has been a few years since I have written Ada; I used and taught Ada 95 back when I was working for a defense contractor. But, now that I'm retired, I wanted to get up to speed with Ada 2012, so I decided to implement a main program to see how the Shortest_Paths generic package works (taken from A.18.31, pages 574-576). But, when I read in the data and call the Shortest_Path function, it returns with CONSTRAINT ERROR: erroneous memory access. I've tried multiple times, but can't seem to figure out what I'm doing (or NOT doing) wrong. 
> 
> Here's the main program:
> 
> with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
> with Ada.Float_Text_IO;   use Ada.Float_Text_IO;
> with Ada.Text_IO;         use Ada.Text_IO;
> with Shortest_Paths;
> with Ada.Command_Line;    use Ada.Command_Line;
> with DirectedEdge;        use DirectedEdge;
> with Ada.Containers;      use Ada.Containers;
> with Ada.Exceptions;
> 
> procedure Main_Test is
> 
>    Input_File : Ada.Text_IO.File_Type;
> 
>    Vertices   : Integer; -- Number of nodes
>    Edges      : Integer; -- Number of paths
> 
>    Tail       : Integer; -- Node From
>    Head       : Integer; -- Node To
>    Weight     : Float;   -- Path Weight/Distance/Cost
> 
>    -- Instantiate Shortest Paths package with 0..Integer'Last subtype
>    package SP is new Shortest_Paths(Node => Natural);
>    
>    -- Use Edge'Read to read the Edge components into Item
>    
>    -- Display directed edge components
>    procedure Display(Edge : in SP.Edge) is
>    begin
>       Put(Edge.From, Width=>1); Put("->");
>       Put(Edge.To,   Width=>1); Put(" ");
>       Put(Float(Edge.Length), Fore => 0, Aft => 2, Exp => 0); Put(" ");
>    end Display;
> 
>    -- Display directed edge components at cursor
>    -- Replace List'Write with Display
>    procedure Display(Cursor: in SP.Adjacency_Lists.Cursor)
>    is
>       Edge : SP.Edge := SP.Adjacency_Lists.Element(Cursor);
>    begin
>       Display(Edge); -- Let other procedure do all the work
>    end Display;
> 
> begin
> 
> -- Open input file using arg 1
>    Open (File => Input_File,
>          Mode => In_File,
>          Name => Argument(1)); -- ../tinyEWD.txt
> 
>    Set_Input(Input_File);        -- Redirect input
>    New_Line;
>    Put("Processing '"); Put(Argument(1)); Put_Line("'");
> 
>    -- Read number of nodes (vertices)
>    Get(Vertices); New_Line;
>    Put("Vertices: ");Put(Vertices, width=>2);New_Line;
> 
>    -- Read number of paths (edges)
>    Get(Edges);
>    Put("Edges:    ");Put(Edges, Width=>2);New_Line(2);
> 
>    declare
>    
>       -- Constrain Vertex to zero-based subrange
>       subtype Vertex is Natural range 0..Vertices-1;
>       
>       -- Adj is DLL of Adjacency Lists for each Vertex
>       Adj    : array (Vertex) of SP.Adjacency_Lists.List;
>       
>       -- Edge is a record of Tail, Head, and Weight components
>       Edge   : SP.Edge;
>    
>    begin
>    
>       Put_Line("Creating Adjacency Lists"); New_Line;
>    
>       -- For each node, create empty list of adjacent nodes
>       Create_Empty_Adjacency_Lists: for Node in Vertex loop
>       
>          -- Initialize each adjacency list to empty
>          Adj(Node) := SP.Adjacency_Lists.Empty_List;
>       
>       end loop Create_Empty_Adjacency_Lists;
>    
>       -- Display and append new edge to adjacency list for node
>       -- Constrain Edge index to natural subrange
>       Append_New_Edge: for E in 0..Edges-1 loop
>       
>          Put("Edge:     ");Put(E, Width=>2);Put(" ");
>       
>          -- Get edge components from data file
>          Get(Tail);   -- Tail
>          Get(Head);   -- Head
>          Get(Weight); -- Distance/Weight
>       
>          -- Set edge components
>          Edge.From   := Tail;
>          Edge.To     := Head;
>          Edge.Length := SP.Distance(Weight);
>       
>          -- Display Edge
>          Display(Edge);
>          Put(" Appended to edge ");Put(Tail,1);
>          New_Line;
>       
>          -- Append new edge to From adjacency list
>          -- Indicating path to another node
>          Adj(Edge.From).Append(Edge);
>       
>       end loop Append_New_Edge;
>       New_Line;
>    
>       Close(Input_File);
>       Set_Input(Standard_Input); -- Reset input source
>    
>       Put_Line("Node Adjacency Lists");
>    
>       -- Display contents of each adjacency list
>       Display_Adjacency_Lists: for Node in Vertex loop
>       
>          Put("Adj[");Put(Node, Width=>1);Put("] ");
>       
>          declare
>             Edges  : Ada.Containers.Count_Type;
>          begin
>          
>             -- How many edges are in this node?
>             Edges := SP.Adjacency_Lists.Length(Adj(Node));
>             Put(Integer(Edges), Width => 1);
>             if (Edges > 1) then
>                Put(" Edges: ");
>             else
>                Put(" Edge:  ");
>             end if;
>          
>             -- Iterate over all nodes in this adjacency list
>             -- and Display each edge for each node
>             SP.Adjacency_Lists.Iterate(Adj(Node), Process => Display'Access);
>          
>          end;
>          New_Line;
>       
>       end loop Display_Adjacency_Lists;
>       New_Line;
>    
>       -- Create Edge-Weighted Graph of Node and Adjacency List
>       declare
>          EWG    : SP.Graphs.Vector; -- Edge Weighted Graphs
>          Path   : SP.Paths.List;    -- Shortest Path
>       begin
>       
>          Put_Line("Creating Edge-Weighted Graphs.");
>          EWG := SP.Graphs.Empty_Vector;
>          Put_Line("EWG Empty_Vector created.");
>          
>          Put("Initializing Shortest Path to empty list...");
>          Path := SP.Paths.Empty_List;
>          Put_Line("done.");
>          
>          for Vertex in 0..Vertices-1 loop
>             Put("Vertex: ");Put(Vertex, Width => 1);
>             EWG.Append(Adj(Vertex));
>             Put_Line(" appended to EWG.");
>          end loop;
>          New_Line;
>          
>          Put("EWG.Length = "); Put(Integer(EWG.Length), Width => 1);New_Line;
>       
>          Put_Line("Finding shortest path from node 0 to node 6");
>          declare
>             use Ada.Exceptions;
>          begin
>             -- Compute Shortest Path
>             Path := SP.Shortest_Path
>                (EWG, Source => 0, Target => 6);
>             exception
>                when Error: others =>
>                   New_Line;
>                   Put_Line(Exception_Name(Error));
>                   Put_Line(Exception_Message(Error));
>                   New_Line;
>                   Return;
>          end;
>       
>          Put("The Shortest Path from Node 0 to Node 6 ");
>          Put("contains "); Put(Integer(Path.Length)); Put(" entries.");
>          -- Display path
>       end;
>    
>    
>    end;
> 
> end Main_Test;
> 
> And here's the test data (taken from Algorithms, by Sedwick):
> 
> 8
> 15
> 4 5 0.35
> 5 4 0.35
> 4 7 0.37
> 5 7 0.28
> 7 5 0.28
> 5 1 0.32
> 0 4 0.38
> 0 2 0.26
> 7 3 0.39
> 1 3 0.29
> 2 7 0.34
> 6 2 0.40
> 3 6 0.52
> 6 0 0.58
> 6 4 0.93

It is hard to comment without Ada units Shortest_Path and DirectedEdge posted. In other word, your code does not compile.

Anh Vo 

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access
  2020-06-07 15:53 ` Anh Vo
@ 2020-06-07 16:17   ` Egil H H
  0 siblings, 0 replies; 9+ messages in thread
From: Egil H H @ 2020-06-07 16:17 UTC (permalink / raw)


On Sunday, June 7, 2020 at 5:54:00 PM UTC+2, Anh Vo wrote:
> 
> It is hard to comment without Ada units Shortest_Path and DirectedEdge posted. In other word, your code does not compile.
> 
> Anh Vo


The original post referred to the RM for Shortest_Paths. 
(The AARM has a link to the AI, which has a copy/pasteable version without paragraph numbers)
As for DirectedEdge, the posted code doesn't use anything in it, and will compile just fine when removing the dependency

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access - SOLVED
  2020-06-07  8:00 ` Egil H H
@ 2020-06-09  0:39   ` John Cupak
  2020-06-09 10:07     ` AdaMagica
  0 siblings, 1 reply; 9+ messages in thread
From: John Cupak @ 2020-06-09  0:39 UTC (permalink / raw)


First of all, I'd like to thank all the nice Ada Experts who responded to my post.

After moving the instantiation of SP after the declaration of the subtype Vertex is Natural range 0..Vertices-1, the procedure worked. I removed the Directed_Edge, as I embedded the code as Display procedures. 

The tinyEWD.txt data file was taken from Sedwick's Algorithms, and when used to run the main program, the results did NOT correspond the output in Sedwick's. After a little digging, I discovered an error in the Shortest_Paths.adb package on page 575 of the ARM.

Near the end of the package body, in the Rebuild path from target to source, the Prepend (The_Path, N); statement before the while N /= Source loop is missing. When I inserted the statement, recompiled, and ran the main program, the output matched Sedwick's.

Again, many thanks to all suggestions.

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: CONSTRAINT ERROR: erroneous memory access - SOLVED
  2020-06-09  0:39   ` CONSTRAINT ERROR: erroneous memory access - SOLVED John Cupak
@ 2020-06-09 10:07     ` AdaMagica
  0 siblings, 0 replies; 9+ messages in thread
From: AdaMagica @ 2020-06-09 10:07 UTC (permalink / raw)


Am Dienstag, 9. Juni 2020 02:39:34 UTC+2 schrieb John Cupak:
> After a little digging, I discovered an error in the Shortest_Paths.adb package on page 575 of the ARM.
> 
> Near the end of the package body, in the Rebuild path from target to source, the Prepend (The_Path, N); statement before the while N /= Source loop is missing. When I inserted the statement, recompiled, and ran the main program, the output matched Sedwick's.

You should report this to Ada Comment, how to do it see
http://www.ada-auth.org/standards/2xrm/html/RM-0-2.html (60/5)
so that this will be corrected in the next edition.

Please indicate exactly where to correct. This is the current version:

19/3  -- Rebuild path from target to source.
20/3  declare
         N : Node := Target;
      begin
         while N /= Source loop
            N := Reached_From(N);
            Prepend (The_Path, N);
         end loop;
      end;

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2020-06-09 10:07 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-06-06 23:40 CONSTRAINT ERROR: erroneous memory access jcupak
2020-06-07  8:00 ` Egil H H
2020-06-09  0:39   ` CONSTRAINT ERROR: erroneous memory access - SOLVED John Cupak
2020-06-09 10:07     ` AdaMagica
2020-06-07  8:51 ` CONSTRAINT ERROR: erroneous memory access Jeffrey R. Carter
2020-06-07 10:20   ` Simon Wright
2020-06-07 14:47     ` Jeffrey R. Carter
2020-06-07 15:53 ` Anh Vo
2020-06-07 16:17   ` Egil H H

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox