304c304,306
< Guide section of this manual fairly
---
> Guide
> section of this manual fairly
> 
376,378c378
< \item As an archive, downloaded from the internet. The original sources from
< Soletta are on the following CVS repository on SourceForge:
< \url{http://cvs.sourceforge.net/viewcvs.py/decal/}
---
> \item As an archive, downloaded from the internet
737c737
<   For I := 0 to list.count - 1 do
---
>   For I := 0 to list.count -- 1 do
742c742
<   For I := 0 to list.count - 1 do
---
>   For I := 0 to list.count -- 1 do
826c826
< Function GenMix(ptr : Pointer) : DObject;
---
> Procedure GenMix;
839c839
<   case obj.vtype of
---
>   case obj.vtype of}
932c932
< the objects (it is a \emph{shallow} copy of the arr container).
---
> the objects (it is a \`{\i}shallow\^{\i} copy of a the arr container).
1062c1062
< \section{Lesson 5 -- Using Maps (Key-Value Pairs)}
---
> \section{Lesson 5 -- Using Maps (Key-Value Pairs}
1163c1163
<       Writeln(`Found Ted Jones, whose id is `, emp.id);
---
>       Writeln(`Found Ted Jones, whose id is `, emp.id;
1202c1202
<   For I := 1 to 50 do
---
>   For I := 1 to 50 do}
1280c1280
<   Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee( getObject(obj2)).name);
---
>   Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee( getObject(obj2)).name));
1348c1348
<   For I := 1 to 10 do
---
>   For I := 1 to 10 do}
1402c1402
< Since we really want remove to run fast, we change our data structure
---
> Since we really want that remove to run fast, we change our data structure
1481c1481
<   Result := TEmployee(getObject(obj)).salary >= 50000;
---
>   Result := TEmployee(getObject(obj)).salary $>$= 50000;
1487c1487
<   Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee( getObject(obj2)).name);
---
>   Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee( getObject(obj2)).name));
1639c1639
< Figure 1 shows the SDL container class hierarchy.
---
> Figure 1 shows the SDL container class hierarchy:
1734c1734,1736
< When you retrieve an iterator from one of these containers, the iterator will
---
> When
> 
> you retrieve an iterator from one of these containers, the iterator will
1877,1878c1879,1880
< \textbf{zero} if obj1 equals obj2, and 
< \textbf{greater than zero} if obj1 is greater than obj2.
---
> \textbf{zero} if obj2 equals obj2, and 
> \textbf{greater than zero} if obj2 is greater than obj1.
1885c1887
< ACar := asObject(obj1) as TCar
---
> ACar := asObject(obj1) as TCar}
1893c1895
< Result := TCar(obj1.VObject).FValue - TCar(obj2.VObject).FValue;
---
> Result := TCar(obj2.VObject)^.FValue - TCar(obj1.VObject)^.FValue;
2044c2046
< PushFront(item)
---
> PushFront(item)}
2059c2061
< PopBack
---
> PopBack}
2138,2139c2140,2141
< use the correct form with assertions. Note that it doesn't make any sense to
< try to add elements directly to a map (because you haven't supplied the
---
> use the correct form with assertions. Note that is doesn't make any sense to
> try to add elements directly to a map (because you haven't) supplied the
2141c2143
< to a set (because there isn't any value).
---
> to a set(because there isn't any value).
2164c2166
< them don't need to be overridden -- there are default implementations. Those
---
> them don't need to overridden -- there are default implementations. Those
2182c2184
< \lstinline|Container.add([value]);|
---
> \lstinline$Container.add([value]);$
2216c2218
<     // no advancement necessary - but don't reuse the iterator once 
---
>     // no advancement necessary -- but don't reuse the iterator once 
2238,2239c2240,2242
< \subsection{Why does SDL use functions instead of class members for its algorithms
< (and for iterator operations?)}
---
> \subsection{Why does SDL use functions instead of class members for its algorithms}
> 
> (and for iterator operations?)
2326c2329
< \lstinline|procedure uniqueInWithTo(_start, _end, dest : DIterator; compare : DBinaryTest);|
---
> \lstinline|procedure uniqueInWithTo(\_start, \_end, dest : DIterator; compare : DBinaryTest);|
2338c2341
< procedure forEachIn(_start, _end : DIterator; unary : DApply);
---
> procedure forEachIn(\_start, \_end : DIterator; unary : DApply);
2340c2343
< procedure forEachInIf(_start, _end : DIterator; unary : DApply; test : DTest);
---
> procedure forEachInIf(\_start, \_end : DIterator; unary : DApply; test : DTest);
2354c2357
< given (not including the item at the \_end position).
---
> given (not including the  item at the \_end position).
2366,2367c2369,2370
< function _inject(container : DContainer; const obj : DObject; binary : DBinary) : DObject;
< function _injectIn(_start, _end : DIterator; const obj : DObject; binary : DBinary) : DObject;
---
> function \_inject(container : DContainer; const obj : DObject; binary : DBinary) : DObject;
> function \_injectIn(\_start, \_end : DIterator; const obj : DObject; binary : DBinary) : DObject;
2369c2372
< function injectIn(_start, _end : DIterator; obj : array of const; binary : DBinary) : DObject;
---
> function injectIn(\_start, \_end : DIterator; obj : array of const; binary : DBinary) : DObject;
2413c2416
< function _median(const obj1, obj2, obj3 : DObject; compare : DComparator) : DObject;
---
> function \_median(const obj1, obj2, obj3 : DObject; compare : DComparator) : DObject;
2454,2455c2457,2458
< function copyInTo(_start, _end, output : DIterator) : DIterator;
< function copyBackward(_start, _end, output : DIterator) : DIterator;
---
> function copyInTo(\_start, \_end, output : DIterator) : DIterator;
> function copyBackward(\_start, \_end, output : DIterator) : DIterator;
2461c2464
< \textbf{CopyTo} copies the contents of con1 to the iterator given. The 
---
> \textbf{ CopyTo} copies the contents of con1 to the iterator given. The 
2476c2479
< function countIn(_start, _end : DIterator; objs : array of const) : Integer;
---
> function countIn(\_start, \_end : DIterator; objs : array of const) : Integer;
2478c2481
< function countIfIn(_start, _end : DIterator; test : DTest) : Integer;
---
> function countIfIn(\_start, \_end : DIterator; test : DTest) : Integer;
2489c2492
< \textbf{CountIf}
---
> \textbf{ CountIf}
2493c2496
< \textbf{CountIfIn } determines the number of items in the range \_start to
---
> \textbf{ CountIfIn } determines the number of items in the range \_start to
2502c2505
< procedure fillIn(_start, _end : DIterator; obj : array of const);
---
> procedure fillIn(\_start, \_end : DIterator; obj : array of const);
2519c2522
< procedure generateIn(_start, _end : DIterator; gen : DGenerator);
---
> procedure generateIn(\_start, \_end : DIterator; gen : DGenerator);
2533c2536
< Function uniqueIn(_start, _end : DIterator) : DIterator;
---
> Function uniqueIn(\_start, \_end : DIterator) : DIterator;
2535c2538
< Function uniqueInWith(_start, _end : DIterator; compare : DBinaryTest) : DIterator;
---
> Function uniqueInWith(\_start, \_end : DIterator; compare : DBinaryTest) : DIterator;
2537,2538c2540,2541
< Function uniqueInTo(_start, _end, dest : DIterator) : DIterator;
< Function uniqueInWithTo(_start, _end, dest : DIterator; compare : DBinaryTest) :DIterator;
---
> Function uniqueInTo(\_start, \_end, dest : DIterator) : DIterator;
> Function uniqueInWithTo(\_start, \_end, dest : DIterator; compare : DBinaryTest) :DIterator;
2551c2554
< function FilterInTo(_start, _end, dest : DIterator; test : DTest) : DIterator;
---
> function FilterInTo(\_start, \_end, dest : DIterator; test : DTest) : DIterator;
2566,2567c2569,2570
< function adjacentFindIn(_start, _end : DIterator) : DIterator;
< function adjacentFindInWith(_start, _end : DIterator; compare : DBinaryTest) : DIterator;
---
> function adjacentFindIn(\_start, \_end : DIterator) : DIterator;
> function adjacentFindInWith(\_start, \_end : DIterator; compare : DBinaryTest) : DIterator;
2579c2582
< function binarySearchIn(_start, _end : DIterator; obj : array of const) : DIterator;
---
> function binarySearchIn(\_start, \_end : DIterator; obj : array of const) : DIterator;
2581c2584
< function binarySearchInWith(_start, _end : DIterator; compare : DComparator; obj : array of const) : DIterator;
---
> function binarySearchInWith(\_start, \_end : DIterator; compare : DComparator; obj : array of const) : DIterator;
2592c2595
< function detectInWith(_start, _end : DIterator; compare : DTest) : DIterator;
---
> function detectInWith(\_start, \_end : DIterator; compare : DTest) : DIterator;
2603c2606
< function everyIn(_start, _end : DIterator; test : DTest) : Boolean;
---
> function everyIn(\_start, \_end : DIterator; test : DTest) : Boolean;
2614c2617
< function findIn(_start, _end : DIterator; obj : array of const) : DIterator;
---
> function findIn(\_start, \_end : DIterator; obj : array of const) : DIterator;
2616c2619
< function findIfIn(_start, _end : DIterator; test : DTest) : DIterator;
---
> function findIfIn(\_start, \_end : DIterator; test : DTest) : DIterator;
2627c2630
< function someIn(_start, _end : DIterator; test : DTest) : Boolean;
---
> function someIn(\_start, \_end : DIterator; test : DTest) : Boolean;
2640c2643
< procedure objFreeIn(_start, _end : DIterator);
---
> procedure objFreeIn(\_start, \_end : DIterator);
2650c2653
< procedure objDisposeIn(_start, _end : DIterator);
---
> procedure objDisposeIn(\_start, \_end : DIterator);
2673c2676
< function orderedHashIn(_start, _end : DIterator) : Integer;
---
> function orderedHashIn(\_start, \_end : DIterator) : Integer;
2690c2693
< function unorderedHashIn(_start, _end : DIterator) : Integer;
---
> function unorderedHashIn(\_start, \_end : DIterator) : Integer;
2704c2707
< function removeIn(_start, _end : DIterator; objs : array of const) : DIterator;
---
> function removeIn(\_start, \_end : DIterator; objs : array of const) : DIterator;
2706c2709
< function removeInTo(_start, _end, output : DIterator; objs : array of const) : DIterator;
---
> function removeInTo(\_start, \_end, output : DIterator; objs : array of const) : DIterator;
2718c2721
< function removeCopyIn(_start, _end, output : DIterator; objs : array of const) :DIterator;
---
> function removeCopyIn(\_start, \_end, output : DIterator; objs : array of const) :DIterator;
2721c2724
< function removeCopyIfIn(_start, _end, output : DIterator; test : DTest) : DIterator;
---
> function removeCopyIfIn(\_start, \_end, output : DIterator; test : DTest) : DIterator;
2731c2734
< function removeIfIn(_start, _end : DIterator; test : DTest) : DIterator;
---
> function removeIfIn(\_start, \_end : DIterator; test : DTest) : DIterator;
2733c2736
< function removeIfInTo(_start, _end, output : DIterator; test : DTest) : DIterator;
---
> function removeIfInTo(\_start, \_end, output : DIterator; test : DTest) : DIterator;
2746c2749
< function replaceIn(_start, _end : DIterator; objs1, objs2 : array of const) :Integer;
---
> function replaceIn(\_start, \_end : DIterator; objs1, objs2 : array of const) :Integer;
2758c2761
< function replaceCopyInTo(_start, _end, output : DIterator; objs1, objs2 : array of const) : Integer;
---
> function replaceCopyInTo(\_start, \_end, output : DIterator; objs1, objs2 : array of const) : Integer;
2761c2764
< function replaceCopyIfInTo(_start, _end, output : DIterator; test : DTest; objs :array of const) : Integer;
---
> function replaceCopyIfInTo(\_start, \_end, output : DIterator; test : DTest; objs :array of const) : Integer;
2765c2768
< item that matches obj1 with obj2 as it copies. The If variants use test to
---
> item that matches obj1 with obj2 as it copies. The IF variants use test to
2772c2775
< function replaceIfIn(_start, _end : DIterator; test : DTest; objs : array of const) :Integer;
---
> function replaceIfIn(\_start, \_end : DIterator; test : DTest; objs : array of const) :Integer;
2784c2787
< procedure reverseIn(_start, _end : DIterator);
---
> procedure reverseIn(\_start, \_end : DIterator);
2795c2798
< procedure reverseCopyInTo(_start, _end, output : DIterator);
---
> procedure reverseCopyInTo(\_start, \_end, output : DIterator);
2848a2852
> 
2850a2855
> 
2900c2905
< procedure randomShuffleIn(_start, _end : DIterator);
---
> procedure randomShuffleIn(\_start, \_end : DIterator);
2912c2917
< procedure sortIn(_start, _end : DIterator);
---
> procedure sortIn(\_start, \_end : DIterator);
2914c2919
< procedure sortInWith(_start, _end : DIterator; comparator : DComparator);
---
> procedure sortInWith(\_start, \_end : DIterator; comparator : DComparator);
2926c2931
< procedure stablesortIn(_start, _end : DIterator);
---
> procedure stablesortIn(\_start, \_end : DIterator);
2928c2933
< procedure stablesortInWith(_start, _end : DIterator; comparator : DComparator);
---
> procedure stablesortInWith(\_start, \_end : DIterator; comparator : DComparator);
2931c2936
< StableSort sorts the items in the container or range, and maintains (without
---
> StableSort sorts the items in the container or range, an maintains (without
2962c2967
< function collectIn(_start, _end : DIterator; unary : DUnary) : DContainer;
---
> function collectIn(\_start, \_end : DIterator; unary : DUnary) : DContainer;
2987c2992
< function transformunaryInTo(_start, _finish, output : DIterator; unary : DUnary) :DIterator;
---
> function transformunaryInTo(\_start, \_finish, output : DIterator; unary : DUnary) :DIterator;
2991c2996,2998
< in a container or range, and stores the results in an output area.
---
> in a container or range, and stored
> 
> the results in an output area.
3007c3014,3016
< Object, Class, WideChar, PWideChar, String, Currency, WideString
---
> Object, Class, WideChar,
> 
> PWideChar, String, Currency, WideString
3057c3066,3068
< \lstinline|function JenkinsHashBuffer(const buffer; length : Integer; initVal : Integer) :Integer;|
---
> \begin{lstlisting}
> function JenkinsHashBuffer(const buffer; length : Integer; initVal : Integer) :Integer;
> \end{lstlisting}
3061,3062c3072
< pointer to some variable, and you want to hash the variable, use the \verb|^|
< notation to dereference the pointer.
---
> pointer to some variable, and you want to hash the variable, use the \^ notation.
3070c3080
< Return the hash value for a \textbf{single} value.
---
> Return the hash value for a \textbf{ single} value.
3074c3084
< Return the hash value for a \textbf{double} value.
---
> Return the hash value for a \textbf{ double} value.
3146a3157
> 
3158c3169
< (the first one), Delphi passes an \emph{invisible parameter}, self, as the
---
> (the first one), Delphi passes an \_invisible parameter\_, self, as the
3195c3206
< a_pointer_i_want_to_pass));
---
> a\_pointer\_i\_want\_to\_pass));
3281c3292
< each item. This is nice when you're printing objects.
---
> each item. This is nice when you're print objects.
3287c3298
< SDL contains numerous assertions throughout its code. In the binary release
---
> SDL contains numerous assertions throughout its code.  In the binary release
3294,3295c3305,3306
< normal activity; for this reason, you never need to turn off \emph{break on
< exception} while working with SDL. Most SDL exceptions will contain a
---
> normal activity; for this reason, you never need to turn off \`{\i}break on
> exception\^{\i} while working with SDL. Most SDL exceptions will contain a
3360,3362c3371,3373
<   public
<     s,t : String;
<   end;
---
> 	public
> 	  s,t : String;
> 	end;
3364a3376
> 
3367c3379
< end;
---
> end;}
3422,3426c3434,3438
<   public
<     s,t : String;
<     yipe : Integer;
<     constructor Create;
<   end;
---
>   	 public
>  	  s,t : String;
> 	  yipe : Integer;
> 	  constructor Create;
> 	end;
3428c3440
< constructor TTest.Create;
---
> constructor TTest.Create;}
3430c3442
<   s := `zonk';
---
>   s := `zonk';}
3435a3448
> 
3442,3443c3455,3456
< var
<   test : TTest;
---
> 
> var test : TTest;
3454a3468
> 
3468c3482
< Your transfer function will always receive a pointer \emph{obj} to the
---
> Your transfer function will always receive a pointer (\emph{obj} to the
3480c3494
< know whether a read or write is in progress. \emph{Version} indicates the
---
> know whether a read or write is in progress. \emph{Version } indicates the
3484c3498
< object to the latest version. \emph{CallSuper} is an advanced variable --
---
> object to the latest version. \emph{CallSuper } is an advanced variable --
3498c3512
< function.  The third is the \emph{tip version} of the object. When reading
---
> function.  The third is the \emph{tip version } of the object. When reading
3520c3534
< WriteObjectToFile and ReadObjectInFile are both \emph{class methods}
---
> WriteObjectToFile and ReadObjectInFile are both \emph{class methods }
3548,3551c3562,3565
< TExtra = class(TTest)
<   public
<     d : Integer;
<   end;
---
>   TExtra = class(TTest)
> 	     public
> 	      d : Integer;
> 	     end;
3555c3569
< \textbf{d}, to TTest's definition.
---
> \textbf{ d}, to TTest's definition.
3573c3587
< Now let's create a routine that puts a TTest, a TExtra, and another TTest
---
> Now let's create a routine that puts a TTest, a TExtra, and another TText
3615c3629
< whether it \emph{owns} the stream it is wrapping. If the object stream owns
---
> whether it \emph{owns } the stream it is wrapping. If the object stream owns
3621,3622c3635,3636
< Note that we created the object stream with a \emph{true} value for the
< \emph{owned} parameter. When we free this object stream, it will
---
> Note that we created the object stream with a \emph{true } value for the
> \emph{owned } parameter. When we free this object stream, it will
3644a3659
> 
3646,3649c3661,3664
<     Int1, int2 : Integer;
<     T : TTest;
<     Constructor Create;
<   End;
---
> 	    Int1, int2 : Integer;
> 	    T : TTest;
> 	    Constructor Create;
>    	    End;
3651a3667
> 
3659a3676
> 
3661,3664c3678,3681
<   with obj as TEmbed do
<     stream.TransferItems([int1, int2, t],
<                          [@int1, @int2, @t],
< 		                 direction, version);
---
> with obj as TEmbed do
>   stream.TransferItems([int1, int2, t],
> 	               [@int1, @int2, @t],
> 		       direction, version);
3668,3669c3685,3686
< var
<   e : TEmbed;
---
> 
> var e : TEmbed;
3696,3699d3712
< Type
<   TBase = class
<     I1, i2 : Integer;
<   End;
3701,3703c3714
<   TDerived = class(TBase)
<     S : String;
<   End;
---
> Type
3705,3707c3716,3726
<   TAnother = class(TDerived)
<     Toast : String;
<   End;
---
> TBase = class
> 	  I1, i2 : Integer;
> 	  End;
> 
> TDerived = class(TBase)
> 	     S : String;
> 	     End;
> 
> TAnother = class(TDerived)
> 	     Toast : String;
>  	     End;
3710a3730
> 
3717a3738
> 
3724a3746
> 
3747c3769
<   d.i2 := 201;
---
>   d.i2 := 201;}
3764d3785
< \end{lstlisting}
3769d3789
< \begin{verbatim}
3770a3791
> 
3771a3793
> 
3773c3795
< \end{verbatim}
---
> 
3778c3800
< object, preventing the superclass from doing anything.
---
> object, preventing the subclass from doing anything.
3843c3865
< The two transferItems calls are identical, except for an additional open array
---
> The two transferItems calls are identical, except for an addition open array
3897d3918
< \end{lstlisting}
3900,3901d3920
< 
< \begin{lstlisting}
3923,3928c3942,3947
<   TSpecial = class	
<     Int1, int2 : Integer;
<     St : String;
<     When : TDateTime;
<     R : Single;
<   End;
---
> TSpecial = class	
> 	     Int1, int2 : Integer;
> 	     St : String;
> 	     When : TDateTime;
> 	     R : Single;
> 	   End;
3931a3951
> 
3935,3937c3955,3957
<                            [@when, @r, @int1, @int2, @st],
<                            [ssvtDateTime, ssvtSingle],
<                            direction, version);
---
> 			   [@when, @r, @int1, @int2, @st],
> 		           [ssvtDateTime, ssvtSingle],
> 		           direction, version);
3941,3942c3961,3962
< var
<   s : TSpecial;
---
> 
> var s : TSpecial;
3951c3971
<       s.when := Now;
---
>       s.when := Now;}
3978,3985c3998,4005
<   TRaw = class
<     FNames : Integer;
<     FName : array[1..25] of String;
<     FAddresses : array[1..25] of String;
<     FEmployees : array[1..25] of TEmployee;
<     FBitmapSize : Integer;
<     FBitmapData : Pointer;
<   End;
---
>    TRaw = class
> 	    FNames : Integer;
> 	    FName : array[1..25] of String;
>             FAddresses : array[1..25] of String;
> 	    FEmployees : array[1..25] of TEmployee;
> 	    FBitmapSize : Integer;
> 	    FBitmapData : Pointer;
> 	  End;
3988a4009
> 
3993c4014
<                            direction,version);
---
> 		direction,version);
3995,3996c4016,4017
<                             [@FName[1], @FAddresses[1], @FEmployees[1]],
<                             [25, 25, 25],direction);
---
> 			    [@FName[1], @FAddresses[1], @FEmployees[1]],
> 			    [25, 25, 25],direction);
4004,4005c4025,4026
< var
<   r : TRaw;
---
> 
> var r : TRaw;
4027c4048
< parameters: the \textbf{first} item in each array (which is used to get
---
> parameters: the \textbf{ first} item in each array (which is used to get
4029c4050
< (which is used to figure out where everything is), the \textbf{number} of
---
> (which is used to figure out where everything is), the \textbf{ number } of
4039c4060
< The only wrinkle in this example is that during a \textbf{read}, we need to
---
> The only wrinkle in this example is that during a (\textbf{read}, we need to
4050c4071
< You may have a \emph{complex object graph} -- which is a bunch of objects
---
> You may have a \emph{complex object graph } -- which is a bunch of objects
4063,4065c4084,4086
<     FHello : String;
<     Inside : TTwo;
<   End;
---
>            FHello : String;
> 	   Inside : TTwo;
> 	 End;
4068,4070c4089,4091
<     Inside : TOne;
<     Ouch : String;
<   End;
---
>  	   Inside : TOne;
> 	   Ouch : String;
> 	 End;
4073a4095
> 
4081a4104
> 
4085c4108
<     version);
---
>      version);
4088a4112
> 
4090a4115
> 
4096,4097c4121,4122
<   o.FHello := `hello';
<   o.inside := t;
---
>   o.FHello := `hello';}
>   o.inside := t;}
4122,4124c4147,4149
<     Name, address : String;
<     Salary : Integer;
<   End;
---
> 	         Name, address : String;
> 		 Salary : Integer;
> 	       End;
4127a4153
> 
4131c4157
<                          direction, version);
---
> 					direction, version);
4135,4136c4161,4162
< var
<   a : TAppObject;
---
> 
> var a : TAppObject;
4155,4158c4181,4184
<   TAppObject = class
<     Name, Address : STring;
<     SalaryHigh : Boolean;
<   End;
---
>    TAppObject = class
> 	Name, Address : STring;
> 	SalaryHigh : Boolean;
>    End;
4162,4163c4188,4189
< var
<   oldSalary : Integer;
---
> 
> var oldSalary : Integer;
4168,4174c4194,4200
<            stream.transferItems([name, address, oldSalary],
<                                 [@name, @address,@oldSalary], direction, version);
<            SalaryHigh := oldSalary > HighSalaryValue;
<          end;
<     2: with obj as TAppObject do
<          stream.transferItems([name, address, salaryHigh],
<                               [@name, @address,@salaryHigh], direction, version);
---
> 	   stream.transferItems([name, address, oldSalary], [@name, @address,
> 				@oldSalary], direction, version);
> 
>            SalaryHigh := oldSalary $>$ HighSalaryValue;
> 	 end;
>    2:  with obj as TAppObject do
>  	 stream.transferItems([name, address, salaryHigh], [@name, @address,@salaryHigh], direction, version);
4179,4180c4205,4207
< var
<   a : TAppObject;
---
> 
> var a : TAppObject;
> 
4193c4220
< we just perform conventional IO. If we're reading an old object (which is
---
> we just perform convention IO. If we're reading an old object (which is
4284c4311
< objects. It is a subclass of Delphi's TList class, with an additional property
---
> objects. It is a subclass of Delphi's TList class, with an addition property
