FPC 3.2.2 - nested Class and Generic Class - Memory Problem ?

[paule32]

to clearify my problem:   I have it done.

The Problem was more in my Logic, so sorry about blame about FPC.
I get in touch with an overflow problem where Memory points to nowhere.

Here is the working Source Code for "Container.PAS" :

Code: Pascal  [Select][+][-]

1. {$mode objfpc}{$H+}
2. {$modeswitch generics}
3. unit Container;
4.  
5. interface
6.  
7. type
8.   generic TList<T1> = class
9.   private
10.     FValue  : T1;
11.     FTop    : specialize TList<T1>;
12.     FBottom : specialize TList<T1>;
13.     FPrev   : specialize TList<T1>;
14.     FNext   : specialize TList<T1>;
15.     FCount  : Integer;
16.   type
17.     Enumerator = class
18.     private
19.       FCurrent : specialize TList<T1>;
20.       FHead    : specialize TList<T1>;
21.     public
22.       constructor Create(AList: specialize TList<T1>);
23.       function GetCurrent: T1;
24.       function MoveNext: Boolean;
25.       property Current: T1 read GetCurrent;
26.     end;
27.     ReverseEnumerator = class
28.     private
29.       FCurrent: specialize TList<T1>;
30.       FStart  : Boolean;
31.     public
32.       constructor Create(AList: specialize TList<T1>);
33.       function MoveNext: Boolean;
34.       function GetCurrent: T1;
35.       property Current: T1 read GetCurrent;
36.     end;
37.   public
38.     constructor Create(AValue: T1);
39.     procedure Add(AValue: T1);
40.    
41.     function GetEnumerator:               Enumerator;
42.     function GetReverseEnumerator: ReverseEnumerator;
43.   published
44.     property Count: Integer read FCount;
45.   end;
46.  
47.   generic TListVector<T1> = class(specialize TList<T1>)
48.   public
49.     constructor Create(AValue: T1);
50.   end;
51.  
52.   generic TMap<T1, T2> = class
53.   private
54.     FValue1 : T1;
55.     FValue2 : T2;
56.     FCount  : Integer;
57.   public
58.     constructor Create(AValue1: T1; AValue2: T2);
59.   end;
60.  
61. implementation
62.  
63. { TListEnumerator }
64. constructor TList.Enumerator.Create(AList: specialize TList<T1>);
65. begin
66.   inherited Create;
67.   FCurrent := nil;
68.   FHead := AList.FTop;
69. end;
70.  
71. function TList.Enumerator.MoveNext: Boolean;
72. begin
73.   if FCurrent = nil then
74.   FCurrent := FHead else
75.   FCurrent := FCurrent.FNext;
76.  
77.   result   := FCurrent <> nil;
78. end;
79.  
80. function TList.Enumerator.GetCurrent: T1;
81. begin
82.   Result := FCurrent.FValue;
83. end;
84.  
85.  
86. { TListReverseEnumerator }
87. constructor TList.ReverseEnumerator.Create(AList: specialize TList<T1>);
88. begin
89.   inherited Create;
90.   FCurrent := AList.FBottom; // Beginne ganz unten
91.   FStart   := false;
92. end;
93.  
94. function TList.ReverseEnumerator.MoveNext: Boolean;
95. begin
96.   if not FStart then
97.   begin
98.     FStart := true;
99.     result := FCurrent <> nil;
100.   end else
101.   begin
102.     if FCurrent <> nil then
103.     FCurrent := FCurrent.FPrev;
104.     result   := FCurrent <> nil;
105.   end;
106. end;
107.  
108. function TList.ReverseEnumerator.GetCurrent: T1;
109. begin
110.   Result := FCurrent.FValue;
111. end;
112.  
113.  
114. { TListVector }
115. constructor TListVector.Create(AValue: T1);
116. begin
117.   inherited Create(AValue);
118. end;
119.  
120.  
121. { TList }
122. constructor TList.Create(AValue: T1);
123. begin
124.   inherited Create;
125.   FValue  := AValue;
126.  
127.   FTop    := self;
128.   FBottom := self;
129.   FNext   := nil;
130.  
131.   FCount  := 1;
132. end;
133.  
134. procedure TList.Add(AValue: T1);
135. var
136.   tmp: specialize TList<T1>;
137. begin
138.   tmp := TList.Create(AValue);
139.   tmp.FPrev     := FBottom;
140.  
141.   FBottom.FNext := tmp;
142.   FBottom       := tmp;
143.  
144.   inc(FCount);
145. end;
146.  
147. function TList.GetEnumerator:                     Enumerator; begin result :=        Enumerator.Create(Self); end;
148. function TList.GetReverseEnumerator: TList.ReverseEnumerator; begin result := ReverseEnumerator.Create(Self); end;
149.  
150. constructor TMap.Create(AValue1: T1; AValue2: T2);
151. begin
152.   inherited Create;
153. end;
154.  
155. end.

When you would like to use it, there is the below Source:

Code: Pascal  [Select][+][-]

1. type
2.   TVector        = specialize TListVector< Integer >;
3.   TVectorReverse = TVector.ReverseEnumerator;
4.  
5. var
6.   V     : TVector;
7.   REnum : TVectorReverse;
8.  
9. var
10.   item: Integer;
11.  
12. begin
13.   V := TVector.Create(12);
14.   V.Add(2);
15.   V.Add(3);
16.   V.Add(4);
17.  
18.   for item in V do
19.   writeln('Value: ', IntToStr(item));
20.  
21.   REnum := V.GetReverseEnumerator;
22.   while REnum.MoveNext do
23.   writeln('Value: ', intToStr(REnum.Current));
24.  
25.   REnum.Free;
26.   V.Free;
27. end.

compiled, you will get the follow Output:

Code: Bash  [Select][+][-]

1. Value: 12
2. Value: 2
3. Value: 3
4. Value: 4
5.  
6. Value: 4
7. Value: 3
8. Value: 2
9. Value: 12

So, Problem solved.
Thanks for all your Hints...

[Thaddy]

That's is exactly what I told you. Then it works. But why so many threads on the same subject?
Should we just call the threads Paule32?