major refactoring.

CryptoLib/src/Asn1/ClpAsn1EncodableVector.pas

@@ -39,7 +39,7 @@ type
     function GetSelf(Index: Int32): IAsn1Encodable;
 
   public
-    class function FromEnumerable(e: TEnumerable<IAsn1Encodable>)
+    class function FromEnumerable(e: TList<IAsn1Encodable>)
       : IAsn1EncodableVector; static;
 
     constructor Create(); overload;
@@ -55,7 +55,7 @@ type
 
     property Count: Int32 read GetCount;
 
-    function GetEnumerator: TEnumerator<IAsn1Encodable>;
+    function GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>; virtual;
 
   end;
 
@@ -108,8 +108,8 @@ begin
   inherited Destroy;
 end;
 
-class function TAsn1EncodableVector.FromEnumerable
-  (e: TEnumerable<IAsn1Encodable>): IAsn1EncodableVector;
+class function TAsn1EncodableVector.FromEnumerable(e: TList<IAsn1Encodable>)
+  : IAsn1EncodableVector;
 var
   v: IAsn1EncodableVector;
   obj: IAsn1Encodable;
@@ -127,9 +127,10 @@ begin
   result := Flist.Count;
 end;
 
-function TAsn1EncodableVector.GetEnumerator: TEnumerator<IAsn1Encodable>;
+function TAsn1EncodableVector.GetEnumerable
+  : TCryptoLibGenericArray<IAsn1Encodable>;
 begin
-  result := Flist.GetEnumerator();
+  result := Flist.ToArray;
 end;
 
 function TAsn1EncodableVector.GetSelf(Index: Int32): IAsn1Encodable;

CryptoLib/src/Asn1/ClpAsn1Sequence.pas

@@ -58,7 +58,7 @@ type
     function GetCount: Int32; virtual;
     function GetParser: IAsn1SequenceParser; virtual;
     function GetSelf(Index: Integer): IAsn1Encodable; virtual;
-    function GetCurrent(e: TEnumerator<IAsn1Encodable>): IAsn1Encodable; inline;
+    function GetCurrent(const e: IAsn1Encodable): IAsn1Encodable;
 
   type
     TAsn1SequenceParserImpl = class sealed(TInterfacedObject,
@@ -89,7 +89,7 @@ type
 
     function ToString(): String; override;
 
-    function GetEnumerator: TEnumerator<IAsn1Encodable>; virtual;
+    function GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>; virtual;
 
     // /**
     // * return the object at the sequence position indicated by index.
@@ -155,12 +155,11 @@ uses
 
 { TAsn1Sequence }
 
-function TAsn1Sequence.GetCurrent(e: TEnumerator<IAsn1Encodable>)
-  : IAsn1Encodable;
+function TAsn1Sequence.GetCurrent(const e: IAsn1Encodable): IAsn1Encodable;
 var
   encObj: IAsn1Encodable;
 begin
-  encObj := e.Current;
+  encObj := e;
 
   // unfortunately null was allowed as a substitute for DER null
   if (encObj = Nil) then
@@ -180,9 +179,9 @@ end;
 function TAsn1Sequence.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IAsn1Sequence;
-  s1, s2: TEnumerator<IAsn1Encodable>;
+  l1, l2: TCryptoLibGenericArray<IAsn1Encodable>;
   o1, o2: IAsn1Object;
-
+  Idx: Int32;
 begin
 
   if (not Supports(asn1Object, IAsn1Sequence, other)) then
@@ -197,40 +196,34 @@ begin
     Exit;
   end;
 
-  s1 := GetEnumerator;
-  s2 := other.GetEnumerator;
+  l1 := GetEnumerable;
+  l2 := other.GetEnumerable;
 
-  try
-    while (s1.MoveNext() and s2.MoveNext()) do
+  for Idx := Low(l1) to High(l1) do
+  begin
+    o1 := GetCurrent(l1[Idx]).ToAsn1Object();
+    o2 := GetCurrent(l2[Idx]).ToAsn1Object();
+
+    if (not(o1.Equals(o2))) then
     begin
-      o1 := GetCurrent(s1).ToAsn1Object();
-      o2 := GetCurrent(s2).ToAsn1Object();
-
-      if (not(o1.Equals(o2))) then
-      begin
-        result := false;
-        Exit;
-      end;
+      result := false;
+      Exit;
     end;
-
-    result := true;
-  finally
-    s1.Free;
-    s2.Free;
   end;
 
+  result := true;
 end;
 
 function TAsn1Sequence.Asn1GetHashCode: Int32;
 var
   hc: Int32;
-  // o: TObject;
-  // o: IInterface;
   o: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   hc := Count;
 
-  for o in Self do
+  LListAsn1Encodable := Self.GetEnumerable;
+  for o in LListAsn1Encodable do
   begin
     hc := hc * 17;
     if (o = Nil) then
@@ -264,9 +257,9 @@ begin
   result := FSeq.Count;
 end;
 
-function TAsn1Sequence.GetEnumerator: TEnumerator<IAsn1Encodable>;
+function TAsn1Sequence.GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
-  result := FSeq.GetEnumerator;
+  result := FSeq.ToArray;
 end;
 
 class function TAsn1Sequence.GetInstance(obj: TObject): IAsn1Sequence;

CryptoLib/src/Asn1/ClpAsn1Set.pas

@@ -60,7 +60,7 @@ type
     function GetCount: Int32; virtual;
     function GetParser: IAsn1SetParser; inline;
     function GetSelf(Index: Integer): IAsn1Encodable; virtual;
-    function GetCurrent(e: TEnumerator<IAsn1Encodable>): IAsn1Encodable; inline;
+    function GetCurrent(const e: IAsn1Encodable): IAsn1Encodable;
 
     /// <summary>
     /// return true if a &lt;= b (arrays are assumed padded with zeros).
@@ -99,7 +99,7 @@ type
 
     function ToArray(): TCryptoLibGenericArray<IAsn1Encodable>; virtual;
 
-    function GetEnumerator: TEnumerator<IAsn1Encodable>; virtual;
+    function GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>; virtual;
 
     // /**
     // * return the object at the sequence position indicated by index.
@@ -170,11 +170,11 @@ begin
   F_set.Add(obj);
 end;
 
-function TAsn1Set.GetCurrent(e: TEnumerator<IAsn1Encodable>): IAsn1Encodable;
+function TAsn1Set.GetCurrent(const e: IAsn1Encodable): IAsn1Encodable;
 var
   encObj: IAsn1Encodable;
 begin
-  encObj := e.Current;
+  encObj := e;
 
   // unfortunately null was allowed as a substitute for DER null
   if (encObj = Nil) then
@@ -189,8 +189,9 @@ end;
 function TAsn1Set.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IAsn1Set;
-  s1, s2: TEnumerator<IAsn1Encodable>;
+  l1, l2: TCryptoLibGenericArray<IAsn1Encodable>;
   o1, o2: IAsn1Object;
+  Idx: Int32;
 begin
 
   if (not Supports(asn1Object, IAsn1Set, other)) then
@@ -205,37 +206,34 @@ begin
     Exit;
   end;
 
-  s1 := GetEnumerator;
-  s2 := other.GetEnumerator;
+  l1 := GetEnumerable;
+  l2 := other.GetEnumerable;
 
-  try
-    while (s1.MoveNext() and s2.MoveNext()) do
-    begin
-      o1 := GetCurrent(s1).ToAsn1Object();
-      o2 := GetCurrent(s2).ToAsn1Object();
+  for Idx := Low(l1) to High(l1) do
+  begin
+    o1 := GetCurrent(l1[Idx]).ToAsn1Object();
+    o2 := GetCurrent(l2[Idx]).ToAsn1Object();
 
-      if (not(o1.Equals(o2))) then
-      begin
-        result := false;
-        Exit;
-      end;
+    if (not(o1.Equals(o2))) then
+    begin
+      result := false;
+      Exit;
     end;
-
-    result := true;
-  finally
-    s1.Free;
-    s2.Free;
   end;
+
+  result := true;
 end;
 
 function TAsn1Set.Asn1GetHashCode: Int32;
 var
   hc: Int32;
   o: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   hc := Count;
 
-  for o in Self do
+  LListAsn1Encodable := Self.GetEnumerable;
+  for o in LListAsn1Encodable do
   begin
     hc := hc * 17;
     if (o = Nil) then
@@ -270,9 +268,9 @@ begin
   result := F_set.Count;
 end;
 
-function TAsn1Set.GetEnumerator: TEnumerator<IAsn1Encodable>;
+function TAsn1Set.GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
-  result := F_set.GetEnumerator;
+  result := F_set.ToArray;
 end;
 
 class function TAsn1Set.GetInstance(obj: TCryptoLibByteArray): IAsn1Set;
@@ -296,6 +294,7 @@ var
   asn1Sequence: IAsn1Sequence;
   v: IAsn1EncodableVector;
   ae: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   inner := obj.GetObject();
 
@@ -334,7 +333,8 @@ begin
   begin
     v := TAsn1EncodableVector.Create();
 
-    for ae in asn1Sequence do
+    LListAsn1Encodable := asn1Sequence.GetEnumerable;
+    for ae in LListAsn1Encodable do
     begin
       v.Add(ae);
     end;

CryptoLib/src/Asn1/ClpBerOctetString.pas

@@ -44,11 +44,11 @@ type
     MaxLength = Int32(1000);
 
   var
-    Focts: TEnumerable<IDerOctetString>;
+    Focts: TList<IDerOctetString>;
 
     function GenerateOcts(): TList<IDerOctetString>;
 
-    class function ToBytes(octs: TEnumerable<IDerOctetString>)
+    class function ToBytes(octs: TList<IDerOctetString>)
       : TCryptoLibByteArray; static;
 
   public
@@ -56,7 +56,7 @@ type
     /// <inheritdoc />
     /// <param name="str">The octets making up the octet string.</param>
     constructor Create(str: TCryptoLibByteArray); overload;
-    constructor Create(octets: TEnumerable<IDerOctetString>); overload;
+    constructor Create(octets: TList<IDerOctetString>); overload;
     constructor Create(const obj: IAsn1Object); overload;
     constructor Create(const obj: IAsn1Encodable); overload;
 
@@ -67,7 +67,7 @@ type
     /// <summary>
     /// return the DER octets that make up this string.
     /// </summary>
-    function GetEnumerable: TCryptoLibGenericArray<IDerOctetString>;
+    function GetEnumerable: TCryptoLibGenericArray<IDerOctetString>; virtual;
 
     procedure Encode(const derOut: IDerOutputStream); override;
 
@@ -80,7 +80,7 @@ implementation
 
 { TBerOctetString }
 
-constructor TBerOctetString.Create(octets: TEnumerable<IDerOctetString>);
+constructor TBerOctetString.Create(octets: TList<IDerOctetString>);
 begin
   Inherited Create(ToBytes(octets));
   Focts := octets;
@@ -110,6 +110,7 @@ end;
 procedure TBerOctetString.Encode(const derOut: IDerOutputStream);
 var
   oct: IDerOctetString;
+  LListIDerOctetString: TCryptoLibGenericArray<IDerOctetString>;
 begin
   if ((Supports(derOut, IAsn1OutputStream)) or
     (Supports(derOut, IBerOutputStream))) then
@@ -121,7 +122,8 @@ begin
     //
     // write out the octet array
     //
-    for oct in Self.GetEnumerable do
+    LListIDerOctetString := Self.GetEnumerable;
+    for oct in LListIDerOctetString do
     begin
       derOut.WriteObject(oct);
     end;
@@ -140,10 +142,12 @@ class function TBerOctetString.FromSequence(const seq: IAsn1Sequence)
 var
   v: TList<IDerOctetString>;
   obj: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   v := TList<IDerOctetString>.Create();
 
-  for obj in seq do
+  LListAsn1Encodable := seq.GetEnumerable;
+  for obj in LListAsn1Encodable do
   begin
     v.Add(obj as IDerOctetString);
   end;
@@ -196,7 +200,7 @@ begin
   result := str;
 end;
 
-class function TBerOctetString.ToBytes(octs: TEnumerable<IDerOctetString>)
+class function TBerOctetString.ToBytes(octs: TList<IDerOctetString>)
   : TCryptoLibByteArray;
 var
   bOut: TMemoryStream;

CryptoLib/src/Asn1/ClpBerSequence.pas

@@ -30,7 +30,8 @@ uses
   ClpIAsn1OutputStream,
   ClpIBerOutputStream,
   ClpIAsn1EncodableVector,
-  ClpIBerSequence;
+  ClpIBerSequence,
+  ClpCryptoLibTypes;
 
 type
   TBerSequence = class(TDerSequence, IBerSequence)
@@ -119,6 +120,7 @@ end;
 procedure TBerSequence.Encode(const derOut: IDerOutputStream);
 var
   o: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
 
   if ((Supports(derOut, IAsn1OutputStream)) or
@@ -127,7 +129,8 @@ begin
     derOut.WriteByte(TAsn1Tags.Sequence or TAsn1Tags.Constructed);
     derOut.WriteByte($80);
 
-    for o in Self do
+    LListAsn1Encodable := Self.GetEnumerable;
+    for o in LListAsn1Encodable do
     begin
       derOut.WriteObject(o);
     end;

CryptoLib/src/Asn1/ClpBerSet.pas

@@ -30,7 +30,8 @@ uses
   ClpIBerOutputStream,
   ClpIAsn1OutputStream,
   ClpIProxiedInterface,
-  ClpIAsn1EncodableVector;
+  ClpIAsn1EncodableVector,
+  ClpCryptoLibTypes;
 
 type
 
@@ -125,6 +126,7 @@ end;
 procedure TBerSet.Encode(const derOut: IDerOutputStream);
 var
   o: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   if ((Supports(derOut, IAsn1OutputStream)) or
     (Supports(derOut, IBerOutputStream))) then
@@ -133,7 +135,8 @@ begin
 
     derOut.WriteByte($80);
 
-    for o in Self do
+    LListAsn1Encodable := Self.GetEnumerable;
+    for o in LListAsn1Encodable do
     begin
       derOut.WriteObject(o);
     end;

CryptoLib/src/Asn1/ClpBerTaggedObject.pas

@@ -113,7 +113,8 @@ end;
 procedure TBerTaggedObject.Encode(const derOut: IDerOutputStream);
 var
   eObj: TList<IAsn1Encodable>;
-  enumeratorIAsn1Sequence, enumeratorIAsn1Set: TEnumerator<IAsn1Encodable>;
+  LListIDerOctetString: TCryptoLibGenericArray<IDerOctetString>;
+  LListIAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
   asn1OctetString: IAsn1OctetString;
   berOctetString: IBerOctetString;
   derOctetString: IDerOctetString;
@@ -137,7 +138,8 @@ begin
           begin
             if (Supports(asn1OctetString, IBerOctetString, berOctetString)) then
             begin
-              for derOctetString in berOctetString.GetEnumerable do
+              LListIDerOctetString := berOctetString.GetEnumerable;
+              for derOctetString in LListIDerOctetString do
               begin
                 eObj.Add(derOctetString as IAsn1Encodable);
               end;
@@ -146,7 +148,8 @@ begin
             begin
               berOctetString := TBerOctetString.Create
                 (asn1OctetString.GetOctets());
-              for derOctetString in berOctetString.GetEnumerable do
+              LListIDerOctetString := berOctetString.GetEnumerable;
+              for derOctetString in LListIDerOctetString do
               begin
                 eObj.Add(derOctetString as IAsn1Encodable);
               end;
@@ -154,26 +157,18 @@ begin
           end
           else if Supports(obj, IAsn1Sequence, asn1Sequence) then
           begin
-            enumeratorIAsn1Sequence := asn1Sequence.GetEnumerator;
-            try
-              while enumeratorIAsn1Sequence.MoveNext do
-              begin
-                eObj.Add(enumeratorIAsn1Sequence.Current);
-              end;
-            finally
-              enumeratorIAsn1Sequence.Free;
+            LListIAsn1Encodable := asn1Sequence.GetEnumerable;
+            for o in LListIAsn1Encodable do
+            begin
+              eObj.Add(o);
             end;
           end
           else if Supports(obj, IAsn1Set, asn1Set) then
           begin
-            enumeratorIAsn1Set := asn1Set.GetEnumerator;
-            try
-              while enumeratorIAsn1Set.MoveNext do
-              begin
-                eObj.Add(enumeratorIAsn1Set.Current);
-              end;
-            finally
-              enumeratorIAsn1Set.Free;
+            LListIAsn1Encodable := asn1Set.GetEnumerable;
+            for o in LListIAsn1Encodable do
+            begin
+              eObj.Add(o);
             end;
           end
           else

CryptoLib/src/Asn1/ClpDerSequence.pas

@@ -99,9 +99,11 @@ end;
 constructor TDerSequence.Create(const v: IAsn1EncodableVector);
 var
   ae: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   Inherited Create(v.Count);
-  for ae in v do
+  LListAsn1Encodable := v.GetEnumerable;
+  for ae in LListAsn1Encodable do
   begin
     AddObject(ae);
   end;
@@ -135,13 +137,15 @@ var
   dOut: TDerOutputStream;
   obj: IAsn1Encodable;
   bytes: TCryptoLibByteArray;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   // TODO Intermediate buffer could be avoided if we could calculate expected length
   bOut := TMemoryStream.Create();
   dOut := TDerOutputStream.Create(bOut);
   try
 
-    for obj in Self do
+    LListAsn1Encodable := Self.GetEnumerable;
+    for obj in LListAsn1Encodable do
     begin
       dOut.WriteObject(obj);
     end;

CryptoLib/src/Asn1/ClpDerSet.pas

@@ -113,9 +113,11 @@ constructor TDerSet.Create(const v: IAsn1EncodableVector;
   needsSorting: Boolean);
 var
   o: IAsn1Encodable;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   Inherited Create(v.Count);
-  for o in v do
+  LListAsn1Encodable := v.GetEnumerable;
+  for o in LListAsn1Encodable do
   begin
     AddObject(o);
   end;
@@ -154,13 +156,15 @@ var
   dOut: TDerOutputStream;
   obj: IAsn1Encodable;
   bytes: TCryptoLibByteArray;
+  LListAsn1Encodable: TCryptoLibGenericArray<IAsn1Encodable>;
 begin
   // TODO Intermediate buffer could be avoided if we could calculate expected length
   bOut := TMemoryStream.Create();
   dOut := TDerOutputStream.Create(bOut);
 
   try
-    for obj in Self do
+    LListAsn1Encodable := Self.GetEnumerable;
+    for obj in LListAsn1Encodable do
     begin
       dOut.WriteObject(obj);
     end;

CryptoLib/src/Interfaces/ClpIAsn1EncodableVector.pas

@@ -23,7 +23,8 @@ interface
 
 uses
   Generics.Collections,
-  ClpIProxiedInterface;
+  ClpIProxiedInterface,
+  ClpCryptoLibTypes;
 
 type
   IAsn1EncodableVector = interface(IInterface)
@@ -40,7 +41,7 @@ type
 
     property Count: Int32 read GetCount;
 
-    function GetEnumerator: TEnumerator<IAsn1Encodable>;
+    function GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>;
 
   end;
 

CryptoLib/src/Interfaces/ClpIAsn1Sequence.pas

@@ -24,7 +24,8 @@ interface
 uses
   Generics.Collections,
   ClpIProxiedInterface,
-  ClpIAsn1SequenceParser;
+  ClpIAsn1SequenceParser,
+  ClpCryptoLibTypes;
 
 type
   IAsn1Sequence = interface(IAsn1Object)
@@ -34,13 +35,13 @@ type
     function GetCount: Int32;
     function GetParser: IAsn1SequenceParser;
     function GetSelf(Index: Integer): IAsn1Encodable;
-    function GetCurrent(e: TEnumerator<IAsn1Encodable>): IAsn1Encodable;
+    function GetCurrent(const e: IAsn1Encodable): IAsn1Encodable;
 
     procedure AddObject(const obj: IAsn1Encodable);
 
     function ToString(): String;
 
-    function GetEnumerator: TEnumerator<IAsn1Encodable>;
+    function GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>;
 
     property Self[Index: Int32]: IAsn1Encodable read GetSelf; default;
 

CryptoLib/src/Interfaces/ClpIAsn1Set.pas

@@ -34,13 +34,13 @@ type
     function GetCount: Int32;
     function GetParser: IAsn1SetParser;
     function GetSelf(Index: Integer): IAsn1Encodable;
-    function GetCurrent(e: TEnumerator<IAsn1Encodable>): IAsn1Encodable;
+    function GetCurrent(const e: IAsn1Encodable): IAsn1Encodable;
 
     function ToString(): String;
 
     function ToArray(): TCryptoLibGenericArray<IAsn1Encodable>;
 
-    function GetEnumerator: TEnumerator<IAsn1Encodable>;
+    function GetEnumerable: TCryptoLibGenericArray<IAsn1Encodable>;
 
     property Self[Index: Int32]: IAsn1Encodable read GetSelf; default;
 

CryptoLib/src/Math/EC/ClpECCurve.pas

@@ -1060,6 +1060,7 @@ begin
   end;
 
   TECAlgorithms.MontgomeryTrick(zs, 0, count, iso);
+
   for j := 0 to System.Pred(count) do
 
   begin

CryptoLib/src/Math/EC/ClpECFieldElement.pas

@@ -1073,7 +1073,9 @@ begin
   P := TNat.FromBigInteger(bits, Q);
   n := TNat.FromBigInteger(bits, x);
   z := TNat.Create(len);
+
   TMod.Invert(P, n, z);
+
   result := TNat.ToBigInteger(len, z);
 end;
 

CryptoLib/src/Math/EC/Multiplier/ClpAbstractECMultiplier.pas

@@ -73,6 +73,7 @@ begin
   end;
 
   positive := MultiplyPositive(p, k.Abs());
+
   if sign > 0 then
   begin
     Result := positive

CryptoLib/src/Math/Raw/ClpMod.pas

@@ -177,6 +177,8 @@ begin
   begin
     InversionStep(p, u, len, a, ac);
   end;
+
+
   if (TNat.IsOne(len, u)) then
   begin
     InversionResult(p, ac, a, z);

CryptoLib/src/Utils/Collections/ClpCollectionUtilities.pas

@@ -32,8 +32,7 @@ type
 
   public
 
-    class function ToStructuredString(c: TEnumerable<IAsn1Encodable>)
-      : String; static;
+    class function ToStructuredString(c: TList<IAsn1Encodable>): String; static;
 
   end;
 
@@ -42,25 +41,27 @@ implementation
 { TCollectionUtilities }
 
 class function TCollectionUtilities.ToStructuredString
-  (c: TEnumerable<IAsn1Encodable>): String;
+  (c: TList<IAsn1Encodable>): String;
 var
-  e: TEnumerator<IAsn1Encodable>;
   sl: TStringList;
+  idx: Int32;
 begin
 
   sl := TStringList.Create();
   sl.LineBreak := '';
   try
     sl.Add('[');
-    e := c.GetEnumerator;
-    if (e.MoveNext()) then
-    begin
-      sl.Add((e.Current as TAsn1Encodable).ClassName);
 
-      while (e.MoveNext()) do
+    if (c.Count <> 0) then
+    begin
+      sl.Add((c[0] as TAsn1Encodable).ClassName);
+      if c.Count > 1 then
       begin
-        sl.Add(', ');
-        sl.Add((e.Current as TAsn1Encodable).ClassName);
+        for idx := 1 to c.Count - 2 do
+        begin
+          sl.Add(', ');
+          sl.Add((c[idx] as TAsn1Encodable).ClassName);
+        end;
       end;
     end;