Indent code. Reproduce using 'make indent' with GNU indent 2.2.10.

21 files changed, 2440 insertions, 2101 deletions

diff --git a/examples/CertificateExample.c b/examples/CertificateExample.c
index d2837b9..f9c19b3 100644
--- a/examples/CertificateExample.c
+++ b/examples/CertificateExample.c
@@ -32,30 +32,35 @@
 
 
 static char *
-my_ltostr(long v,char *str)
+my_ltostr (long v, char *str)
 {
-  long d,r;
+  long d, r;
   char temp[20];
-  int count,k,start;
-
-  if(v<0){
-    str[0]='-';
-    start=1;
-    v=-v;
-  }
-  else start=0;
-
-  count=0;
-  do{
-    d=v/10;
-    r=v-d*10;
-    temp[start+count]='0'+(char)r;
-    count++;
-    v=d;
-  }while(v);
-
-  for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
-  str[count+start]=0;
+  int count, k, start;
+
+  if (v < 0)
+    {
+      str[0] = '-';
+      start = 1;
+      v = -v;
+    }
+  else
+    start = 0;
+
+  count = 0;
+  do
+    {
+      d = v / 10;
+      r = v - d * 10;
+      temp[start + count] = '0' + (char) r;
+      count++;
+      v = d;
+    }
+  while (v);
+
+  for (k = 0; k < count; k++)
+    str[k + start] = temp[start + count - k - 1];
+  str[count + start] = 0;
   return str;
 }
 
@@ -68,103 +73,128 @@ my_ltostr(long v,char *str)
 /*                 "C=US O=gov"                       */
 /******************************************************/
 static void
-get_Name_type(ASN1_TYPE cert_def,ASN1_TYPE cert,const char *root, char *answer)
+get_Name_type (ASN1_TYPE cert_def, ASN1_TYPE cert, const char *root,
+	       char *answer)
 {
-  int k,k2,result,len;
-  char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
-  ASN1_TYPE value=ASN1_TYPE_EMPTY;
+  int k, k2, result, len;
+  char name[128], str[1024], str2[1024], name2[128], counter[5], name3[128];
+  ASN1_TYPE value = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
 
-  answer[0]=0;
-  k=1;
-  do{
-    strcpy(name,root);
-    strcat(name,".rdnSequence.?");
-    my_ltostr(k,counter);
-    strcat(name,counter);
-    len = sizeof(str) - 1;
-    result=asn1_read_value(cert,name,str,&len);
-    if(result==ASN1_ELEMENT_NOT_FOUND) break;
-    k2=1;
-    do{
-      strcpy(name2,name);
-      strcat(name2,".?");
-      my_ltostr(k2,counter);
-      strcat(name2,counter);
-      len = sizeof(str) - 1;
-      result=asn1_read_value(cert,name2,str,&len);
-      if(result==ASN1_ELEMENT_NOT_FOUND) break;
-      strcpy(name3,name2);
-      strcat(name3,".type");
-      len = sizeof(str) - 1;
-      result=asn1_read_value(cert,name3,str,&len);
-      strcpy(name3,name2);
-      strcat(name3,".value");
-      if(result==ASN1_SUCCESS){
-	len = sizeof(str2) - 1;
-	result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
-			  str2,&len);
-	if(!strcmp(str,str2)){
-	  asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
-			   &value);
-	  len = sizeof(str) - 1;
-	  asn1_read_value(cert,name3,str,&len);
-	  asn1_der_decoding(&value,str,len,errorDescription);
-	  len = sizeof(str) - 1;
-	  asn1_read_value(value,"",str,&len);  /* CHOICE */
-	  strcpy(name3,str);
-	  len = sizeof(str) - 1;
-	  asn1_read_value(value,name3,str,&len);
-	  str[len]=0;
-	  strcat(answer," C=");
-	  strcat(answer,str);
-	  asn1_delete_structure(&value);
-	}
-	else{
-	  len = sizeof(str2) - 1;
-	  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
-			    ,str2,&len);
-	  if(!strcmp(str,str2)){
-	    asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName"
-			     ,&value);
-	    len = sizeof(str) - 1;
-	    asn1_read_value(cert,name3,str,&len);	  
-	    asn1_der_decoding(&value,str,len,errorDescription);
-	    len = sizeof(str) - 1;
-	    asn1_read_value(value,"",str,&len);  /* CHOICE */
-	    strcpy(name3,str);
-	    len = sizeof(str) - 1;
-	    asn1_read_value(value,name3,str,&len);
-	    str[len]=0;
-	    strcat(answer," O=");
-	    strcat(answer,str);
-	    asn1_delete_structure(&value);
-	  }
-	  else{
-	    len = sizeof(str2) - 1;
-	    result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
-	    if(!strcmp(str,str2)){
-	      asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
-	      len = sizeof(str) - 1;
-	      asn1_read_value(cert,name3,str,&len);
-	      asn1_der_decoding(&value,str,len,errorDescription);
-	      len = sizeof(str) - 1;
-	      asn1_read_value(value,"",str,&len);  /* CHOICE */
-	      strcpy(name3,str);
-	      len = sizeof(str) - 1;
-	      asn1_read_value(value,name3,str,&len);
-	      str[len]=0;
-	      strcat(answer," OU=");
-	      strcat(answer,str);
-	      asn1_delete_structure(&value);
+  answer[0] = 0;
+  k = 1;
+  do
+    {
+      strcpy (name, root);
+      strcat (name, ".rdnSequence.?");
+      my_ltostr (k, counter);
+      strcat (name, counter);
+      len = sizeof (str) - 1;
+      result = asn1_read_value (cert, name, str, &len);
+      if (result == ASN1_ELEMENT_NOT_FOUND)
+	break;
+      k2 = 1;
+      do
+	{
+	  strcpy (name2, name);
+	  strcat (name2, ".?");
+	  my_ltostr (k2, counter);
+	  strcat (name2, counter);
+	  len = sizeof (str) - 1;
+	  result = asn1_read_value (cert, name2, str, &len);
+	  if (result == ASN1_ELEMENT_NOT_FOUND)
+	    break;
+	  strcpy (name3, name2);
+	  strcat (name3, ".type");
+	  len = sizeof (str) - 1;
+	  result = asn1_read_value (cert, name3, str, &len);
+	  strcpy (name3, name2);
+	  strcat (name3, ".value");
+	  if (result == ASN1_SUCCESS)
+	    {
+	      len = sizeof (str2) - 1;
+	      result =
+		asn1_read_value (cert_def,
+				 "PKIX1Implicit88.id-at-countryName", str2,
+				 &len);
+	      if (!strcmp (str, str2))
+		{
+		  asn1_create_element (cert_def,
+				       "PKIX1Implicit88.X520OrganizationName",
+				       &value);
+		  len = sizeof (str) - 1;
+		  asn1_read_value (cert, name3, str, &len);
+		  asn1_der_decoding (&value, str, len, errorDescription);
+		  len = sizeof (str) - 1;
+		  asn1_read_value (value, "", str, &len);	/* CHOICE */
+		  strcpy (name3, str);
+		  len = sizeof (str) - 1;
+		  asn1_read_value (value, name3, str, &len);
+		  str[len] = 0;
+		  strcat (answer, " C=");
+		  strcat (answer, str);
+		  asn1_delete_structure (&value);
+		}
+	      else
+		{
+		  len = sizeof (str2) - 1;
+		  result =
+		    asn1_read_value (cert_def,
+				     "PKIX1Implicit88.id-at-organizationName",
+				     str2, &len);
+		  if (!strcmp (str, str2))
+		    {
+		      asn1_create_element (cert_def,
+					   "PKIX1Implicit88.X520OrganizationName",
+					   &value);
+		      len = sizeof (str) - 1;
+		      asn1_read_value (cert, name3, str, &len);
+		      asn1_der_decoding (&value, str, len, errorDescription);
+		      len = sizeof (str) - 1;
+		      asn1_read_value (value, "", str, &len);	/* CHOICE */
+		      strcpy (name3, str);
+		      len = sizeof (str) - 1;
+		      asn1_read_value (value, name3, str, &len);
+		      str[len] = 0;
+		      strcat (answer, " O=");
+		      strcat (answer, str);
+		      asn1_delete_structure (&value);
+		    }
+		  else
+		    {
+		      len = sizeof (str2) - 1;
+		      result =
+			asn1_read_value (cert_def,
+					 "PKIX1Implicit88.id-at-organizationalUnitName",
+					 str2, &len);
+		      if (!strcmp (str, str2))
+			{
+			  asn1_create_element (cert_def,
+					       "PKIX1Implicit88.X520OrganizationalUnitName",
+					       &value);
+			  len = sizeof (str) - 1;
+			  asn1_read_value (cert, name3, str, &len);
+			  asn1_der_decoding (&value, str, len,
+					     errorDescription);
+			  len = sizeof (str) - 1;
+			  asn1_read_value (value, "", str, &len);	/* CHOICE */
+			  strcpy (name3, str);
+			  len = sizeof (str) - 1;
+			  asn1_read_value (value, name3, str, &len);
+			  str[len] = 0;
+			  strcat (answer, " OU=");
+			  strcat (answer, str);
+			  asn1_delete_structure (&value);
+			}
+		    }
+		}
 	    }
-	  }
+	  k2++;
 	}
-      }
-      k2++;
-    }while(1);
-    k++;
-  }while(1);
+      while (1);
+      k++;
+    }
+  while (1);
 }
 
 
@@ -175,223 +205,331 @@ get_Name_type(ASN1_TYPE cert_def,ASN1_TYPE cert,const char *root, char *answer)
 /*              as in rfc2459 Appendix D.1            */
 /* Parameters:                                        */
 /*   unsigned char *der: contains the der encoding    */
-/*   int *der_len: number of bytes of der string      */ 
+/*   int *der_len: number of bytes of der string      */
 /******************************************************/
 static void
-create_certificate(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
+create_certificate (ASN1_TYPE cert_def, unsigned char *der, int *der_len)
 {
-  int result,k,len;
+  int result, k, len;
   unsigned char str[1024];
   const unsigned char *str2;
-  ASN1_TYPE cert1=ASN1_TYPE_EMPTY;
-  ASN1_TYPE value=ASN1_TYPE_EMPTY;
-  ASN1_TYPE param=ASN1_TYPE_EMPTY;
-  ASN1_TYPE constr=ASN1_TYPE_EMPTY;
+  ASN1_TYPE cert1 = ASN1_TYPE_EMPTY;
+  ASN1_TYPE value = ASN1_TYPE_EMPTY;
+  ASN1_TYPE param = ASN1_TYPE_EMPTY;
+  ASN1_TYPE constr = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
   int max_len;
 
-  max_len=*der_len;
+  max_len = *der_len;
+
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.Certificate", &cert1);
 
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.Certificate",&cert1);
- 
   /* Use the next 3 lines to visit the empty certificate */
   /* printf("-----------------\n");
      asn1_visit_tree(cert1,"");   
      printf("-----------------\n"); */
 
-  /* version: v3(2) */  
-  result=asn1_write_value(cert1,"tbsCertificate.version","v3",0); 
+  /* version: v3(2) */
+  result = asn1_write_value (cert1, "tbsCertificate.version", "v3", 0);
 
-  /* serialNumber: 17 */    
-  result=asn1_write_value(cert1,"tbsCertificate.serialNumber","17",0); 
+  /* serialNumber: 17 */
+  result = asn1_write_value (cert1, "tbsCertificate.serialNumber", "17", 0);
 
   /* signature: dsa-with-sha1 */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.signature.algorithm",
-		     str,1);    
-  
-  result=asn1_write_value(cert1,"tbsCertificate.signature.parameters",
-		     NULL,0);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.signature.algorithm", str, 1);
 
+  result = asn1_write_value (cert1, "tbsCertificate.signature.parameters",
+			     NULL, 0);
 
-  /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
-  result=asn1_write_value(cert1,"tbsCertificate.issuer","rdnSequence",12);
 
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+  /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer", "rdnSequence", 12);
+
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence", "NEW", 1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence.?LAST", "NEW",
+		      1);
   /* C */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
-			  &value);
-  result=asn1_write_value(value,"","US",2);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
+		     &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
+  result = asn1_write_value (value, "", "US", 2);
   *der_len = max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
+
+
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence", "NEW", 1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence.?LAST", "NEW",
+		      1);
   /* O */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
-			  &value);
-  result=asn1_write_value(value,"","printableString",1);
-  result=asn1_write_value(value,"printableString","gov",3);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
+		     &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
+			 &value);
+  result = asn1_write_value (value, "", "printableString", 1);
+  result = asn1_write_value (value, "printableString", "gov", 3);
   *der_len = max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
 
 
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence", "NEW", 1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence.?LAST", "NEW",
+		      1);
 
   /* OU */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
-		    str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
-  result=asn1_write_value(value,"","printableString",1);
-  result=asn1_write_value(value,"printableString","nist",4);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
+		     str, &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def,
+			 "PKIX1Implicit88.X520OrganizationalUnitName",
+			 &value);
+  result = asn1_write_value (value, "", "printableString", 1);
+  result = asn1_write_value (value, "printableString", "nist", 4);
   *der_len = max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
 
 
   /* validity */
-  result=asn1_write_value(cert1,"tbsCertificate.validity.notBefore","utcTime",1);
-  result=asn1_write_value(cert1,"tbsCertificate.validity.notBefore.utcTime","970630000000Z",1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.validity.notBefore", "utcTime",
+		      1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.validity.notBefore.utcTime",
+		      "970630000000Z", 1);
 
-  result=asn1_write_value(cert1,"tbsCertificate.validity.notAfter","utcTime",1);
-  result=asn1_write_value(cert1,"tbsCertificate.validity.notAfter.utcTime","971231000000Z",1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.validity.notAfter", "utcTime",
+		      1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.validity.notAfter.utcTime",
+		      "971231000000Z", 1);
 
 
 
   /* subject: Country="US" Organization="gov" OrganizationUnit="nist" */
-  result=asn1_write_value(cert1,"tbsCertificate.subject","rdnSequence",1);
-
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",1);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject", "rdnSequence", 1);
+
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence", "NEW", 1);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence.?LAST",
+		      "NEW", 1);
   /* C */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
-			  &value);
-  result=asn1_write_value(value,"","US",2);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
+		     &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
+  result = asn1_write_value (value, "", "US", 2);
   *der_len = max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",4);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
+
+
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence", "NEW", 4);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence.?LAST",
+		      "NEW", 4);
   /* O */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
-			  &value);
-  result=asn1_write_value(value,"","printableString",1);
-  result=asn1_write_value(value,"printableString","gov",3);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
+		     &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
+			 &value);
+  result = asn1_write_value (value, "", "printableString", 1);
+  result = asn1_write_value (value, "printableString", "gov", 3);
   *der_len = max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",4);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
+
+
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence", "NEW", 4);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence.?LAST",
+		      "NEW", 4);
   /* OU */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
-		    str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
-  result=asn1_write_value(value,"","printableString",1);
-  result=asn1_write_value(value,"printableString","nist",4);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
+		     str, &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def,
+			 "PKIX1Implicit88.X520OrganizationalUnitName",
+			 &value);
+  result = asn1_write_value (value, "", "printableString", 1);
+  result = asn1_write_value (value, "printableString", "nist", 4);
   *der_len = max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
 
 
   /* subjectPublicKeyInfo: dsa with parameters=Dss-Parms */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa",str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm",str,1); 
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.Dss-Parms",&param);
-  str2="\xd4\x38"; /* only an example */
-  result=asn1_write_value(param,"p",str2,128);
-  str2="\xd4\x38"; /* only an example */
-  result=asn1_write_value(param,"q",str2,20);
-  str2="\xd4\x38"; /* only an example */
-  result=asn1_write_value(param,"g",str2,128);
+  len = sizeof (str) - 1;
+  result = asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa", str, &len);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.Dss-Parms", &param);
+  str2 = "\xd4\x38";		/* only an example */
+  result = asn1_write_value (param, "p", str2, 128);
+  str2 = "\xd4\x38";		/* only an example */
+  result = asn1_write_value (param, "q", str2, 20);
+  str2 = "\xd4\x38";		/* only an example */
+  result = asn1_write_value (param, "g", str2, 128);
   *der_len = max_len;
-  result=asn1_der_coding(param,"",der,der_len,errorDescription);
-  asn1_delete_structure(&param);
-  result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.algorithm.parameters",der,*der_len); 
+  result = asn1_der_coding (param, "", der, der_len, errorDescription);
+  asn1_delete_structure (&param);
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subjectPublicKeyInfo.algorithm.parameters",
+		      der, *der_len);
 
 
   /* subjectPublicKey */
-  str2="\x02\x81"; /* only an example */
-  result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",str2,1048);
+  str2 = "\x02\x81";		/* only an example */
+  result =
+    asn1_write_value (cert1,
+		      "tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",
+		      str2, 1048);
 
-  result=asn1_write_value(cert1,"tbsCertificate.issuerUniqueID",NULL,0);  /* NO OPTION */
-  result=asn1_write_value(cert1,"tbsCertificate.subjectUniqueID",NULL,0); /* NO OPTION */
+  result = asn1_write_value (cert1, "tbsCertificate.issuerUniqueID", NULL, 0);	/* NO OPTION */
+  result = asn1_write_value (cert1, "tbsCertificate.subjectUniqueID", NULL, 0);	/* NO OPTION */
 
   /* extensions */
-  result=asn1_write_value(cert1,"tbsCertificate.extensions","NEW",1); 
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-basicConstraints",
-		    str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnID",str,1); /*   basicConstraints */  
-  result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.critical","TRUE",1); 
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.BasicConstraints",&constr);
-  result=asn1_write_value(constr,"cA","TRUE",1); 
-  result=asn1_write_value(constr,"pathLenConstraint",NULL,0); 
-  *der_len = max_len; 
-  result=asn1_der_coding(constr,"",der,der_len,errorDescription);
-  result=asn1_delete_structure(&constr);
-  result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnValue",der,*der_len); 
-
-
-  result=asn1_write_value(cert1,"tbsCertificate.extensions","NEW",1); 
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-subjectKeyIdentifier",
-		    str,&len);
-  result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnID",str,1); /* subjectKeyIdentifier */ 
-  result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.critical","FALSE",1); 
-  str2="\x04\x14\xe7\x26\xc5"; /* only an example */
-  result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnValue",str2,22); 
+  result = asn1_write_value (cert1, "tbsCertificate.extensions", "NEW", 1);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-basicConstraints", str,
+		     &len);
+  result = asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnID", str, 1);	/*   basicConstraints */
+  result =
+    asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.critical",
+		      "TRUE", 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.BasicConstraints",
+			 &constr);
+  result = asn1_write_value (constr, "cA", "TRUE", 1);
+  result = asn1_write_value (constr, "pathLenConstraint", NULL, 0);
+  *der_len = max_len;
+  result = asn1_der_coding (constr, "", der, der_len, errorDescription);
+  result = asn1_delete_structure (&constr);
+  result =
+    asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnValue", der,
+		      *der_len);
+
+
+  result = asn1_write_value (cert1, "tbsCertificate.extensions", "NEW", 1);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-subjectKeyIdentifier",
+		     str, &len);
+  result = asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnID", str, 1);	/* subjectKeyIdentifier */
+  result =
+    asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.critical",
+		      "FALSE", 1);
+  str2 = "\x04\x14\xe7\x26\xc5";	/* only an example */
+  result =
+    asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnValue",
+		      str2, 22);
 
 
   /* signatureAlgorithm: dsa-with-sha  */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
-  result=asn1_write_value(cert1,"signatureAlgorithm.algorithm",str,1); 
-  result=asn1_write_value(cert1,"signatureAlgorithm.parameters",NULL,0); /* NO OPTION */  
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+  result = asn1_write_value (cert1, "signatureAlgorithm.algorithm", str, 1);
+  result = asn1_write_value (cert1, "signatureAlgorithm.parameters", NULL, 0);	/* NO OPTION */
 
 
   /* signature */
   *der_len = max_len;
-  result=asn1_der_coding(cert1,"tbsCertificate",der,der_len
-                         ,errorDescription);
-  if(result!=ASN1_SUCCESS){
-    printf("\n'tbsCertificate' encoding creation: ERROR\n");
-  }
+  result =
+    asn1_der_coding (cert1, "tbsCertificate", der, der_len, errorDescription);
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("\n'tbsCertificate' encoding creation: ERROR\n");
+    }
   /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
-  result=asn1_write_value(cert1,"signature",str2,368); /* dsa-with-sha */ 
-  
+  result = asn1_write_value (cert1, "signature", str2, 368);	/* dsa-with-sha */
+
 
   /* Use the next 3 lines to visit the certificate */
   /* printf("-----------------\n");   
@@ -399,19 +537,22 @@ create_certificate(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
      printf("-----------------\n"); */
 
   *der_len = max_len;
-  result=asn1_der_coding(cert1,"",der,der_len,errorDescription);
-  if(result!=ASN1_SUCCESS){
-    printf("\n'certificate' encoding creation: ERROR\n");
-    return;
-  }
-
-  /* Print the 'Certificate1' DER encoding */ 
-  printf("-----------------\nCertificate Encoding:\nNumber of bytes=%i\n",*der_len);
-  for(k=0;k<*der_len;k++) printf("%02x ",der[k]);  
-  printf("\n-----------------\n");
+  result = asn1_der_coding (cert1, "", der, der_len, errorDescription);
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("\n'certificate' encoding creation: ERROR\n");
+      return;
+    }
+
+  /* Print the 'Certificate1' DER encoding */
+  printf ("-----------------\nCertificate Encoding:\nNumber of bytes=%i\n",
+	  *der_len);
+  for (k = 0; k < *der_len; k++)
+    printf ("%02x ", der[k]);
+  printf ("\n-----------------\n");
 
   /* Clear the "certificate1" structure */
-  asn1_delete_structure(&cert1);
+  asn1_delete_structure (&cert1);
 }
 
 
@@ -423,53 +564,56 @@ create_certificate(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
 /*              string                                */
 /* Parameters:                                        */
 /*   unsigned char *der: the encoding string          */
-/*   int der_len: number of bytes of der string      */ 
+/*   int der_len: number of bytes of der string      */
 /******************************************************/
 static void
-get_certificate(ASN1_TYPE cert_def,unsigned char *der,int der_len)
+get_certificate (ASN1_TYPE cert_def, unsigned char *der, int der_len)
 {
-  int result,len,start,end;
-  unsigned char str[1024],str2[1024];
-  ASN1_TYPE cert2=ASN1_TYPE_EMPTY;
+  int result, len, start, end;
+  unsigned char str[1024], str2[1024];
+  ASN1_TYPE cert2 = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
 
-  asn1_create_element(cert_def,"PKIX1Implicit88.Certificate",&cert2);
+  asn1_create_element (cert_def, "PKIX1Implicit88.Certificate", &cert2);
 
-  result=asn1_der_decoding(&cert2,der,der_len,errorDescription);
+  result = asn1_der_decoding (&cert2, der, der_len, errorDescription);
+
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("Problems with DER encoding\n");
+      return;
+    }
 
-  if(result!=ASN1_SUCCESS){
-    printf("Problems with DER encoding\n");
-    return;
-  }
-   
 
   /* issuer */
-  get_Name_type(cert_def,cert2,"tbsCertificate.issuer",str);
-  printf("certificate:\nissuer :%s\n",str);
+  get_Name_type (cert_def, cert2, "tbsCertificate.issuer", str);
+  printf ("certificate:\nissuer :%s\n", str);
   /* subject */
-  get_Name_type(cert_def,cert2,"tbsCertificate.subject",str);
-  printf("subject:%s\n",str);
+  get_Name_type (cert_def, cert2, "tbsCertificate.subject", str);
+  printf ("subject:%s\n", str);
 
 
   /* Verify sign */
-  len = sizeof(str) - 1;
-  result=asn1_read_value(cert2,"signatureAlgorithm.algorithm"
-		    ,str,&len);
+  len = sizeof (str) - 1;
+  result = asn1_read_value (cert2, "signatureAlgorithm.algorithm", str, &len);
 
-  len = sizeof(str2) - 1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
-  if(!strcmp(str,str2)){  /* dsa-with-sha */
+  len = sizeof (str2) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str2,
+		     &len);
+  if (!strcmp (str, str2))
+    {				/* dsa-with-sha */
 
-    result=asn1_der_decoding_startEnd(cert2,der,der_len,
-			     "tbsCertificate",&start,&end);
+      result = asn1_der_decoding_startEnd (cert2, der, der_len,
+					   "tbsCertificate", &start, &end);
 
-    /* add the lines to calculate the sha on der[start]..der[end] */
+      /* add the lines to calculate the sha on der[start]..der[end] */
 
-    len = sizeof(str) - 1;
-    result=asn1_read_value(cert2,"signature",str,&len);
+      len = sizeof (str) - 1;
+      result = asn1_read_value (cert2, "signature", str, &len);
 
-    /* compare the previous value to signature ( with issuer public key) */ 
-  }
+      /* compare the previous value to signature ( with issuer public key) */
+    }
 
   /* Use the next 3 lines to visit the certificate */
   /*   printf("-----------------\n");   
@@ -478,7 +622,7 @@ get_certificate(ASN1_TYPE cert_def,unsigned char *der,int der_len)
 
 
   /* Clear the "certificate2" structure */
-  asn1_delete_structure(&cert2);
+  asn1_delete_structure (&cert2);
 }
 
 extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
@@ -487,50 +631,44 @@ extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
 /* Function : main                                      */
 /* Description: reads the certificate description.      */
 /*              Creates a certificate and calculate     */
-/*              the der encoding. After that creates    */  
+/*              the der encoding. After that creates    */
 /*              another certificate from der string     */
 /********************************************************/
 int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
 {
-  int result,der_len;
+  int result, der_len;
   unsigned char der[1024];
-  ASN1_TYPE PKIX1Implicit88=ASN1_TYPE_EMPTY;
+  ASN1_TYPE PKIX1Implicit88 = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
 
-  if(1)
-    result=asn1_array2tree(pkix_asn1_tab,&PKIX1Implicit88,errorDescription); 
+  if (1)
+    result =
+      asn1_array2tree (pkix_asn1_tab, &PKIX1Implicit88, errorDescription);
   else
-    result=asn1_parser2tree("pkix.asn",&PKIX1Implicit88,errorDescription);
+    result =
+      asn1_parser2tree ("pkix.asn", &PKIX1Implicit88, errorDescription);
+
+  if (result != ASN1_SUCCESS)
+    {
+      asn1_perror (result);
+      printf ("%s", errorDescription);
+      exit (1);
+    }
 
-  if(result != ASN1_SUCCESS){
-    asn1_perror(result);
-    printf("%s",errorDescription);
-    exit(1);
-  }
 
-  
   /* Use the following 3 lines to visit the PKIX1Implicit structures */
   /* printf("-----------------\n");
      asn1_visit_tree(PKIX1Implicit88,"PKIX1Implicit88");   
      printf("-----------------\n"); */
 
-  der_len=1024;
-  create_certificate(PKIX1Implicit88,der,&der_len);
+  der_len = 1024;
+  create_certificate (PKIX1Implicit88, der, &der_len);
 
-  get_certificate(PKIX1Implicit88,der,der_len);
+  get_certificate (PKIX1Implicit88, der, der_len);
 
   /* Clear the "PKIX1Implicit88" structures */
-  asn1_delete_structure(&PKIX1Implicit88);
+  asn1_delete_structure (&PKIX1Implicit88);
 
   return 0;
 }
-
-
-
-
-
-
-
-
-
diff --git a/examples/CrlExample.c b/examples/CrlExample.c
index 7efd62f..0d8818c 100644
--- a/examples/CrlExample.c
+++ b/examples/CrlExample.c
@@ -33,30 +33,35 @@
 
 
 static char *
-my_ltostr(long v,char *str)
+my_ltostr (long v, char *str)
 {
-  long d,r;
+  long d, r;
   char temp[20];
-  int count,k,start;
-
-  if(v<0){
-    str[0]='-';
-    start=1;
-    v=-v;
-  }
-  else start=0;
-
-  count=0;
-  do{
-    d=v/10;
-    r=v-d*10;
-    temp[start+count]='0'+(char)r;
-    count++;
-    v=d;
-  }while(v);
-
-  for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
-  str[count+start]=0;
+  int count, k, start;
+
+  if (v < 0)
+    {
+      str[0] = '-';
+      start = 1;
+      v = -v;
+    }
+  else
+    start = 0;
+
+  count = 0;
+  do
+    {
+      d = v / 10;
+      r = v - d * 10;
+      temp[start + count] = '0' + (char) r;
+      count++;
+      v = d;
+    }
+  while (v);
+
+  for (k = 0; k < count; k++)
+    str[k + start] = temp[start + count - k - 1];
+  str[count + start] = 0;
   return str;
 }
 
@@ -70,111 +75,137 @@ my_ltostr(long v,char *str)
 /*                 "C=US O=gov"                       */
 /******************************************************/
 static void
-get_Name_type(ASN1_TYPE cert_def,ASN1_TYPE cert,const char *root, char *answer)
+get_Name_type (ASN1_TYPE cert_def, ASN1_TYPE cert, const char *root,
+	       char *answer)
 {
-  int k,k2,result,len;
-  char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
-  ASN1_TYPE value=ASN1_TYPE_EMPTY;
+  int k, k2, result, len;
+  char name[128], str[1024], str2[1024], name2[128], counter[5], name3[128];
+  ASN1_TYPE value = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
 
-  answer[0]=0;
-  k=1;
-  do{
-    strcpy(name,root);
-    strcat(name,".rdnSequence.?");
-    my_ltostr(k,counter);
-    strcat(name,counter);
-    
-    len = sizeof(str)-1;
-    result=asn1_read_value(cert,name,str,&len);
-    if(result==ASN1_ELEMENT_NOT_FOUND) break;
-    k2=1;
-    do{
-      strcpy(name2,name);
-      strcat(name2,".?");
-      my_ltostr(k2,counter);
-      strcat(name2,counter);
-      
-      len = sizeof(str)-1;
-      result=asn1_read_value(cert,name2,str,&len);
-      if(result==ASN1_ELEMENT_NOT_FOUND) break;
-      strcpy(name3,name2);
-      strcat(name3,".type");
-      
-      len = sizeof(str)-1;
-      result=asn1_read_value(cert,name3,str,&len);
-      strcpy(name3,name2);
-      strcat(name3,".value");
-      if(result==ASN1_SUCCESS){
-	len = sizeof(str2);
-	result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
-			  str2,&len);
-	if(!strcmp(str,str2)){
-	  asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
-			      &value);
-	  len = sizeof(str)-1;
-	  asn1_read_value(cert,name3,str,&len);
-	  result=asn1_der_decoding(&value,str,len,errorDescription);
-
-	  len = sizeof(str)-1;
-	  asn1_read_value(value,"",str,&len);  /* CHOICE */
-
-	  strcpy(name3,str);
-	  
-	  len = sizeof(str)-1;
-	  asn1_read_value(value,name3,str,&len);
-	  str[len]=0;
-	  strcat(answer," C=");
-	  strcat(answer,str);
-
-	  asn1_delete_structure(&value);
-	}
-	else{
-	  len = sizeof(str2);
-	  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
-			    ,str2,&len);
-	  if(!strcmp(str,str2)){
-	    asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName"
-			     ,&value);
-	    
-	    len = sizeof(str)-1;
-	    asn1_read_value(cert,name3,str,&len);	  
-	    asn1_der_decoding(&value,str,len,errorDescription);
-	    len = sizeof(str)-1;
-	    asn1_read_value(value,"",str,&len);  /* CHOICE */
-	    strcpy(name3,str);
-	    len = sizeof(str)-1;
-	    asn1_read_value(value,name3,str,&len);
-	    str[len]=0;
-	    strcat(answer," O=");
-	    strcat(answer,str);
-	    asn1_delete_structure(&value);
-	  }
-	  else{
-	    len = sizeof(str2);
-	    result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
-	    if(!strcmp(str,str2)){
-	      asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
-	      len = sizeof(str)-1;
-	      asn1_read_value(cert,name3,str,&len);
-	      asn1_der_decoding(&value,str,len,errorDescription);
-	      len = sizeof(str)-1;
-	      asn1_read_value(value,"",str,&len);  /* CHOICE */
-	      strcpy(name3,str);
-	      len = sizeof(str)-1;
-	      asn1_read_value(value,name3,str,&len);
-	      str[len]=0;
-	      strcat(answer," OU=");
-	      strcat(answer,str);
-	      asn1_delete_structure(&value);
+  answer[0] = 0;
+  k = 1;
+  do
+    {
+      strcpy (name, root);
+      strcat (name, ".rdnSequence.?");
+      my_ltostr (k, counter);
+      strcat (name, counter);
+
+      len = sizeof (str) - 1;
+      result = asn1_read_value (cert, name, str, &len);
+      if (result == ASN1_ELEMENT_NOT_FOUND)
+	break;
+      k2 = 1;
+      do
+	{
+	  strcpy (name2, name);
+	  strcat (name2, ".?");
+	  my_ltostr (k2, counter);
+	  strcat (name2, counter);
+
+	  len = sizeof (str) - 1;
+	  result = asn1_read_value (cert, name2, str, &len);
+	  if (result == ASN1_ELEMENT_NOT_FOUND)
+	    break;
+	  strcpy (name3, name2);
+	  strcat (name3, ".type");
+
+	  len = sizeof (str) - 1;
+	  result = asn1_read_value (cert, name3, str, &len);
+	  strcpy (name3, name2);
+	  strcat (name3, ".value");
+	  if (result == ASN1_SUCCESS)
+	    {
+	      len = sizeof (str2);
+	      result =
+		asn1_read_value (cert_def,
+				 "PKIX1Implicit88.id-at-countryName", str2,
+				 &len);
+	      if (!strcmp (str, str2))
+		{
+		  asn1_create_element (cert_def,
+				       "PKIX1Implicit88.X520OrganizationName",
+				       &value);
+		  len = sizeof (str) - 1;
+		  asn1_read_value (cert, name3, str, &len);
+		  result =
+		    asn1_der_decoding (&value, str, len, errorDescription);
+
+		  len = sizeof (str) - 1;
+		  asn1_read_value (value, "", str, &len);	/* CHOICE */
+
+		  strcpy (name3, str);
+
+		  len = sizeof (str) - 1;
+		  asn1_read_value (value, name3, str, &len);
+		  str[len] = 0;
+		  strcat (answer, " C=");
+		  strcat (answer, str);
+
+		  asn1_delete_structure (&value);
+		}
+	      else
+		{
+		  len = sizeof (str2);
+		  result =
+		    asn1_read_value (cert_def,
+				     "PKIX1Implicit88.id-at-organizationName",
+				     str2, &len);
+		  if (!strcmp (str, str2))
+		    {
+		      asn1_create_element (cert_def,
+					   "PKIX1Implicit88.X520OrganizationName",
+					   &value);
+
+		      len = sizeof (str) - 1;
+		      asn1_read_value (cert, name3, str, &len);
+		      asn1_der_decoding (&value, str, len, errorDescription);
+		      len = sizeof (str) - 1;
+		      asn1_read_value (value, "", str, &len);	/* CHOICE */
+		      strcpy (name3, str);
+		      len = sizeof (str) - 1;
+		      asn1_read_value (value, name3, str, &len);
+		      str[len] = 0;
+		      strcat (answer, " O=");
+		      strcat (answer, str);
+		      asn1_delete_structure (&value);
+		    }
+		  else
+		    {
+		      len = sizeof (str2);
+		      result =
+			asn1_read_value (cert_def,
+					 "PKIX1Implicit88.id-at-organizationalUnitName",
+					 str2, &len);
+		      if (!strcmp (str, str2))
+			{
+			  asn1_create_element (cert_def,
+					       "PKIX1Implicit88.X520OrganizationalUnitName",
+					       &value);
+			  len = sizeof (str) - 1;
+			  asn1_read_value (cert, name3, str, &len);
+			  asn1_der_decoding (&value, str, len,
+					     errorDescription);
+			  len = sizeof (str) - 1;
+			  asn1_read_value (value, "", str, &len);	/* CHOICE */
+			  strcpy (name3, str);
+			  len = sizeof (str) - 1;
+			  asn1_read_value (value, name3, str, &len);
+			  str[len] = 0;
+			  strcat (answer, " OU=");
+			  strcat (answer, str);
+			  asn1_delete_structure (&value);
+			}
+		    }
+		}
 	    }
-	  }
+	  k2++;
 	}
-      }
-      k2++;
-    }while(1);
-    k++;
-  }while(1);
+      while (1);
+      k++;
+    }
+  while (1);
 }
 
 
@@ -185,157 +216,213 @@ get_Name_type(ASN1_TYPE cert_def,ASN1_TYPE cert,const char *root, char *answer)
 /*              as in rfc2459 Appendix D.1            */
 /* Parameters:                                        */
 /*   unsigned char *der: contains the der encoding    */
-/*   int *der_len: number of bytes of der string      */ 
+/*   int *der_len: number of bytes of der string      */
 /******************************************************/
 static void
-create_CRL(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
+create_CRL (ASN1_TYPE cert_def, unsigned char *der, int *der_len)
 {
-  int result,k,len;
+  int result, k, len;
   unsigned char str[1024];
   const unsigned char *str2;
-  ASN1_TYPE crl=ASN1_TYPE_EMPTY;
-  ASN1_TYPE value=ASN1_TYPE_EMPTY;
+  ASN1_TYPE crl = ASN1_TYPE_EMPTY;
+  ASN1_TYPE value = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
   int max_len;
 
-  max_len=*der_len;
+  max_len = *der_len;
+
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.CertificateList", &crl);
 
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.CertificateList",&crl);
- 
-  /* Use the next 3 lines to visit the empty certificate */ 
+  /* Use the next 3 lines to visit the empty certificate */
   /*  printf("-----------------\n");
-   asn1_visit_tree(crl,"");   
-   printf("-----------------\n"); */
-   
+     asn1_visit_tree(crl,"");   
+     printf("-----------------\n"); */
+
 
-  /* version: v2(1) */  
-  result=asn1_write_value(crl,"tbsCertList.version","v2",0); 
+  /* version: v2(1) */
+  result = asn1_write_value (crl, "tbsCertList.version", "v2", 0);
 
 
   /* signature: dsa-with-sha */
-  len = sizeof(str)-1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
-  result=asn1_write_value(crl,"tbsCertList.signature.algorithm",str,1);   
-  result=asn1_write_value(crl,"tbsCertList.signature.parameters",NULL,0);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+  result = asn1_write_value (crl, "tbsCertList.signature.algorithm", str, 1);
+  result =
+    asn1_write_value (crl, "tbsCertList.signature.parameters", NULL, 0);
 
 
   /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
-  result=asn1_write_value(crl,"tbsCertList.issuer","rdnSequence",1);
+  result = asn1_write_value (crl, "tbsCertList.issuer", "rdnSequence", 1);
 
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",1);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
+  result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 1);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 1);
   /* C */
-  len = sizeof(str)-1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
-			  &value);
-  result=asn1_write_value(value,"","US",2);
-  *der_len=max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-
-  asn1_delete_structure(&value);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",4);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",4);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
+		     &len);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
+  result = asn1_write_value (value, "", "US", 2);
+  *der_len = max_len;
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
+
+
+  result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 4);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 4);
   /* O */
-  len = sizeof(str)-1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,8);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
-			  &value);
-  result=asn1_write_value(value,"","printableString",1);
-  result=asn1_write_value(value,"printableString","gov",3);
-  *der_len=max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",1);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
+		     &len);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
+		      str, 8);
+  result =
+    asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
+			 &value);
+  result = asn1_write_value (value, "", "printableString", 1);
+  result = asn1_write_value (value, "printableString", "gov", 3);
+  *der_len = max_len;
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
+
+
+  result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 1);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 1);
   /* OU */
-  len = sizeof(str)-1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
-		    str,&len);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
-  result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
-  result=asn1_write_value(value,"","printableString",1);
-  result=asn1_write_value(value,"printableString","nist",4);
-  *der_len=max_len;
-  result=asn1_der_coding(value,"",der,der_len,errorDescription);
-  asn1_delete_structure(&value);
-  result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
+		     str, &len);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
+		      str, 1);
+  result =
+    asn1_create_element (cert_def,
+			 "PKIX1Implicit88.X520OrganizationalUnitName",
+			 &value);
+  result = asn1_write_value (value, "", "printableString", 1);
+  result = asn1_write_value (value, "printableString", "nist", 4);
+  *der_len = max_len;
+  result = asn1_der_coding (value, "", der, der_len, errorDescription);
+  asn1_delete_structure (&value);
+  result =
+    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
+		      der, *der_len);
 
 
   /* validity */
-  result=asn1_write_value(crl,"tbsCertList.thisUpdate","utcTime",1);
-  result=asn1_write_value(crl,"tbsCertList.thisUpdate.utcTime","970801000000Z",1);
+  result = asn1_write_value (crl, "tbsCertList.thisUpdate", "utcTime", 1);
+  result =
+    asn1_write_value (crl, "tbsCertList.thisUpdate.utcTime", "970801000000Z",
+		      1);
 
-  result=asn1_write_value(crl,"tbsCertList.nextUpdate","utcTime",1);
-  result=asn1_write_value(crl,"tbsCertList.nextUpdate.utcTime","970808000000Z",1);
+  result = asn1_write_value (crl, "tbsCertList.nextUpdate", "utcTime", 1);
+  result =
+    asn1_write_value (crl, "tbsCertList.nextUpdate.utcTime", "970808000000Z",
+		      1);
 
 
   /* revokedCertificates */
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates","NEW",1);
-  str[0]=18;
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.userCertificate",str,1);
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.revocationDate","utcTime",1);
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime","970731000000Z",1);
-
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions","NEW",1);
-  len = sizeof(str)-1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-cRLReasons",
-		    str,&len);
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID",str,1); /* reasonCode */
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical","FALSE",1); 
-  str2="\x0a\x01\x01";
-  result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",str2,3); 
+  result =
+    asn1_write_value (crl, "tbsCertList.revokedCertificates", "NEW", 1);
+  str[0] = 18;
+  result =
+    asn1_write_value (crl,
+		      "tbsCertList.revokedCertificates.?LAST.userCertificate",
+		      str, 1);
+  result =
+    asn1_write_value (crl,
+		      "tbsCertList.revokedCertificates.?LAST.revocationDate",
+		      "utcTime", 1);
+  result =
+    asn1_write_value (crl,
+		      "tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime",
+		      "970731000000Z", 1);
+
+  result =
+    asn1_write_value (crl,
+		      "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions",
+		      "NEW", 1);
+  len = sizeof (str) - 1;
+  result = asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-cRLReasons",
+			    str, &len);
+  result = asn1_write_value (crl, "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID", str, 1);	/* reasonCode */
+  result =
+    asn1_write_value (crl,
+		      "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical",
+		      "FALSE", 1);
+  str2 = "\x0a\x01\x01";
+  result =
+    asn1_write_value (crl,
+		      "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",
+		      str2, 3);
 
 
   /* crlExtensions */
-  result=asn1_write_value(crl,"tbsCertList.crlExtensions",NULL,0);
+  result = asn1_write_value (crl, "tbsCertList.crlExtensions", NULL, 0);
 
 
   /* signatureAlgorithm: dsa-with-sha  */
-  len = sizeof(str)-1;
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
-  result=asn1_write_value(crl,"signatureAlgorithm.algorithm",str,1);  
-  result=asn1_write_value(crl,"signatureAlgorithm.parameters",NULL,0); /* NO OPTION */  
+  len = sizeof (str) - 1;
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+  result = asn1_write_value (crl, "signatureAlgorithm.algorithm", str, 1);
+  result = asn1_write_value (crl, "signatureAlgorithm.parameters", NULL, 0);	/* NO OPTION */
 
   /* signature */
-  *der_len=max_len;
-  result=asn1_der_coding(crl,"tbsCertList",der,der_len,errorDescription);
-  if(result!=ASN1_SUCCESS){
-    printf("\n'tbsCertList' encoding creation: ERROR\n");
-    return;
-  }
+  *der_len = max_len;
+  result =
+    asn1_der_coding (crl, "tbsCertList", der, der_len, errorDescription);
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("\n'tbsCertList' encoding creation: ERROR\n");
+      return;
+    }
 
   /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
-  result=asn1_write_value(crl,"signature",str2,46*8);  
-  
+  result = asn1_write_value (crl, "signature", str2, 46 * 8);
+
 
   /* Use the next 3 lines to visit the certificate */
   /* printf("-----------------\n");   
      asn1_visit_tree(crl,"");  
      printf("-----------------\n"); */
 
-  *der_len=max_len;
-  result=asn1_der_coding(crl,"",der,der_len,errorDescription);
-  if(result!=ASN1_SUCCESS){
-    printf("\n'crl1' encoding creation: ERROR\n");
-    return;
-  }
-
-  /* Print the 'Certificate1' DER encoding */ 
-  printf("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",*der_len);
-  for(k=0;k<*der_len;k++) printf("%02x ",der[k]);  
-  printf("\n-----------------\n");
+  *der_len = max_len;
+  result = asn1_der_coding (crl, "", der, der_len, errorDescription);
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("\n'crl1' encoding creation: ERROR\n");
+      return;
+    }
+
+  /* Print the 'Certificate1' DER encoding */
+  printf ("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",
+	  *der_len);
+  for (k = 0; k < *der_len; k++)
+    printf ("%02x ", der[k]);
+  printf ("\n-----------------\n");
 
   /* Clear the "certificate1" structure */
-  asn1_delete_structure(&crl);
+  asn1_delete_structure (&crl);
 }
 
 
@@ -347,48 +434,52 @@ create_CRL(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
 /*              string                                */
 /* Parameters:                                        */
 /*   unsigned char *der: the encoding string          */
-/*   int der_len: number of bytes of der string      */ 
+/*   int der_len: number of bytes of der string      */
 /******************************************************/
 static void
-get_CRL(ASN1_TYPE cert_def,unsigned char *der,int der_len)
+get_CRL (ASN1_TYPE cert_def, unsigned char *der, int der_len)
 {
-  int result,len,start,end;
-  unsigned char str[1024],str2[1024];
-  ASN1_TYPE crl2=ASN1_TYPE_EMPTY;
+  int result, len, start, end;
+  unsigned char str[1024], str2[1024];
+  ASN1_TYPE crl2 = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
 
 
-  asn1_create_element(cert_def,"PKIX1Implicit88.CertificateList",&crl2);
+  asn1_create_element (cert_def, "PKIX1Implicit88.CertificateList", &crl2);
+
+  result = asn1_der_decoding (&crl2, der, der_len, errorDescription);
+
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("Problems with DER encoding\n");
+      return;
+    }
 
-  result=asn1_der_decoding(&crl2,der,der_len,errorDescription);
- 
-  if(result!=ASN1_SUCCESS){
-    printf("Problems with DER encoding\n");
-    return;
-  }
-   
 
   /* issuer */
-  get_Name_type(cert_def,crl2,"tbsCertList.issuer",str);
-  printf("crl2:\nissuer: %s\n",str);
+  get_Name_type (cert_def, crl2, "tbsCertList.issuer", str);
+  printf ("crl2:\nissuer: %s\n", str);
 
 
   /* Verify sign */
-  len = sizeof(str)-1;
-  result=asn1_read_value(crl2,"signatureAlgorithm.algorithm",str,&len);
+  len = sizeof (str) - 1;
+  result = asn1_read_value (crl2, "signatureAlgorithm.algorithm", str, &len);
 
-  result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
-  if(!strcmp(str,str2)){  /* dsa-with-sha */
+  result =
+    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str2,
+		     &len);
+  if (!strcmp (str, str2))
+    {				/* dsa-with-sha */
 
-    result=asn1_der_decoding_startEnd(crl2,der,der_len,
-			     "tbsCertList",&start,&end);
+      result = asn1_der_decoding_startEnd (crl2, der, der_len,
+					   "tbsCertList", &start, &end);
 
-    /* add the lines to calculate the sha on der[start]..der[end] */
+      /* add the lines to calculate the sha on der[start]..der[end] */
 
-    result=asn1_read_value(crl2,"signature",str,&len);
+      result = asn1_read_value (crl2, "signature", str, &len);
 
-    /* compare the previous value to signature ( with issuer public key) */ 
-  }
+      /* compare the previous value to signature ( with issuer public key) */
+    }
 
   /* Use the next 3 lines to visit the certificate */
   /* printf("-----------------\n");   
@@ -397,7 +488,7 @@ get_CRL(ASN1_TYPE cert_def,unsigned char *der,int der_len)
 
 
   /* Clear the "crl2" structure */
-  asn1_delete_structure(&crl2);
+  asn1_delete_structure (&crl2);
 }
 
 extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
@@ -406,50 +497,44 @@ extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
 /* Function : main                                      */
 /* Description: reads the certificate description.      */
 /*              Creates a certificate and calculate     */
-/*              the der encoding. After that creates    */  
+/*              the der encoding. After that creates    */
 /*              another certificate from der string     */
 /********************************************************/
 int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
 {
-  int result,der_len;
+  int result, der_len;
   unsigned char der[1024];
-  ASN1_TYPE PKIX1Implicit88=ASN1_TYPE_EMPTY;
+  ASN1_TYPE PKIX1Implicit88 = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
 
-  if(1)
-    result=asn1_array2tree(pkix_asn1_tab,&PKIX1Implicit88,errorDescription);   
+  if (1)
+    result =
+      asn1_array2tree (pkix_asn1_tab, &PKIX1Implicit88, errorDescription);
   else
-    result=asn1_parser2tree("pkix.asn",&PKIX1Implicit88,errorDescription);
-
-  if(result != ASN1_SUCCESS){
-    asn1_perror(result);
-    printf("%s\n",errorDescription);
-    exit(1);
-  }
-  
+    result =
+      asn1_parser2tree ("pkix.asn", &PKIX1Implicit88, errorDescription);
+
+  if (result != ASN1_SUCCESS)
+    {
+      asn1_perror (result);
+      printf ("%s\n", errorDescription);
+      exit (1);
+    }
+
   /* Use the following 3 lines to visit the PKIX1Implicit structures */
   /* printf("-----------------\n");
      asn1_visit_tree(cert_def,"PKIX1Implicit88");   
      printf("-----------------\n"); */
 
-  der_len=1024;
-  create_CRL(PKIX1Implicit88,der,&der_len);
+  der_len = 1024;
+  create_CRL (PKIX1Implicit88, der, &der_len);
 
 
-  get_CRL(PKIX1Implicit88,der,der_len);
+  get_CRL (PKIX1Implicit88, der, der_len);
 
   /* Clear the "PKIX1Implicit88" structures */
-  asn1_delete_structure(&PKIX1Implicit88);
+  asn1_delete_structure (&PKIX1Implicit88);
 
   return 0;
 }
-
-
-
-
-
-
-
-
-
diff --git a/lib/coding.c b/lib/coding.c
index 025fd36..ea0c7d9 100644
--- a/lib/coding.c
+++ b/lib/coding.c
@@ -45,7 +45,7 @@
 /* Return:                                            */
 /******************************************************/
 static void
-_asn1_error_description_value_not_found (ASN1_TYPE  node,
+_asn1_error_description_value_not_found (ASN1_TYPE node,
 					 char *ErrorDescription)
 {
 
@@ -370,7 +370,7 @@ asn1_bit_der (const unsigned char *str, int bit_len,
 /*   otherwise ASN1_SUCCESS.                          */
 /******************************************************/
 static asn1_retCode
-_asn1_complete_explicit_tag (ASN1_TYPE  node, unsigned char *der,
+_asn1_complete_explicit_tag (ASN1_TYPE node, unsigned char *der,
 			     int *counter, int *max_len)
 {
   ASN1_TYPE p;
@@ -443,7 +443,7 @@ _asn1_complete_explicit_tag (ASN1_TYPE  node, unsigned char *der,
 /*   otherwise ASN1_SUCCESS.                          */
 /******************************************************/
 static asn1_retCode
-_asn1_insert_tag_der (ASN1_TYPE  node, unsigned char *der, int *counter,
+_asn1_insert_tag_der (ASN1_TYPE node, unsigned char *der, int *counter,
 		      int *max_len)
 {
   ASN1_TYPE p;
@@ -604,7 +604,7 @@ _asn1_insert_tag_der (ASN1_TYPE  node, unsigned char *der, int *counter,
 /* Return:                                            */
 /******************************************************/
 static void
-_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE  node)
+_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE node)
 {
   struct vet
   {
@@ -718,7 +718,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE  node)
 /* Return:                                            */
 /******************************************************/
 static void
-_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE  node)
+_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE node)
 {
   struct vet
   {
diff --git a/lib/decoding.c b/lib/decoding.c
index 532b2ed..d72a4c0 100644
--- a/lib/decoding.c
+++ b/lib/decoding.c
@@ -180,11 +180,11 @@ asn1_get_length_ber (const unsigned char *ber, int ber_len, int *len)
   int ret;
   long err;
 
-  ret = asn1_get_length_der( ber, ber_len, len);
+  ret = asn1_get_length_der (ber, ber_len, len);
   if (ret == -1)
-    {			/* indefinite length method */
+    {				/* indefinite length method */
       ret = ber_len;
-      err = _asn1_get_indefinite_length_string (ber+1, &ret);
+      err = _asn1_get_indefinite_length_string (ber + 1, &ret);
       if (err != ASN1_SUCCESS)
 	return -3;
     }
@@ -385,7 +385,7 @@ _asn1_extract_tag_der (ASN1_TYPE node, const unsigned char *der, int der_len,
 					 &len2);
 		  if (len3 < 0)
 		    return ASN1_DER_ERROR;
-                  
+
 		  counter += len2;
 		  if (counter > der_len)
 		    return ASN1_DER_ERROR;
@@ -598,45 +598,48 @@ _asn1_delete_not_used (ASN1_TYPE node)
 }
 
 static asn1_retCode
-_asn1_extract_der_octet(ASN1_TYPE node, const unsigned char *der, int der_len)
+_asn1_extract_der_octet (ASN1_TYPE node, const unsigned char *der,
+			 int der_len)
 {
-int len2, len3;
-int counter2, counter_end;
+  int len2, len3;
+  int counter2, counter_end;
 
-    len2 = asn1_get_length_der (der, der_len, &len3);
-    if (len2 < -1)
-        return ASN1_DER_ERROR;
+  len2 = asn1_get_length_der (der, der_len, &len3);
+  if (len2 < -1)
+    return ASN1_DER_ERROR;
 
-    counter2 = len3 + 1;
+  counter2 = len3 + 1;
 
-    if (len2 == -1)
-        counter_end = der_len - 2;
-    else
-        counter_end = der_len;
+  if (len2 == -1)
+    counter_end = der_len - 2;
+  else
+    counter_end = der_len;
 
-    while (counter2 < counter_end)
-      {
-	len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
+  while (counter2 < counter_end)
+    {
+      len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
 
-        if (len2 < -1)
-	  return ASN1_DER_ERROR;
+      if (len2 < -1)
+	return ASN1_DER_ERROR;
 
-	if (len2 > 0)
-	  {
-	    _asn1_append_value( node, der + counter2 + len3, len2);
-          }
-        else
-          { /* indefinite */
-            
-            len2 = _asn1_extract_der_octet( node, der+counter2+len3, der_len-counter2-len3);
-            if (len2 < 0)
-                return len2;
-          }
-
-        counter2 += len2 + len3 + 1;
-      }
-      
-      return ASN1_SUCCESS;
+      if (len2 > 0)
+	{
+	  _asn1_append_value (node, der + counter2 + len3, len2);
+	}
+      else
+	{			/* indefinite */
+
+	  len2 =
+	    _asn1_extract_der_octet (node, der + counter2 + len3,
+				     der_len - counter2 - len3);
+	  if (len2 < 0)
+	    return len2;
+	}
+
+      counter2 += len2 + len3 + 1;
+    }
+
+  return ASN1_SUCCESS;
 }
 
 
@@ -692,17 +695,17 @@ _asn1_get_octet_string (const unsigned char *der, ASN1_TYPE node, int *len)
 	{
 	  unsigned char temp[DER_LEN];
 	  int ret;
-	  
-	  len2 = sizeof(temp);
+
+	  len2 = sizeof (temp);
 
 	  asn1_length_der (tot_len, temp, &len2);
 	  _asn1_set_value (node, temp, len2);
 
 	  tot_len += len2;
 
- 	  ret = _asn1_extract_der_octet(node, der, *len);
- 	  if (ret!=ASN1_SUCCESS)
-             return ret;
+	  ret = _asn1_extract_der_octet (node, der, *len);
+	  if (ret != ASN1_SUCCESS)
+	    return ret;
 
 	}
     }
@@ -1241,7 +1244,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 	      if (len4 != -1)
 		{
 		  len2 += len4;
-		  _asn1_set_value_octet (p, der+counter, len2+len3);
+		  _asn1_set_value_octet (p, der + counter, len2 + len3);
 		  counter += len2 + len3;
 		}
 	      else
@@ -1261,7 +1264,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 		      return ris;
 		    }
 
-		  _asn1_set_value_octet (p, der+counter, len2);
+		  _asn1_set_value_octet (p, der + counter, len2);
 		  counter += len2;
 
 		  /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
@@ -1907,7 +1910,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 		  len2 += len4;
 		  if (state == FOUND)
 		    {
-		      _asn1_set_value_octet (p, der+counter, len2+len3);
+		      _asn1_set_value_octet (p, der + counter, len2 + len3);
 		      temp2 = NULL;
 
 		      if (p == nodeFound)
@@ -1934,7 +1937,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
 		  if (state == FOUND)
 		    {
-		      _asn1_set_value_octet (p, der+counter, len2);
+		      _asn1_set_value_octet (p, der + counter, len2);
 
 		      if (p == nodeFound)
 			state = EXIT;
diff --git a/lib/element.c b/lib/element.c
index 1a5ad33..4b4c838 100644
--- a/lib/element.c
+++ b/lib/element.c
@@ -35,7 +35,7 @@
 #include "element.h"
 
 void
-_asn1_hierarchical_name (ASN1_TYPE  node, char *name, int name_size)
+_asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
 {
   ASN1_TYPE p;
   char tmp_name[64];
@@ -128,7 +128,7 @@ _asn1_convert_integer (const char *value, unsigned char *value_out,
 
 
 int
-_asn1_append_sequence_set (ASN1_TYPE  node)
+_asn1_append_sequence_set (ASN1_TYPE node)
 {
   ASN1_TYPE p, p2;
   char temp[10];
@@ -417,7 +417,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
 	  (!negative && (value_temp[k] & 0x80)))
 	k--;
 
-      _asn1_set_value_octet (node, value_temp+k, len-k);
+      _asn1_set_value_octet (node, value_temp + k, len - k);
 
       if (node->type & CONST_DEFAULT)
 	{
diff --git a/lib/element.h b/lib/element.h
index f0314d2..b5d9eb9 100644
--- a/lib/element.h
+++ b/lib/element.h
@@ -3,11 +3,12 @@
 #define _ELEMENT_H
 
 
-asn1_retCode _asn1_append_sequence_set(ASN1_TYPE node);
+asn1_retCode _asn1_append_sequence_set (ASN1_TYPE node);
 
-asn1_retCode _asn1_convert_integer(const char *value,unsigned char *value_out,
-			  int value_out_size, int *len);
+asn1_retCode _asn1_convert_integer (const char *value,
+				    unsigned char *value_out,
+				    int value_out_size, int *len);
 
-void _asn1_hierarchical_name(ASN1_TYPE node,char *name,int name_size);
+void _asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size);
 
 #endif
diff --git a/lib/gstr.h b/lib/gstr.h
index 992fd0f..5452fa4 100644
--- a/lib/gstr.h
+++ b/lib/gstr.h
@@ -1,5 +1,5 @@
-void _asn1_str_cpy( char* dest, size_t dest_tot_size, const char* src);
-void _asn1_str_cat( char* dest, size_t dest_tot_size, const char* src);
+void _asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
+void _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
 
 #define Estrcpy(x,y) _asn1_str_cpy(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
 #define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
diff --git a/lib/int.h b/lib/int.h
index 3bcbf43..c16e657 100644
--- a/lib/int.h
+++ b/lib/int.h
@@ -59,7 +59,7 @@ struct node_asn
 #define _asn1_realloc realloc
 #define _asn1_strdup strdup
 
-#define MAX_LOG_SIZE 1024 /* maximum number of characters of a log message */
+#define MAX_LOG_SIZE 1024	/* maximum number of characters of a log message */
 
 /* Define used for visiting trees. */
 #define UP     1
@@ -107,13 +107,13 @@ struct node_asn
 #define CONST_EXPLICIT    (1<<11)
 #define CONST_IMPLICIT    (1<<12)
 
-#define CONST_TAG         (1<<13)  /*  Used in ASN.1 assignement  */
+#define CONST_TAG         (1<<13)	/*  Used in ASN.1 assignement  */
 #define CONST_OPTION      (1<<14)
 #define CONST_DEFAULT     (1<<15)
 #define CONST_TRUE        (1<<16)
 #define CONST_FALSE       (1<<17)
 
-#define CONST_LIST        (1<<18)  /*  Used with TYPE_INTEGER and TYPE_BIT_STRING  */
+#define CONST_LIST        (1<<18)	/*  Used with TYPE_INTEGER and TYPE_BIT_STRING  */
 #define CONST_MIN_MAX     (1<<19)
 
 #define CONST_1_PARAM     (1<<20)
diff --git a/lib/libtasn1.h b/lib/libtasn1.h
index 7b304c2..22a9608 100644
--- a/lib/libtasn1.h
+++ b/lib/libtasn1.h
@@ -29,7 +29,8 @@
 #include <time.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #define ASN1_VERSION "2.0"
@@ -105,9 +106,9 @@ extern "C" {
   /*****************************************/
   struct static_struct_asn
   {
-    const char *name;	/* Node name */
-    unsigned int type;	/* Node type */
-    const void *value;	/* Node value */
+    const char *name;		/* Node name */
+    unsigned int type;		/* Node type */
+    const void *value;		/* Node value */
   };
   typedef struct static_struct_asn ASN1_ARRAY_TYPE;
 
@@ -141,8 +142,8 @@ extern "C" {
 				ASN1_TYPE * definitions,
 				char *errorDescription);
 
-  void asn1_print_structure (FILE *out, ASN1_TYPE structure, const char *name,
-			     int mode);
+  void asn1_print_structure (FILE * out, ASN1_TYPE structure,
+			     const char *name, int mode);
 
   asn1_retCode asn1_create_element (ASN1_TYPE definitions,
 				    const char *source_name,
diff --git a/lib/parser_aux.c b/lib/parser_aux.c
index 23bccd7..29d0a18 100644
--- a/lib/parser_aux.c
+++ b/lib/parser_aux.c
@@ -198,13 +198,14 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
 /* Return: pointer to the NODE_ASN element.                       */
 /******************************************************************/
 ASN1_TYPE
-_asn1_set_value (ASN1_TYPE  node, const void *value, unsigned int len)
+_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len)
 {
   if (node == NULL)
     return node;
   if (node->value)
     {
-      if (node->value != node->small_value) _asn1_free (node->value);
+      if (node->value != node->small_value)
+	_asn1_free (node->value);
       node->value = NULL;
       node->value_len = 0;
     }
@@ -212,13 +213,16 @@ _asn1_set_value (ASN1_TYPE  node, const void *value, unsigned int len)
   if (!len)
     return node;
 
-  if (len < sizeof(node->small_value)) {
-    node->value = node->small_value;
-  } else {
-    node->value = _asn1_malloc (len);
-    if (node->value == NULL)
-      return NULL;
-  }
+  if (len < sizeof (node->small_value))
+    {
+      node->value = node->small_value;
+    }
+  else
+    {
+      node->value = _asn1_malloc (len);
+      if (node->value == NULL)
+	return NULL;
+    }
   node->value_len = len;
 
   memcpy (node->value, value, len);
@@ -237,10 +241,10 @@ _asn1_set_value (ASN1_TYPE  node, const void *value, unsigned int len)
 /* Return: pointer to the NODE_ASN element.                       */
 /******************************************************************/
 ASN1_TYPE
-_asn1_set_value_octet (ASN1_TYPE  node, const void *value, unsigned int len)
+_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len)
 {
-int len2;
-void* temp;
+  int len2;
+  void *temp;
 
   if (node == NULL)
     return node;
@@ -258,14 +262,15 @@ void* temp;
  * value.
  */
 ASN1_TYPE
-_asn1_set_value_m (ASN1_TYPE  node, void *value, unsigned int len)
+_asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len)
 {
   if (node == NULL)
     return node;
 
   if (node->value)
     {
-      if (node->value != node->small_value) _asn1_free (node->value);
+      if (node->value != node->small_value)
+	_asn1_free (node->value);
       node->value = NULL;
       node->value_len = 0;
     }
@@ -290,7 +295,7 @@ _asn1_set_value_m (ASN1_TYPE  node, void *value, unsigned int len)
 /* Return: pointer to the NODE_ASN element.                       */
 /******************************************************************/
 ASN1_TYPE
-_asn1_append_value (ASN1_TYPE  node, const void *value, unsigned int len)
+_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len)
 {
   if (node == NULL)
     return node;
@@ -298,13 +303,14 @@ _asn1_append_value (ASN1_TYPE  node, const void *value, unsigned int len)
     {
       /* value is allocated */
       int prev_len = node->value_len;
-      node->value_len+=len;
-      node->value = _asn1_realloc( node->value, node->value_len);
-      if (node->value == NULL) {
-	node->value_len = 0;
-	return NULL;
-      }
-      memcpy( &node->value[prev_len], value, len);
+      node->value_len += len;
+      node->value = _asn1_realloc (node->value, node->value_len);
+      if (node->value == NULL)
+	{
+	  node->value_len = 0;
+	  return NULL;
+	}
+      memcpy (&node->value[prev_len], value, len);
 
       return node;
     }
@@ -312,19 +318,20 @@ _asn1_append_value (ASN1_TYPE  node, const void *value, unsigned int len)
     {
       /* value is in node */
       int prev_len = node->value_len;
-      node->value_len+=len;
-      node->value = _asn1_malloc( node->value_len);
-      if (node->value == NULL) {
-	node->value_len = 0;
-	return NULL;
-      }
-      memcpy( node->value, node->small_value, prev_len);
-      memcpy( &node->value[prev_len], value, len);
+      node->value_len += len;
+      node->value = _asn1_malloc (node->value_len);
+      if (node->value == NULL)
+	{
+	  node->value_len = 0;
+	  return NULL;
+	}
+      memcpy (node->value, node->small_value, prev_len);
+      memcpy (&node->value[prev_len], value, len);
 
       return node;
     }
-    else /* node->value == NULL */
-    return _asn1_set_value(node, value, len);
+  else				/* node->value == NULL */
+    return _asn1_set_value (node, value, len);
 }
 
 /******************************************************************/
@@ -338,7 +345,7 @@ _asn1_append_value (ASN1_TYPE  node, const void *value, unsigned int len)
 /* Return: pointer to the NODE_ASN element.                       */
 /******************************************************************/
 ASN1_TYPE
-_asn1_set_name (ASN1_TYPE  node, const char *name)
+_asn1_set_name (ASN1_TYPE node, const char *name)
 {
   if (node == NULL)
     return node;
@@ -373,7 +380,7 @@ _asn1_set_name (ASN1_TYPE  node, const char *name)
 /* Return: pointer to *NODE.                                      */
 /******************************************************************/
 ASN1_TYPE
-_asn1_set_right (ASN1_TYPE  node, ASN1_TYPE  right)
+_asn1_set_right (ASN1_TYPE node, ASN1_TYPE right)
 {
   if (node == NULL)
     return node;
@@ -392,7 +399,7 @@ _asn1_set_right (ASN1_TYPE  node, ASN1_TYPE  right)
 /* Return: field RIGHT of NODE.                                   */
 /******************************************************************/
 ASN1_TYPE
-_asn1_get_right (ASN1_TYPE  node)
+_asn1_get_right (ASN1_TYPE node)
 {
   if (node == NULL)
     return NULL;
@@ -407,7 +414,7 @@ _asn1_get_right (ASN1_TYPE  node)
 /* Return: pointer to the last element along the right chain.     */
 /******************************************************************/
 ASN1_TYPE
-_asn1_get_last_right (ASN1_TYPE  node)
+_asn1_get_last_right (ASN1_TYPE node)
 {
   ASN1_TYPE p;
 
@@ -429,7 +436,7 @@ _asn1_get_last_right (ASN1_TYPE  node)
 /* Return: pointer to *NODE.                                      */
 /******************************************************************/
 ASN1_TYPE
-_asn1_set_down (ASN1_TYPE  node, ASN1_TYPE  down)
+_asn1_set_down (ASN1_TYPE node, ASN1_TYPE down)
 {
   if (node == NULL)
     return node;
@@ -448,7 +455,7 @@ _asn1_set_down (ASN1_TYPE  node, ASN1_TYPE  down)
 /* Return: field DOWN of NODE.                                    */
 /******************************************************************/
 ASN1_TYPE
-_asn1_get_down (ASN1_TYPE  node)
+_asn1_get_down (ASN1_TYPE node)
 {
   if (node == NULL)
     return NULL;
@@ -463,7 +470,7 @@ _asn1_get_down (ASN1_TYPE  node)
 /* Return: a null terminated string.                              */
 /******************************************************************/
 char *
-_asn1_get_name (ASN1_TYPE  node)
+_asn1_get_name (ASN1_TYPE node)
 {
   if (node == NULL)
     return NULL;
@@ -482,7 +489,7 @@ _asn1_get_name (ASN1_TYPE  node)
 /* Return: NODE pointer.                                          */
 /******************************************************************/
 ASN1_TYPE
-_asn1_mod_type (ASN1_TYPE  node, unsigned int value)
+_asn1_mod_type (ASN1_TYPE node, unsigned int value)
 {
   if (node == NULL)
     return node;
@@ -499,7 +506,7 @@ _asn1_mod_type (ASN1_TYPE  node, unsigned int value)
 /*   node: NODE_ASN element pointer.                              */
 /******************************************************************/
 void
-_asn1_remove_node (ASN1_TYPE  node)
+_asn1_remove_node (ASN1_TYPE node)
 {
   if (node == NULL)
     return;
@@ -519,7 +526,7 @@ _asn1_remove_node (ASN1_TYPE  node)
 /* Return: Null if not found.                                     */
 /******************************************************************/
 ASN1_TYPE
-_asn1_find_up (ASN1_TYPE  node)
+_asn1_find_up (ASN1_TYPE node)
 {
   ASN1_TYPE p;
 
diff --git a/lib/parser_aux.h b/lib/parser_aux.h
index d30a34c..564f64e 100644
--- a/lib/parser_aux.h
+++ b/lib/parser_aux.h
@@ -7,67 +7,53 @@
 /***************************************/
 /*  Functions used by ASN.1 parser     */
 /***************************************/
-ASN1_TYPE
-_asn1_add_node(unsigned int type);
+ASN1_TYPE _asn1_add_node (unsigned int type);
 
 ASN1_TYPE
-_asn1_set_value(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len);
 
-ASN1_TYPE
-_asn1_set_value_m(ASN1_TYPE node,void *value,unsigned int len);
+ASN1_TYPE _asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len);
 
 ASN1_TYPE
-_asn1_set_value_octet(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len);
 
 ASN1_TYPE
-_asn1_append_value(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len);
 
-ASN1_TYPE
-_asn1_set_name(ASN1_TYPE node,const char *name);
+ASN1_TYPE _asn1_set_name (ASN1_TYPE node, const char *name);
 
-ASN1_TYPE
-_asn1_set_right(ASN1_TYPE node, ASN1_TYPE right);
+ASN1_TYPE _asn1_set_right (ASN1_TYPE node, ASN1_TYPE right);
 
-ASN1_TYPE
-_asn1_get_right(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_right (ASN1_TYPE node);
 
-ASN1_TYPE
-_asn1_get_last_right(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_last_right (ASN1_TYPE node);
 
-ASN1_TYPE
-_asn1_set_down(ASN1_TYPE node, ASN1_TYPE down);
+ASN1_TYPE _asn1_set_down (ASN1_TYPE node, ASN1_TYPE down);
 
-char *
-_asn1_get_name(ASN1_TYPE node);
+char *_asn1_get_name (ASN1_TYPE node);
 
-ASN1_TYPE
-_asn1_get_down(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_down (ASN1_TYPE node);
 
-ASN1_TYPE
-_asn1_mod_type(ASN1_TYPE node,unsigned int value);
+ASN1_TYPE _asn1_mod_type (ASN1_TYPE node, unsigned int value);
 
-void
-_asn1_remove_node(ASN1_TYPE node);
+void _asn1_remove_node (ASN1_TYPE node);
 
-void _asn1_delete_list(void);
+void _asn1_delete_list (void);
 
-void _asn1_delete_list_and_nodes(void);
+void _asn1_delete_list_and_nodes (void);
 
-char * _asn1_ltostr(long v,char *str);
+char *_asn1_ltostr (long v, char *str);
 
-ASN1_TYPE _asn1_find_up(ASN1_TYPE node);
+ASN1_TYPE _asn1_find_up (ASN1_TYPE node);
 
-asn1_retCode _asn1_change_integer_value(ASN1_TYPE node);
+asn1_retCode _asn1_change_integer_value (ASN1_TYPE node);
 
-asn1_retCode _asn1_expand_object_id(ASN1_TYPE node);
+asn1_retCode _asn1_expand_object_id (ASN1_TYPE node);
 
-asn1_retCode _asn1_type_set_config(ASN1_TYPE node);
+asn1_retCode _asn1_type_set_config (ASN1_TYPE node);
 
-asn1_retCode _asn1_check_identifier(ASN1_TYPE node);
+asn1_retCode _asn1_check_identifier (ASN1_TYPE node);
 
-asn1_retCode _asn1_set_default_tag(ASN1_TYPE node);
+asn1_retCode _asn1_set_default_tag (ASN1_TYPE node);
 
 #endif
-
-
-
diff --git a/lib/structure.c b/lib/structure.c
index 47b6875..bea3077 100644
--- a/lib/structure.c
+++ b/lib/structure.c
@@ -69,7 +69,7 @@ _asn1_add_node_only (unsigned int type)
 /* Return: NULL if not found.                                     */
 /******************************************************************/
 ASN1_TYPE
-_asn1_find_left (ASN1_TYPE  node)
+_asn1_find_left (ASN1_TYPE node)
 {
   if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
     return NULL;
@@ -386,7 +386,7 @@ asn1_delete_element (ASN1_TYPE structure, const char *element_name)
 }
 
 ASN1_TYPE
-_asn1_copy_structure3 (ASN1_TYPE  source_node)
+_asn1_copy_structure3 (ASN1_TYPE source_node)
 {
   ASN1_TYPE dest_node, p_s, p_d, p_d_prev;
   int move;
@@ -408,7 +408,7 @@ _asn1_copy_structure3 (ASN1_TYPE  source_node)
 	  if (p_s->name)
 	    _asn1_set_name (p_d, p_s->name);
 	  if (p_s->value)
-             _asn1_set_value (p_d, p_s->value, p_s->value_len);
+	    _asn1_set_value (p_d, p_s->value, p_s->value_len);
 	  move = DOWN;
 	}
       else
@@ -455,7 +455,7 @@ _asn1_copy_structure3 (ASN1_TYPE  source_node)
 
 
 static ASN1_TYPE
-_asn1_copy_structure2 (ASN1_TYPE  root, const char *source_name)
+_asn1_copy_structure2 (ASN1_TYPE root, const char *source_name)
 {
   ASN1_TYPE source_node;
 
@@ -467,7 +467,7 @@ _asn1_copy_structure2 (ASN1_TYPE  root, const char *source_name)
 
 
 static asn1_retCode
-_asn1_type_choice_config (ASN1_TYPE  node)
+_asn1_type_choice_config (ASN1_TYPE node)
 {
   ASN1_TYPE p, p2, p3, p4;
   int move, tlen;
@@ -552,7 +552,7 @@ _asn1_type_choice_config (ASN1_TYPE  node)
 
 
 static asn1_retCode
-_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE  root)
+_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE root)
 {
   ASN1_TYPE p, p2, p3;
   char name2[ASN1_MAX_NAME_SIZE + 2];
diff --git a/lib/structure.h b/lib/structure.h
index 1803e7a..7257986 100644
--- a/lib/structure.h
+++ b/lib/structure.h
@@ -8,14 +8,14 @@
 #ifndef _STRUCTURE_H
 #define _STRUCTURE_H
 
-asn1_retCode _asn1_create_static_structure(ASN1_TYPE pointer,
-       char* output_file_name,char *vector_name);
+asn1_retCode _asn1_create_static_structure (ASN1_TYPE pointer,
+					    char *output_file_name,
+					    char *vector_name);
 
-ASN1_TYPE _asn1_copy_structure3(ASN1_TYPE source_node);
+ASN1_TYPE _asn1_copy_structure3 (ASN1_TYPE source_node);
 
-ASN1_TYPE  _asn1_add_node_only(unsigned int type);
+ASN1_TYPE _asn1_add_node_only (unsigned int type);
 
-ASN1_TYPE  _asn1_find_left(ASN1_TYPE node);
+ASN1_TYPE _asn1_find_left (ASN1_TYPE node);
 
 #endif
-
diff --git a/src/asn1Coding.c b/src/asn1Coding.c
index 22ea515..b084cb3 100644
--- a/src/asn1Coding.c
+++ b/src/asn1Coding.c
@@ -23,7 +23,7 @@
 /*****************************************************/
 /* File: asn1Coding.c                                */
 /* Description: program to generate a DER coding     */
-/*              of an ASN1 definition.               */   
+/*              of an ASN1 definition.               */
 /*****************************************************/
 
 #include <config.h>
@@ -49,24 +49,27 @@ static const char help_man[] =
   "  -o, --output FILE     output file\n"
   "  -h, --help            display this help and exit\n"
   "  -v, --version         output version information and exit.\n"
-  "\n"
-  "Report bugs to <" PACKAGE_BUGREPORT ">.";
+  "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.";
 
 #define ASSIGNMENT_SUCCESS 1
 #define ASSIGNMENT_ERROR   2
 #define ASSIGNMENT_EOF     3
 
 static int
-readAssignment(FILE *file,char *varName, char *value){
+readAssignment (FILE * file, char *varName, char *value)
+{
 
   int ret;
 
-  ret=fscanf(file,"%s",varName);
-  if(ret==EOF) return ASSIGNMENT_EOF;
-  if(!strcmp(varName,"''")) varName[0]=0;
+  ret = fscanf (file, "%s", varName);
+  if (ret == EOF)
+    return ASSIGNMENT_EOF;
+  if (!strcmp (varName, "''"))
+    varName[0] = 0;
 
-  ret=fscanf(file,"%s",value);
-  if(ret==EOF) return ASSIGNMENT_ERROR;
+  ret = fscanf (file, "%s", value);
+  if (ret == EOF)
+    return ASSIGNMENT_ERROR;
 
   return ASSIGNMENT_SUCCESS;
 }
@@ -74,34 +77,35 @@ readAssignment(FILE *file,char *varName, char *value){
 
 
 static void
-createFileName(char *inputFileName, char **outputFileName)
+createFileName (char *inputFileName, char **outputFileName)
 {
- char *char_p,*slash_p,*dot_p;
-
- /* searching the last '/' and '.' in inputFileAssignmentName */
- char_p=inputFileName;
- slash_p=inputFileName;
- while((char_p=strchr(char_p,'/'))){
-   char_p++;
-     slash_p=char_p;
- }
- 
- char_p=slash_p;
- dot_p=inputFileName+strlen(inputFileName);
- 
- while((char_p=strchr(char_p,'.'))){
-   dot_p=char_p;
-   char_p++;
- }
- 
- /* outputFileName= inputFileName + .out */
- *outputFileName=(char *)malloc(dot_p-inputFileName+1+
-			       strlen(".out"));
- memcpy(*outputFileName,inputFileName,
-          dot_p-inputFileName);
- (*outputFileName)[dot_p-inputFileName]=0;
- strcat(*outputFileName,".out");
- return;
+  char *char_p, *slash_p, *dot_p;
+
+  /* searching the last '/' and '.' in inputFileAssignmentName */
+  char_p = inputFileName;
+  slash_p = inputFileName;
+  while ((char_p = strchr (char_p, '/')))
+    {
+      char_p++;
+      slash_p = char_p;
+    }
+
+  char_p = slash_p;
+  dot_p = inputFileName + strlen (inputFileName);
+
+  while ((char_p = strchr (char_p, '.')))
+    {
+      dot_p = char_p;
+      char_p++;
+    }
+
+  /* outputFileName= inputFileName + .out */
+  *outputFileName = (char *) malloc (dot_p - inputFileName + 1 +
+				     strlen (".out"));
+  memcpy (*outputFileName, inputFileName, dot_p - inputFileName);
+  (*outputFileName)[dot_p - inputFileName] = 0;
+  strcat (*outputFileName, ".out");
+  return;
 }
 
 
@@ -110,224 +114,251 @@ createFileName(char *inputFileName, char **outputFileName)
 /* Description:                                         */
 /********************************************************/
 int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
 {
-  static struct option long_options[] =
-  {
-    {"help",    no_argument,       0, 'h'},
-    {"version", no_argument,       0, 'v'},
-    {"check",   no_argument,       0, 'c'},
-    {"output",  required_argument, 0, 'o'},
+  static struct option long_options[] = {
+    {"help", no_argument, 0, 'h'},
+    {"version", no_argument, 0, 'v'},
+    {"check", no_argument, 0, 'c'},
+    {"output", required_argument, 0, 'o'},
     {0, 0, 0, 0}
   };
-  int option_index=0;
- int option_result;
- char *outputFileName=NULL;
- char *inputFileAsnName=NULL;
- char *inputFileAssignmentName=NULL;
- int checkSyntaxOnly=0;
- ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
- ASN1_TYPE structure=ASN1_TYPE_EMPTY;
- char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- int asn1_result=ASN1_SUCCESS;
- FILE *outputFile;
- FILE *inputFile;
- char varName[1024];
- char value[1024];
- unsigned char *der = NULL;
- int  der_len;
- int  k;
-
- set_program_name (argv[0]);
-
- opterr=0; /* disable error messages from getopt */
-
- while(1){
-
-   option_result=getopt_long(argc,argv,"hvco:",long_options,&option_index);
-
-   if(option_result == -1) break;
-
-   switch(option_result){
-   case 'h':  /* HELP */
-     printf("%s\n",help_man);
-
-     if(outputFileName) free(outputFileName);
-     exit(0);
-     break;
-   case 'v':  /* VERSION */
-     version_etc (stdout, program_name, PACKAGE, VERSION,
-		  "Fabio Fiorina", NULL);
-     if(outputFileName) free(outputFileName);
-     exit(0);
-     break;
-   case 'c':  /* CHECK SYNTAX */
-     checkSyntaxOnly = 1;
-     break;
-   case 'o':  /* OUTPUT */
-     outputFileName=(char *)malloc(strlen(optarg)+1);
-     strcpy(outputFileName,optarg);
-     break;
-   case '?':  /* UNKNOW OPTION */
-     fprintf(stderr,"asn1Coding: option '%s' not recognized or without argument.\n\n",argv[optind-1]);
-     printf("%s\n",help_man);
-
-     if(outputFileName) free(outputFileName);
-     exit(1);
-     break;
-   default:
-     fprintf(stderr,"asn1Coding: ?? getopt returned character code Ox%x ??\n",option_result);
-   }
- }
-
- if(optind == argc){
-   fprintf(stderr,"asn1Coding: input file with ASN1 definitions missing.\n");
-   fprintf(stderr,"            input file with assignments missing.\n\n");
-   printf("%s\n",help_man);
-
-   if(outputFileName) free(outputFileName);
-   exit(1);
- }
-
- if(optind == argc-1){
-   fprintf(stderr,"asn1Coding: input file with assignments missing.\n\n");
-   printf("%s\n",help_man);
-
-   if(outputFileName) free(outputFileName);
-   exit(1);
- }
-
- inputFileAsnName=(char *)malloc(strlen(argv[optind])+1);
- strcpy(inputFileAsnName,argv[optind]);
-
- inputFileAssignmentName=(char *)malloc(strlen(argv[optind+1])+1);
- strcpy(inputFileAssignmentName,argv[optind+1]);
-
- asn1_result=asn1_parser2tree(inputFileAsnName,&definitions,errorDescription);
-
- switch(asn1_result){
- case ASN1_SUCCESS:
-   printf("Parse: done.\n");
-   break;
- case ASN1_FILE_NOT_FOUND:
-   printf("asn1Coding: FILE %s NOT FOUND\n",inputFileAsnName);
-   break;
- case ASN1_SYNTAX_ERROR: 
- case ASN1_IDENTIFIER_NOT_FOUND: 
- case ASN1_NAME_TOO_LONG:
-   printf("asn1Coding: %s\n",errorDescription);
-   break;
- default:
-   printf("libtasn1 ERROR: %s\n",asn1_strerror(asn1_result));
- }
-
- if(asn1_result != ASN1_SUCCESS){
-   free(inputFileAsnName);
-   free(inputFileAssignmentName);
-   exit(1);
- }
-
-
- inputFile=fopen(inputFileAssignmentName,"r");
- 
- if(inputFile==NULL){
-   printf("asn1Coding: file '%s' not found\n",inputFileAssignmentName);
-   free(inputFileAsnName);
-   free(inputFileAssignmentName);
-   exit(1);
- }
-
-
- printf("\n");
-
- while(readAssignment(inputFile,varName,value) == ASSIGNMENT_SUCCESS){
-   printf("var=%s, value=%s\n",varName,value);
-   if(structure==ASN1_TYPE_EMPTY){
-     asn1_result=asn1_create_element(definitions,value,&structure);
-   }
-   else
-     asn1_result=asn1_write_value(structure,varName,value,0); 
-
-   if(asn1_result != ASN1_SUCCESS){
-     printf("libtasn1 ERROR: %s\n",asn1_strerror(asn1_result));
-     
-     asn1_delete_structure(&definitions);
-     asn1_delete_structure(&structure);
-     
-     free(inputFileAsnName);
-     free(inputFileAssignmentName);
-     
-     fclose(inputFile);
-     exit(1);
-   }
- }
- fclose(inputFile);
-
- printf("\n");
- asn1_print_structure(stdout,structure,"",ASN1_PRINT_NAME_TYPE_VALUE);
-
- der_len=0;
- asn1_result=asn1_der_coding(structure,"",der,&der_len,
-                             errorDescription);
- if (asn1_result==ASN1_MEM_ERROR)
-   {
-     der = malloc (der_len);
-     asn1_result=asn1_der_coding(structure,"",der,&der_len,
+  int option_index = 0;
+  int option_result;
+  char *outputFileName = NULL;
+  char *inputFileAsnName = NULL;
+  char *inputFileAssignmentName = NULL;
+  int checkSyntaxOnly = 0;
+  ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+  ASN1_TYPE structure = ASN1_TYPE_EMPTY;
+  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+  int asn1_result = ASN1_SUCCESS;
+  FILE *outputFile;
+  FILE *inputFile;
+  char varName[1024];
+  char value[1024];
+  unsigned char *der = NULL;
+  int der_len;
+  int k;
+
+  set_program_name (argv[0]);
+
+  opterr = 0;			/* disable error messages from getopt */
+
+  while (1)
+    {
+
+      option_result =
+	getopt_long (argc, argv, "hvco:", long_options, &option_index);
+
+      if (option_result == -1)
+	break;
+
+      switch (option_result)
+	{
+	case 'h':		/* HELP */
+	  printf ("%s\n", help_man);
+
+	  if (outputFileName)
+	    free (outputFileName);
+	  exit (0);
+	  break;
+	case 'v':		/* VERSION */
+	  version_etc (stdout, program_name, PACKAGE, VERSION,
+		       "Fabio Fiorina", NULL);
+	  if (outputFileName)
+	    free (outputFileName);
+	  exit (0);
+	  break;
+	case 'c':		/* CHECK SYNTAX */
+	  checkSyntaxOnly = 1;
+	  break;
+	case 'o':		/* OUTPUT */
+	  outputFileName = (char *) malloc (strlen (optarg) + 1);
+	  strcpy (outputFileName, optarg);
+	  break;
+	case '?':		/* UNKNOW OPTION */
+	  fprintf (stderr,
+		   "asn1Coding: option '%s' not recognized or without argument.\n\n",
+		   argv[optind - 1]);
+	  printf ("%s\n", help_man);
+
+	  if (outputFileName)
+	    free (outputFileName);
+	  exit (1);
+	  break;
+	default:
+	  fprintf (stderr,
+		   "asn1Coding: ?? getopt returned character code Ox%x ??\n",
+		   option_result);
+	}
+    }
+
+  if (optind == argc)
+    {
+      fprintf (stderr,
+	       "asn1Coding: input file with ASN1 definitions missing.\n");
+      fprintf (stderr,
+	       "            input file with assignments missing.\n\n");
+      printf ("%s\n", help_man);
+
+      if (outputFileName)
+	free (outputFileName);
+      exit (1);
+    }
+
+  if (optind == argc - 1)
+    {
+      fprintf (stderr,
+	       "asn1Coding: input file with assignments missing.\n\n");
+      printf ("%s\n", help_man);
+
+      if (outputFileName)
+	free (outputFileName);
+      exit (1);
+    }
+
+  inputFileAsnName = (char *) malloc (strlen (argv[optind]) + 1);
+  strcpy (inputFileAsnName, argv[optind]);
+
+  inputFileAssignmentName = (char *) malloc (strlen (argv[optind + 1]) + 1);
+  strcpy (inputFileAssignmentName, argv[optind + 1]);
+
+  asn1_result =
+    asn1_parser2tree (inputFileAsnName, &definitions, errorDescription);
+
+  switch (asn1_result)
+    {
+    case ASN1_SUCCESS:
+      printf ("Parse: done.\n");
+      break;
+    case ASN1_FILE_NOT_FOUND:
+      printf ("asn1Coding: FILE %s NOT FOUND\n", inputFileAsnName);
+      break;
+    case ASN1_SYNTAX_ERROR:
+    case ASN1_IDENTIFIER_NOT_FOUND:
+    case ASN1_NAME_TOO_LONG:
+      printf ("asn1Coding: %s\n", errorDescription);
+      break;
+    default:
+      printf ("libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
+    }
+
+  if (asn1_result != ASN1_SUCCESS)
+    {
+      free (inputFileAsnName);
+      free (inputFileAssignmentName);
+      exit (1);
+    }
+
+
+  inputFile = fopen (inputFileAssignmentName, "r");
+
+  if (inputFile == NULL)
+    {
+      printf ("asn1Coding: file '%s' not found\n", inputFileAssignmentName);
+      free (inputFileAsnName);
+      free (inputFileAssignmentName);
+      exit (1);
+    }
+
+
+  printf ("\n");
+
+  while (readAssignment (inputFile, varName, value) == ASSIGNMENT_SUCCESS)
+    {
+      printf ("var=%s, value=%s\n", varName, value);
+      if (structure == ASN1_TYPE_EMPTY)
+	{
+	  asn1_result = asn1_create_element (definitions, value, &structure);
+	}
+      else
+	asn1_result = asn1_write_value (structure, varName, value, 0);
+
+      if (asn1_result != ASN1_SUCCESS)
+	{
+	  printf ("libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
+
+	  asn1_delete_structure (&definitions);
+	  asn1_delete_structure (&structure);
+
+	  free (inputFileAsnName);
+	  free (inputFileAssignmentName);
+
+	  fclose (inputFile);
+	  exit (1);
+	}
+    }
+  fclose (inputFile);
+
+  printf ("\n");
+  asn1_print_structure (stdout, structure, "", ASN1_PRINT_NAME_TYPE_VALUE);
+
+  der_len = 0;
+  asn1_result = asn1_der_coding (structure, "", der, &der_len,
 				 errorDescription);
-   }
- printf("\nCoding: %s\n\n",asn1_strerror(asn1_result));
- if(asn1_result!=ASN1_SUCCESS){
-   printf("asn1Coding: %s\n",errorDescription);
-
-   if (der)
-     free (der);
-
-   asn1_delete_structure(&definitions);
-   asn1_delete_structure(&structure);
-
-   free(inputFileAsnName);
-   free(inputFileAssignmentName);
-
-   exit(1);
- }
-
- /* Print the 'Certificate1' DER encoding */ 
- printf("-----------------\nNumber of bytes=%i\n",der_len);
- for(k=0;k<der_len;k++) printf("%02x ",der[k]);  
- printf("\n-----------------\n");
-
- asn1_delete_structure(&definitions);
- asn1_delete_structure(&structure);
- 
-
- if(outputFileName==NULL)
-   createFileName(inputFileAssignmentName,&outputFileName);
-
- printf("\nOutputFile=%s\n",outputFileName);
-
- outputFile=fopen(outputFileName,"w");
- 
- if(outputFile==NULL){
-   printf("asn1Coding: output file '%s' not available\n",outputFileName);
-   if (der)
-     free (der);
-   free(inputFileAsnName);
-   free(inputFileAssignmentName);
-   free(outputFileName);
-   exit(1);
- }
-
- for(k=0;k<der_len;k++) 
-   fprintf(outputFile,"%c",der[k]);  
- fclose(outputFile);
- printf("\nWriting: done.\n");
-
- if (der)
-   free (der);
-
- free(inputFileAsnName);
- free(inputFileAssignmentName);
- free(outputFileName);
-
- exit(0);
+  if (asn1_result == ASN1_MEM_ERROR)
+    {
+      der = malloc (der_len);
+      asn1_result = asn1_der_coding (structure, "", der, &der_len,
+				     errorDescription);
+    }
+  printf ("\nCoding: %s\n\n", asn1_strerror (asn1_result));
+  if (asn1_result != ASN1_SUCCESS)
+    {
+      printf ("asn1Coding: %s\n", errorDescription);
+
+      if (der)
+	free (der);
+
+      asn1_delete_structure (&definitions);
+      asn1_delete_structure (&structure);
+
+      free (inputFileAsnName);
+      free (inputFileAssignmentName);
+
+      exit (1);
+    }
+
+  /* Print the 'Certificate1' DER encoding */
+  printf ("-----------------\nNumber of bytes=%i\n", der_len);
+  for (k = 0; k < der_len; k++)
+    printf ("%02x ", der[k]);
+  printf ("\n-----------------\n");
+
+  asn1_delete_structure (&definitions);
+  asn1_delete_structure (&structure);
+
+
+  if (outputFileName == NULL)
+    createFileName (inputFileAssignmentName, &outputFileName);
+
+  printf ("\nOutputFile=%s\n", outputFileName);
+
+  outputFile = fopen (outputFileName, "w");
+
+  if (outputFile == NULL)
+    {
+      printf ("asn1Coding: output file '%s' not available\n", outputFileName);
+      if (der)
+	free (der);
+      free (inputFileAsnName);
+      free (inputFileAssignmentName);
+      free (outputFileName);
+      exit (1);
+    }
+
+  for (k = 0; k < der_len; k++)
+    fprintf (outputFile, "%c", der[k]);
+  fclose (outputFile);
+  printf ("\nWriting: done.\n");
+
+  if (der)
+    free (der);
+
+  free (inputFileAsnName);
+  free (inputFileAssignmentName);
+  free (outputFileName);
+
+  exit (0);
 }
diff --git a/src/asn1Decoding.c b/src/asn1Decoding.c
index e38b78f..8aebfc1 100644
--- a/src/asn1Decoding.c
+++ b/src/asn1Decoding.c
@@ -48,213 +48,230 @@ static const char help_man[] =
   "  -c, --check           checks the syntax only\n"
   "  -h, --help            display this help and exit\n"
   "  -v, --version         output version information and exit.\n"
-  "\n"
-  "Report bugs to <" PACKAGE_BUGREPORT ">.";
+  "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.";
 
 /********************************************************/
 /* Function : main                                      */
 /* Description:                                         */
 /********************************************************/
 int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
 {
-  static struct option long_options[] =
-  {
-    {"help",    no_argument,       0, 'h'},
-    {"version", no_argument,       0, 'v'},
-    {"check",   no_argument,       0, 'c'},
+  static struct option long_options[] = {
+    {"help", no_argument, 0, 'h'},
+    {"version", no_argument, 0, 'v'},
+    {"check", no_argument, 0, 'c'},
     {0, 0, 0, 0}
   };
- int option_index = 0;
- int option_result;
- char *inputFileAsnName=NULL;
- char *inputFileDerName=NULL; 
- char *typeName=NULL;
- int checkSyntaxOnly=0;
- ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
- ASN1_TYPE structure=ASN1_TYPE_EMPTY;
- char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- int asn1_result=ASN1_SUCCESS;
- unsigned char *der;
- int  der_len=0;
- /* FILE *outputFile; */ 
-
- set_program_name (argv[0]);
-
- opterr=0; /* disable error messages from getopt */
-
- while(1){
-
-   option_result=getopt_long(argc,argv,"hvc",long_options,&option_index);
-
-   if(option_result == -1) break;
-
-   switch(option_result){
-   case 'h':  /* HELP */
-     printf("%s\n",help_man);
-     exit(0);
-     break;
-   case 'v':  /* VERSION */
-     version_etc (stdout, program_name, PACKAGE, VERSION,
-		  "Fabio Fiorina", NULL);
-     exit(0);
-     break;
-   case 'c':  /* CHECK SYNTAX */
-     checkSyntaxOnly = 1;
-     break;
-   case '?':  /* UNKNOW OPTION */
-     fprintf(stderr,"asn1Decoding: option '%s' not recognized or without argument.\n\n",argv[optind-1]);
-     printf("%s\n",help_man);
-
-     exit(1);
-     break;
-   default:
-     fprintf(stderr,"asn1Decoding: ?? getopt returned character code Ox%x ??\n",option_result);
-   }
- }
-
- if(optind == argc){
-   fprintf(stderr,"asn1Decoding: input file with ASN1 definitions missing.\n");
-   fprintf(stderr,"              input file with DER coding missing.\n");
-   fprintf(stderr,"              ASN1 type name missing.\n\n");
-   printf("%s\n",help_man);
-
-   exit(1);
- }
-
- if(optind == argc-1){
-   fprintf(stderr,"asn1Decoding: input file with DER coding missing.\n\n");
-   fprintf(stderr,"              ASN1 type name missing.\n\n");
-   printf("%s\n",help_man);
-
-   exit(1);
- }
-
- if(optind == argc-2){
-   fprintf(stderr,"asn1Decoding: ASN1 type name missing.\n\n");
-   printf("%s\n",help_man);
-
-   exit(1);
- }
-
- inputFileAsnName=(char *)malloc(strlen(argv[optind])+1);
- strcpy(inputFileAsnName,argv[optind]);
- 
- inputFileDerName=(char *)malloc(strlen(argv[optind+1])+1);
- strcpy(inputFileDerName,argv[optind+1]);
- 
- typeName=(char *)malloc(strlen(argv[optind+2])+1);
- strcpy(typeName,argv[optind+2]);
-
- asn1_result=asn1_parser2tree(inputFileAsnName,&definitions,errorDescription);
-
- switch(asn1_result){
- case ASN1_SUCCESS:
-   printf("Parse: done.\n");
-   break;
- case ASN1_FILE_NOT_FOUND:
-   printf("asn1Decoding: FILE %s NOT FOUND\n",inputFileAsnName);
-   break;
- case ASN1_SYNTAX_ERROR: 
- case ASN1_IDENTIFIER_NOT_FOUND: 
- case ASN1_NAME_TOO_LONG:
-   printf("asn1Decoding: %s\n",errorDescription);
-   break;
- default:
-   printf("libtasn1 ERROR: %s\n",asn1_strerror(asn1_result));
- }
-
- if(asn1_result != ASN1_SUCCESS){
-   free(inputFileAsnName);
-   free(inputFileDerName);
-   free(typeName);
-   exit(1);
- }
-
-
- {
-   size_t tmplen;
-   der = (unsigned char*) read_binary_file (inputFileDerName, &tmplen);
-   der_len = tmplen;
- }
-
- if(der==NULL){
-   printf("asn1Decoding: could not read '%s'\n",inputFileDerName);
-   asn1_delete_structure(&definitions);
-
-   free(inputFileAsnName);
-   free(inputFileDerName);
-   free(typeName);
-   exit(1);
- }
+  int option_index = 0;
+  int option_result;
+  char *inputFileAsnName = NULL;
+  char *inputFileDerName = NULL;
+  char *typeName = NULL;
+  int checkSyntaxOnly = 0;
+  ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+  ASN1_TYPE structure = ASN1_TYPE_EMPTY;
+  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+  int asn1_result = ASN1_SUCCESS;
+  unsigned char *der;
+  int der_len = 0;
+  /* FILE *outputFile; */
+
+  set_program_name (argv[0]);
+
+  opterr = 0;			/* disable error messages from getopt */
+
+  while (1)
+    {
+
+      option_result =
+	getopt_long (argc, argv, "hvc", long_options, &option_index);
+
+      if (option_result == -1)
+	break;
+
+      switch (option_result)
+	{
+	case 'h':		/* HELP */
+	  printf ("%s\n", help_man);
+	  exit (0);
+	  break;
+	case 'v':		/* VERSION */
+	  version_etc (stdout, program_name, PACKAGE, VERSION,
+		       "Fabio Fiorina", NULL);
+	  exit (0);
+	  break;
+	case 'c':		/* CHECK SYNTAX */
+	  checkSyntaxOnly = 1;
+	  break;
+	case '?':		/* UNKNOW OPTION */
+	  fprintf (stderr,
+		   "asn1Decoding: option '%s' not recognized or without argument.\n\n",
+		   argv[optind - 1]);
+	  printf ("%s\n", help_man);
+
+	  exit (1);
+	  break;
+	default:
+	  fprintf (stderr,
+		   "asn1Decoding: ?? getopt returned character code Ox%x ??\n",
+		   option_result);
+	}
+    }
+
+  if (optind == argc)
+    {
+      fprintf (stderr,
+	       "asn1Decoding: input file with ASN1 definitions missing.\n");
+      fprintf (stderr, "              input file with DER coding missing.\n");
+      fprintf (stderr, "              ASN1 type name missing.\n\n");
+      printf ("%s\n", help_man);
+
+      exit (1);
+    }
+
+  if (optind == argc - 1)
+    {
+      fprintf (stderr,
+	       "asn1Decoding: input file with DER coding missing.\n\n");
+      fprintf (stderr, "              ASN1 type name missing.\n\n");
+      printf ("%s\n", help_man);
+
+      exit (1);
+    }
+
+  if (optind == argc - 2)
+    {
+      fprintf (stderr, "asn1Decoding: ASN1 type name missing.\n\n");
+      printf ("%s\n", help_man);
+
+      exit (1);
+    }
+
+  inputFileAsnName = (char *) malloc (strlen (argv[optind]) + 1);
+  strcpy (inputFileAsnName, argv[optind]);
+
+  inputFileDerName = (char *) malloc (strlen (argv[optind + 1]) + 1);
+  strcpy (inputFileDerName, argv[optind + 1]);
+
+  typeName = (char *) malloc (strlen (argv[optind + 2]) + 1);
+  strcpy (typeName, argv[optind + 2]);
+
+  asn1_result =
+    asn1_parser2tree (inputFileAsnName, &definitions, errorDescription);
+
+  switch (asn1_result)
+    {
+    case ASN1_SUCCESS:
+      printf ("Parse: done.\n");
+      break;
+    case ASN1_FILE_NOT_FOUND:
+      printf ("asn1Decoding: FILE %s NOT FOUND\n", inputFileAsnName);
+      break;
+    case ASN1_SYNTAX_ERROR:
+    case ASN1_IDENTIFIER_NOT_FOUND:
+    case ASN1_NAME_TOO_LONG:
+      printf ("asn1Decoding: %s\n", errorDescription);
+      break;
+    default:
+      printf ("libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
+    }
+
+  if (asn1_result != ASN1_SUCCESS)
+    {
+      free (inputFileAsnName);
+      free (inputFileDerName);
+      free (typeName);
+      exit (1);
+    }
 
 
- /*****************************************/
- /* ONLY FOR TEST                         */
- /*****************************************/
- /*
- der_len=0;
- outputFile=fopen("data.p12","w");
- while(fscanf(inputFile,"%c",der+der_len) != EOF){
-   if((der_len>=0x11) && (der_len<=(0xe70)))
-     fprintf(outputFile,"%c",der[der_len]);
-   der_len++;
- }
- fclose(outputFile);
- fclose(inputFile);
- */
- 
- asn1_result=asn1_create_element(definitions,typeName,&structure);
+  {
+    size_t tmplen;
+    der = (unsigned char *) read_binary_file (inputFileDerName, &tmplen);
+    der_len = tmplen;
+  }
 
- /* asn1_print_structure(stdout,structure,"",ASN1_PRINT_ALL); */
+  if (der == NULL)
+    {
+      printf ("asn1Decoding: could not read '%s'\n", inputFileDerName);
+      asn1_delete_structure (&definitions);
 
+      free (inputFileAsnName);
+      free (inputFileDerName);
+      free (typeName);
+      exit (1);
+    }
 
- if(asn1_result != ASN1_SUCCESS){
-   printf("Structure creation: %s\n",asn1_strerror(asn1_result));
-   asn1_delete_structure(&definitions);
 
-   free(inputFileAsnName);
-   free(inputFileDerName);
-   free(typeName);   
-   free(der);
-   exit(1);
- }
+ /*****************************************/
+  /* ONLY FOR TEST                         */
+ /*****************************************/
+  /*
+     der_len=0;
+     outputFile=fopen("data.p12","w");
+     while(fscanf(inputFile,"%c",der+der_len) != EOF){
+     if((der_len>=0x11) && (der_len<=(0xe70)))
+     fprintf(outputFile,"%c",der[der_len]);
+     der_len++;
+     }
+     fclose(outputFile);
+     fclose(inputFile);
+   */
 
- asn1_result=asn1_der_decoding(&structure,der,der_len,errorDescription);
- printf("\nDecoding: %s\n",asn1_strerror(asn1_result));
- if(asn1_result != ASN1_SUCCESS)
-   printf("asn1Decoding: %s\n",errorDescription);
+  asn1_result = asn1_create_element (definitions, typeName, &structure);
 
- printf("\nDECODING RESULT:\n");
- asn1_print_structure(stdout,structure,"",ASN1_PRINT_NAME_TYPE_VALUE);
+  /* asn1_print_structure(stdout,structure,"",ASN1_PRINT_ALL); */
 
- /*****************************************/
- /* ONLY FOR TEST                         */
- /*****************************************/
- /*
- der_len=10000;
- option_index=0;
- asn1_result=asn1_read_value(structure,"?2.content",der,&der_len);
- outputFile=fopen("encryptedData.p12","w");
- while(der_len>0){
-   fprintf(outputFile,"%c",der[option_index]);
-   der_len--;
-   option_index++;
- }
- fclose(outputFile);
- */
 
- asn1_delete_structure(&definitions);
- asn1_delete_structure(&structure);
+  if (asn1_result != ASN1_SUCCESS)
+    {
+      printf ("Structure creation: %s\n", asn1_strerror (asn1_result));
+      asn1_delete_structure (&definitions);
 
- free(der);
+      free (inputFileAsnName);
+      free (inputFileDerName);
+      free (typeName);
+      free (der);
+      exit (1);
+    }
 
- free(inputFileAsnName);
- free(inputFileDerName);
- free(typeName);  
+  asn1_result =
+    asn1_der_decoding (&structure, der, der_len, errorDescription);
+  printf ("\nDecoding: %s\n", asn1_strerror (asn1_result));
+  if (asn1_result != ASN1_SUCCESS)
+    printf ("asn1Decoding: %s\n", errorDescription);
 
- if(asn1_result != ASN1_SUCCESS)
-   exit(1);
+  printf ("\nDECODING RESULT:\n");
+  asn1_print_structure (stdout, structure, "", ASN1_PRINT_NAME_TYPE_VALUE);
 
- exit(0);
+ /*****************************************/
+  /* ONLY FOR TEST                         */
+ /*****************************************/
+  /*
+     der_len=10000;
+     option_index=0;
+     asn1_result=asn1_read_value(structure,"?2.content",der,&der_len);
+     outputFile=fopen("encryptedData.p12","w");
+     while(der_len>0){
+     fprintf(outputFile,"%c",der[option_index]);
+     der_len--;
+     option_index++;
+     }
+     fclose(outputFile);
+   */
+
+  asn1_delete_structure (&definitions);
+  asn1_delete_structure (&structure);
+
+  free (der);
+
+  free (inputFileAsnName);
+  free (inputFileDerName);
+  free (typeName);
+
+  if (asn1_result != ASN1_SUCCESS)
+    exit (1);
+
+  exit (0);
 }
diff --git a/src/asn1Parser.c b/src/asn1Parser.c
index 61923c3..7e4d18e 100644
--- a/src/asn1Parser.c
+++ b/src/asn1Parser.c
@@ -50,132 +50,156 @@ static const char help_man[] =
   "  -n, --name NAME       array name\n"
   "  -h, --help            display this help and exit\n"
   "  -v, --version         output version information and exit.\n"
-  "\n"
-  "Report bugs to <" PACKAGE_BUGREPORT ">.";
+  "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.";
 
 /********************************************************/
 /* Function : main                                      */
 /* Description:                                         */
 /********************************************************/
 int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
 {
-  static struct option long_options[] =
-  {
-    {"help",    no_argument,       0, 'h'},
-    {"version", no_argument,       0, 'v'},
-    {"check",   no_argument,       0, 'c'},
-    {"output",  required_argument, 0, 'o'},
-    {"name",    required_argument, 0, 'n'},
+  static struct option long_options[] = {
+    {"help", no_argument, 0, 'h'},
+    {"version", no_argument, 0, 'v'},
+    {"check", no_argument, 0, 'c'},
+    {"output", required_argument, 0, 'o'},
+    {"name", required_argument, 0, 'n'},
     {0, 0, 0, 0}
   };
   int option_index = 0;
- int option_result;
- char *outputFileName=NULL;
- char *inputFileName=NULL;
- char *vectorName=NULL;
- int checkSyntaxOnly=0;
- ASN1_TYPE pointer=ASN1_TYPE_EMPTY;
- char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- int parse_result=ASN1_SUCCESS;
-
- set_program_name (argv[0]);
-
- opterr=0; /* disable error messages from getopt */
-
- while(1){
-
-   option_result=getopt_long(argc,argv,"hvco:n:",long_options,&option_index);
-
-   if(option_result == -1) break;
-
-   switch(option_result){
-   case 0:
-     printf("option %s",long_options[option_index].name);
-     if(optarg) printf(" with arg %s",optarg);
-     printf("\n");
-     break;
-   case 'h':  /* HELP */
-     printf("%s\n",help_man);
-
-     if(outputFileName) free(outputFileName);
-     if(vectorName) free(vectorName);
-     exit(0);
-     break;
-   case 'v':  /* VERSION */
-     version_etc (stdout, program_name, PACKAGE, VERSION,
-		  "Fabio Fiorina", NULL);
-     if(outputFileName) free(outputFileName);
-     if(vectorName) free(vectorName);
-     exit(0);
-     break;
-   case 'c':  /* CHECK SYNTAX */
-     checkSyntaxOnly = 1;
-     break;
-   case 'o':  /* OUTPUT */
-     outputFileName=(char *)malloc(strlen(optarg)+1);
-     strcpy(outputFileName,optarg);
-     break;
-   case 'n':  /* VECTOR NAME */
-     vectorName=(char *)malloc(strlen(optarg)+1);
-     strcpy(vectorName,optarg);
-     break;
-   case '?':  /* UNKNOW OPTION */
-     fprintf(stderr,"asn1Parser: option '%s' not recognized or without argument.\n\n",argv[optind-1]);
-     printf("%s\n",help_man);
-
-     if(outputFileName) free(outputFileName);
-     if(vectorName) free(vectorName);
-     exit(1);
-     break;
-   default:
-     fprintf(stderr,"asn1Parser: ?? getopt returned character code Ox%x ??\n",option_result);
-   }
-
- }
-
- if(optind == argc){
-   fprintf(stderr,"asn1Parser: input file name missing.\n\n");
-   printf("%s\n",help_man);
-
-   if(outputFileName) free(outputFileName);
-   if(vectorName) free(vectorName);
-   exit(1);
- }
- else{
-   inputFileName=(char *)malloc(strlen(argv[optind])+1);
-   strcpy(inputFileName,argv[optind]);
- }
-
- if(checkSyntaxOnly == 1){
-   parse_result=asn1_parser2tree(inputFileName,&pointer,errorDescription);
-   asn1_delete_structure(&pointer);
- }
- else /* C VECTOR CREATION */
-   parse_result=asn1_parser2array(inputFileName,
-                outputFileName,vectorName,errorDescription);
-
- switch(parse_result){
- case ASN1_SUCCESS:
-   printf("Done.\n");
-   break;
- case ASN1_FILE_NOT_FOUND:
-   printf("asn1Parser: FILE %s NOT FOUND\n",inputFileName);
-   break;
- case ASN1_SYNTAX_ERROR: 
- case ASN1_IDENTIFIER_NOT_FOUND: 
- case ASN1_NAME_TOO_LONG:
-   printf("asn1Parser: %s\n",errorDescription);
-   break;
- default:
-   printf("libtasn1 ERROR: %s\n",asn1_strerror(parse_result));
- }
-
-
- free(inputFileName);
- if(outputFileName) free(outputFileName);
- if(vectorName) free(vectorName);
-
- if(parse_result != ASN1_SUCCESS) exit(1);
- exit(0);
+  int option_result;
+  char *outputFileName = NULL;
+  char *inputFileName = NULL;
+  char *vectorName = NULL;
+  int checkSyntaxOnly = 0;
+  ASN1_TYPE pointer = ASN1_TYPE_EMPTY;
+  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+  int parse_result = ASN1_SUCCESS;
+
+  set_program_name (argv[0]);
+
+  opterr = 0;			/* disable error messages from getopt */
+
+  while (1)
+    {
+
+      option_result =
+	getopt_long (argc, argv, "hvco:n:", long_options, &option_index);
+
+      if (option_result == -1)
+	break;
+
+      switch (option_result)
+	{
+	case 0:
+	  printf ("option %s", long_options[option_index].name);
+	  if (optarg)
+	    printf (" with arg %s", optarg);
+	  printf ("\n");
+	  break;
+	case 'h':		/* HELP */
+	  printf ("%s\n", help_man);
+
+	  if (outputFileName)
+	    free (outputFileName);
+	  if (vectorName)
+	    free (vectorName);
+	  exit (0);
+	  break;
+	case 'v':		/* VERSION */
+	  version_etc (stdout, program_name, PACKAGE, VERSION,
+		       "Fabio Fiorina", NULL);
+	  if (outputFileName)
+	    free (outputFileName);
+	  if (vectorName)
+	    free (vectorName);
+	  exit (0);
+	  break;
+	case 'c':		/* CHECK SYNTAX */
+	  checkSyntaxOnly = 1;
+	  break;
+	case 'o':		/* OUTPUT */
+	  outputFileName = (char *) malloc (strlen (optarg) + 1);
+	  strcpy (outputFileName, optarg);
+	  break;
+	case 'n':		/* VECTOR NAME */
+	  vectorName = (char *) malloc (strlen (optarg) + 1);
+	  strcpy (vectorName, optarg);
+	  break;
+	case '?':		/* UNKNOW OPTION */
+	  fprintf (stderr,
+		   "asn1Parser: option '%s' not recognized or without argument.\n\n",
+		   argv[optind - 1]);
+	  printf ("%s\n", help_man);
+
+	  if (outputFileName)
+	    free (outputFileName);
+	  if (vectorName)
+	    free (vectorName);
+	  exit (1);
+	  break;
+	default:
+	  fprintf (stderr,
+		   "asn1Parser: ?? getopt returned character code Ox%x ??\n",
+		   option_result);
+	}
+
+    }
+
+  if (optind == argc)
+    {
+      fprintf (stderr, "asn1Parser: input file name missing.\n\n");
+      printf ("%s\n", help_man);
+
+      if (outputFileName)
+	free (outputFileName);
+      if (vectorName)
+	free (vectorName);
+      exit (1);
+    }
+  else
+    {
+      inputFileName = (char *) malloc (strlen (argv[optind]) + 1);
+      strcpy (inputFileName, argv[optind]);
+    }
+
+  if (checkSyntaxOnly == 1)
+    {
+      parse_result =
+	asn1_parser2tree (inputFileName, &pointer, errorDescription);
+      asn1_delete_structure (&pointer);
+    }
+  else				/* C VECTOR CREATION */
+    parse_result = asn1_parser2array (inputFileName,
+				      outputFileName, vectorName,
+				      errorDescription);
+
+  switch (parse_result)
+    {
+    case ASN1_SUCCESS:
+      printf ("Done.\n");
+      break;
+    case ASN1_FILE_NOT_FOUND:
+      printf ("asn1Parser: FILE %s NOT FOUND\n", inputFileName);
+      break;
+    case ASN1_SYNTAX_ERROR:
+    case ASN1_IDENTIFIER_NOT_FOUND:
+    case ASN1_NAME_TOO_LONG:
+      printf ("asn1Parser: %s\n", errorDescription);
+      break;
+    default:
+      printf ("libtasn1 ERROR: %s\n", asn1_strerror (parse_result));
+    }
+
+
+  free (inputFileName);
+  if (outputFileName)
+    free (outputFileName);
+  if (vectorName)
+    free (vectorName);
+
+  if (parse_result != ASN1_SUCCESS)
+    exit (1);
+  exit (0);
 }
diff --git a/tests/Test_indefinite.c b/tests/Test_indefinite.c
index 24484df..c750932 100644
--- a/tests/Test_indefinite.c
+++ b/tests/Test_indefinite.c
@@ -37,13 +37,13 @@
 
 
 
-int 
-main(int argc,char *argv[])
+int
+main (int argc, char *argv[])
 {
   asn1_retCode result;
-  char buffer[10*1024];
-  ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
-  ASN1_TYPE asn1_element=ASN1_TYPE_EMPTY;
+  char buffer[10 * 1024];
+  ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+  ASN1_TYPE asn1_element = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
   FILE *out, *fd;
   ssize_t size;
@@ -52,70 +52,68 @@ main(int argc,char *argv[])
 
   if (!treefile)
     treefile = "pkix.asn";
-  
+
   if (!indeffile)
     indeffile = "TestIndef.p12";
 
-  printf("\n\n/****************************************/\n");
-  printf(    "/*     Test sequence : Test_indefinite  */\n");
-  printf(    "/****************************************/\n\n");
-  printf("ASN1TREE: %s\n", treefile);
+  printf ("\n\n/****************************************/\n");
+  printf ("/*     Test sequence : Test_indefinite  */\n");
+  printf ("/****************************************/\n\n");
+  printf ("ASN1TREE: %s\n", treefile);
 
   /* Check version */
-  if(asn1_check_version("0.2.11")==NULL)
-    printf("\nLibrary version check ERROR:\n actual version: %s\n\n",asn1_check_version(NULL));
-
-  result=asn1_parser2tree(treefile,&definitions,errorDescription);
-  if(result!=ASN1_SUCCESS){
-    asn1_perror(result);
-    printf("ErrorDescription = %s\n\n",errorDescription);
-    exit(1);
-  }
-
-  out=stdout;
-
-  fd = fopen(indeffile, "rb");
-  if (fd == NULL) {
-    printf("Cannot read file %s\n", indeffile);
-    exit(1);
-  }
-  size = fread(buffer, 1, sizeof(buffer), fd);
-  if (size <= 0) {
-    printf("Cannot read from file %s\n", indeffile);
-    exit(1);
-  }
-  
-  fclose(fd);
-
-  result=asn1_create_element(definitions,"PKIX1.pkcs-12-PFX",&asn1_element);
-  if (result != ASN1_SUCCESS) {
-    asn1_perror(result);
-    printf("Cannot create PKCS12 element\n");
-    exit(1);
-  }
-  
-  result=asn1_der_decoding(&asn1_element,buffer,size,
-			     errorDescription);
-  if (result != ASN1_SUCCESS) {
-    asn1_perror(result);
-    printf("Cannot decode BER data (size %d)\n", size);
-    exit(1);
-  }
+  if (asn1_check_version ("0.2.11") == NULL)
+    printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
+	    asn1_check_version (NULL));
+
+  result = asn1_parser2tree (treefile, &definitions, errorDescription);
+  if (result != ASN1_SUCCESS)
+    {
+      asn1_perror (result);
+      printf ("ErrorDescription = %s\n\n", errorDescription);
+      exit (1);
+    }
+
+  out = stdout;
+
+  fd = fopen (indeffile, "rb");
+  if (fd == NULL)
+    {
+      printf ("Cannot read file %s\n", indeffile);
+      exit (1);
+    }
+  size = fread (buffer, 1, sizeof (buffer), fd);
+  if (size <= 0)
+    {
+      printf ("Cannot read from file %s\n", indeffile);
+      exit (1);
+    }
+
+  fclose (fd);
+
+  result =
+    asn1_create_element (definitions, "PKIX1.pkcs-12-PFX", &asn1_element);
+  if (result != ASN1_SUCCESS)
+    {
+      asn1_perror (result);
+      printf ("Cannot create PKCS12 element\n");
+      exit (1);
+    }
+
+  result = asn1_der_decoding (&asn1_element, buffer, size, errorDescription);
+  if (result != ASN1_SUCCESS)
+    {
+      asn1_perror (result);
+      printf ("Cannot decode BER data (size %d)\n", size);
+      exit (1);
+    }
 
   /* Clear the definition structures */
-  asn1_delete_structure(&definitions);
-  asn1_delete_structure(&asn1_element);
+  asn1_delete_structure (&definitions);
+  asn1_delete_structure (&asn1_element);
 
-  if(out != stdout) fclose(out);
+  if (out != stdout)
+    fclose (out);
 
-  exit(0);
+  exit (0);
 }
-
-
-
-
-
-
-
-
-
diff --git a/tests/Test_parser.c b/tests/Test_parser.c
index 398eb31..18d3c39 100644
--- a/tests/Test_parser.c
+++ b/tests/Test_parser.c
@@ -31,70 +31,76 @@
 #include <stdlib.h>
 #include "libtasn1.h"
 
-typedef struct{
+typedef struct
+{
   int lineNumber;
   char *line;
-  int  errorNumber;
+  int errorNumber;
   char *errorDescription;
 } test_type;
 
 char *fileCorrectName;
-char fileErroredName[]="Test_parser_ERROR.asn";
+char fileErroredName[] = "Test_parser_ERROR.asn";
 
 #define _FILE_ "Test_parser_ERROR.asn"
 
-test_type test_array[]={
+test_type test_array[] = {
   /* Test DEFINITIONS syntax */
-  {5,"TEST_PARSER2 { } DEFINITIONS IMPLICIT TAGS ::= BEGIN int1 ::= INTEGER END",
-   ASN1_SYNTAX_ERROR,_FILE_":6: parse error near 'TEST_PARSER'"},
-  {6,"TEST_PARSER { }",ASN1_SUCCESS,""},
+  {5,
+   "TEST_PARSER2 { } DEFINITIONS IMPLICIT TAGS ::= BEGIN int1 ::= INTEGER END",
+   ASN1_SYNTAX_ERROR, _FILE_ ":6: parse error near 'TEST_PARSER'"},
+  {6, "TEST_PARSER { }", ASN1_SUCCESS, ""},
 
   /* Test ASN1_MAX_NAME_SIZE (128) */
-  {12,"a1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567 ::= INTEGER",
-   ASN1_SUCCESS,""},
-  {12,"a12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678 ::= INTEGER",
-   ASN1_NAME_TOO_LONG,_FILE_":12: name too long (more than 128 characters)"},
+  {12,
+   "a1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567 ::= INTEGER",
+   ASN1_SUCCESS, ""},
+  {12,
+   "a12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678 ::= INTEGER",
+   ASN1_NAME_TOO_LONG,
+   _FILE_ ":12: name too long (more than 128 characters)"},
 
   /* Test 'check identifier' function */
-  {12,"ident1 ::= ident2   ident2 ::= INTEGER",
-   ASN1_SUCCESS,""},
-  {12,"ident1 ::= ident2",
-   ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'ident2' not found"},
-  {12,"obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4}    "
-      "pkix OBJECT IDENTIFIER ::= {1 2}",
-   ASN1_SUCCESS,""},
-  {12,"obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4}",
-   ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'pkix' not found"},
+  {12, "ident1 ::= ident2   ident2 ::= INTEGER",
+   ASN1_SUCCESS, ""},
+  {12, "ident1 ::= ident2",
+   ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier 'ident2' not found"},
+  {12, "obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4}    "
+   "pkix OBJECT IDENTIFIER ::= {1 2}",
+   ASN1_SUCCESS, ""},
+  {12, "obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4}",
+   ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier 'pkix' not found"},
 
   /* Test INTEGER */
-  {14,"int1 INTEGER OPTIONAL,",ASN1_SUCCESS,""},
-  {14,"int1 INTEGER DEFAULT 1,",ASN1_SUCCESS,""},
-  {14,"int1 INTEGER DEFAULT -1,",ASN1_SUCCESS,""},
-  {14,"int1 INTEGER DEFAULT v1,",ASN1_SUCCESS,""},
-  {14,"int1 [1] INTEGER,",ASN1_SUCCESS,""},
-  {14,"int1 [1] EXPLICIT INTEGER,",ASN1_SUCCESS,""},
-  {14,"int1 [1] IMPLICIT INTEGER,",ASN1_SUCCESS,""},
-  {12,"Integer ::= [1] EXPLICIT INTEGER {v1(-1), v2(1)}",ASN1_SUCCESS,""},
-  {12,"Integer ::= INTEGER {v1(0), v2}",
-   ASN1_SYNTAX_ERROR,_FILE_":12: parse error near '}'"},
-  {12,"Integer ::= INTEGER {v1(0), 1}",
-   ASN1_SYNTAX_ERROR,_FILE_":12: parse error near '1'"},
-  {12,"const1 INTEGER ::= -1",ASN1_SUCCESS,""},
-  {12,"const1 INTEGER ::= 1",ASN1_SUCCESS,""},
-  {12,"const1 INTEGER ::= v1",
-   ASN1_SYNTAX_ERROR,_FILE_":12: parse error near 'v1'"},
-  {16," generic generalstring",
-   ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'generalstring' not found"},  
+  {14, "int1 INTEGER OPTIONAL,", ASN1_SUCCESS, ""},
+  {14, "int1 INTEGER DEFAULT 1,", ASN1_SUCCESS, ""},
+  {14, "int1 INTEGER DEFAULT -1,", ASN1_SUCCESS, ""},
+  {14, "int1 INTEGER DEFAULT v1,", ASN1_SUCCESS, ""},
+  {14, "int1 [1] INTEGER,", ASN1_SUCCESS, ""},
+  {14, "int1 [1] EXPLICIT INTEGER,", ASN1_SUCCESS, ""},
+  {14, "int1 [1] IMPLICIT INTEGER,", ASN1_SUCCESS, ""},
+  {12, "Integer ::= [1] EXPLICIT INTEGER {v1(-1), v2(1)}", ASN1_SUCCESS, ""},
+  {12, "Integer ::= INTEGER {v1(0), v2}",
+   ASN1_SYNTAX_ERROR, _FILE_ ":12: parse error near '}'"},
+  {12, "Integer ::= INTEGER {v1(0), 1}",
+   ASN1_SYNTAX_ERROR, _FILE_ ":12: parse error near '1'"},
+  {12, "const1 INTEGER ::= -1", ASN1_SUCCESS, ""},
+  {12, "const1 INTEGER ::= 1", ASN1_SUCCESS, ""},
+  {12, "const1 INTEGER ::= v1",
+   ASN1_SYNTAX_ERROR, _FILE_ ":12: parse error near 'v1'"},
+  {16, " generic generalstring",
+   ASN1_IDENTIFIER_NOT_FOUND,
+   _FILE_ ":: identifier 'generalstring' not found"},
 
   /* Test: OID */
-  {20,"   oid1    OBJECT IDENTIFIER DEFAULT Oid-type",
-   ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'Oid-type' not found"},  
-  {20,"   oid1    OBJECT IDENTIFIER DEFAULT 1",
-   ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier '1' not found"},  
-  {20,"   oid1    OBJECT IDENTIFIER DEFAULT",
-   ASN1_SYNTAX_ERROR,_FILE_":21: parse error near '}'"},  
-  {20,"   oid1    OBJECT IDENTIFIER DEFAULT Oid-type1",
-   ASN1_SUCCESS,""},  
+  {20, "   oid1    OBJECT IDENTIFIER DEFAULT Oid-type",
+   ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier 'Oid-type' not found"},
+  {20, "   oid1    OBJECT IDENTIFIER DEFAULT 1",
+   ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier '1' not found"},
+  {20, "   oid1    OBJECT IDENTIFIER DEFAULT",
+   ASN1_SYNTAX_ERROR, _FILE_ ":21: parse error near '}'"},
+  {20, "   oid1    OBJECT IDENTIFIER DEFAULT Oid-type1",
+   ASN1_SUCCESS, ""},
 
 
   /* end */
@@ -102,115 +108,114 @@ test_type test_array[]={
 };
 
 int
-readLine(FILE *file,char *line)
+readLine (FILE * file, char *line)
 {
   int c;
 
-  while(((c=fgetc(file))!=EOF) && (c!='\n')){
-    *line=c;
-    line++;
-  }
+  while (((c = fgetc (file)) != EOF) && (c != '\n'))
+    {
+      *line = c;
+      line++;
+    }
 
-  *line=0;
+  *line = 0;
 
   return c;
 }
 
 
 void
-createFile(int lineNumber,char *line)
+createFile (int lineNumber, char *line)
 {
-  FILE *fileIn,*fileOut;
+  FILE *fileIn, *fileOut;
   char lineRead[1024];
-  int fileInLineNumber=0;
-
-  fileIn=fopen(fileCorrectName,"r");
-  fileOut=fopen(fileErroredName,"w");
-
-  while(readLine(fileIn,lineRead) != EOF){
-    fileInLineNumber++;
-    if(fileInLineNumber==lineNumber)
-      fprintf(fileOut,"%s\n",line);
-    else
-      fprintf(fileOut,"%s\n",lineRead);
-  }
+  int fileInLineNumber = 0;
+
+  fileIn = fopen (fileCorrectName, "r");
+  fileOut = fopen (fileErroredName, "w");
+
+  while (readLine (fileIn, lineRead) != EOF)
+    {
+      fileInLineNumber++;
+      if (fileInLineNumber == lineNumber)
+	fprintf (fileOut, "%s\n", line);
+      else
+	fprintf (fileOut, "%s\n", lineRead);
+    }
 
-  fclose(fileOut);
-  fclose(fileIn);
+  fclose (fileOut);
+  fclose (fileIn);
 }
 
 
-int 
-main(int argc,char *argv[])
+int
+main (int argc, char *argv[])
 {
   asn1_retCode result;
-  ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
+  ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
   test_type *test;
-  int errorCounter=0,testCounter=0;
+  int errorCounter = 0, testCounter = 0;
 
   fileCorrectName = getenv ("ASN1PARSER");
   if (!fileCorrectName)
-    fileCorrectName="Test_parser.asn";
+    fileCorrectName = "Test_parser.asn";
 
-  printf("\n\n/****************************************/\n");
-  printf(    "/*     Test sequence : Test_parser      */\n");
-  printf(    "/****************************************/\n\n");
-  printf("ASN1PARSER: %s\n", fileCorrectName);
+  printf ("\n\n/****************************************/\n");
+  printf ("/*     Test sequence : Test_parser      */\n");
+  printf ("/****************************************/\n\n");
+  printf ("ASN1PARSER: %s\n", fileCorrectName);
 
-  result=asn1_parser2tree(fileCorrectName,&definitions,errorDescription);
+  result = asn1_parser2tree (fileCorrectName, &definitions, errorDescription);
 
-  if(result!=ASN1_SUCCESS){
-    printf("File '%s' not correct\n",fileCorrectName);
-    asn1_perror(result);
-    printf("ErrorDescription = %s\n\n",errorDescription);
-    exit(1);
-  }
+  if (result != ASN1_SUCCESS)
+    {
+      printf ("File '%s' not correct\n", fileCorrectName);
+      asn1_perror (result);
+      printf ("ErrorDescription = %s\n\n", errorDescription);
+      exit (1);
+    }
 
   /* Only for Test */
   /* asn1_visit_tree(stdout,definitions,"TEST_PARSER",ASN1_PRINT_ALL); */
 
   /* Clear the definitions structures */
-  asn1_delete_structure(&definitions);
+  asn1_delete_structure (&definitions);
+
 
+  test = test_array;
 
-  test=test_array;
+  while (test->lineNumber != 0)
+    {
+      testCounter++;
 
-  while(test->lineNumber != 0){
-    testCounter++;
+      createFile (test->lineNumber, test->line);
 
-    createFile(test->lineNumber,test->line);
+      result =
+	asn1_parser2tree (fileErroredName, &definitions, errorDescription);
+      asn1_delete_structure (&definitions);
 
-    result=asn1_parser2tree(fileErroredName,&definitions,errorDescription);
-    asn1_delete_structure(&definitions);
+      if ((result != test->errorNumber) ||
+	  (strcmp (errorDescription, test->errorDescription)))
+	{
+	  errorCounter++;
+	  printf ("ERROR N. %d:\n", errorCounter);
+	  printf ("  Line %d - %s\n", test->lineNumber, test->line);
+	  printf ("  Error expected: %s - %s\n",
+		  asn1_strerror (test->errorNumber), test->errorDescription);
+	  printf ("  Error detected: %s - %s\n\n", asn1_strerror (result),
+		  errorDescription);
+	}
 
-    if((result != test->errorNumber) || 
-       (strcmp(errorDescription,test->errorDescription))){
-      errorCounter++;
-      printf("ERROR N. %d:\n",errorCounter);
-      printf("  Line %d - %s\n",test->lineNumber,test->line);
-      printf("  Error expected: %s - %s\n",asn1_strerror(test->errorNumber),
-             test->errorDescription);
-      printf("  Error detected: %s - %s\n\n",asn1_strerror(result),
-             errorDescription);
+      test++;
     }
- 
-    test++;
-  }
 
 
-  printf("Total tests : %d\n",testCounter);
-  printf("Total errors: %d\n",errorCounter);
+  printf ("Total tests : %d\n", testCounter);
+  printf ("Total errors: %d\n", errorCounter);
 
-  if(errorCounter > 0)
+  if (errorCounter > 0)
     return 1;
 
-  exit(0);
+  exit (0);
 }
-
-
-
-
-
-
-
diff --git a/tests/Test_tree.c b/tests/Test_tree.c
index 47b6294..f4ce056 100644
--- a/tests/Test_tree.c
+++ b/tests/Test_tree.c
@@ -61,353 +61,368 @@
 #define ACT_DELETE_ELEMENT     21
 
 
-typedef struct{
+typedef struct
+{
   int action;
   char *par1;
   unsigned char *par2;
   int par3;
-  int  errorNumber;
+  int errorNumber;
 } test_type;
 
 
-test_type test_array[]={
+test_type test_array[] = {
 
-  {ACT_DELETE,"","",0,ASN1_ELEMENT_NOT_FOUND},
+  {ACT_DELETE, "", "", 0, ASN1_ELEMENT_NOT_FOUND},
 
   /* Test: APPLICATION 30 */
-  {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"pvno","5",0,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,5,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,4,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,5,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_SUCCESS},
-  {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_ELEMENT_NOT_FOUND},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.KrbError", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "pvno", "5", 0, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 5, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 4, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 5, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.KrbError", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE_ELEMENT, "pvno", "", 0, ASN1_SUCCESS},
+  {ACT_DELETE_ELEMENT, "pvno", "", 0, ASN1_ELEMENT_NOT_FOUND},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: CHOICE */
-  {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"version",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"validity",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer","rdnSequence",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.3",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x18\x71\x75\x61\x73\x61\x72\x2e\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",26,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.7",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x08\x43\x61\x6d\x70\x69\x6e\x61\x73",10,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.6",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x13\x06\x42\x72\x61\x73\x69\x6c",8,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.10",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x02\x49\x43",4,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.11",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x03\x4c\x41\x53",5,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.8",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x09\x53\x61\x6f\x20\x50\x61\x75\x6c\x6f",11,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.type","1.2.840.113549.1.9.1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x16\x19\x65\x64\x75\x61\x72\x64\x6f\x40\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",27,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,152,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,151,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,152,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_SUCCESS},
-  {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_ELEMENT_NOT_FOUND},
-  {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?3","",0,ASN1_SUCCESS},
-  {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?5","",0,ASN1_SUCCESS},
-  {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?7","",0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.CertTemplate", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "version", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "validity", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer", "rdnSequence", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.3", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+   "\x0c\x18\x71\x75\x61\x73\x61\x72\x2e\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",
+   26, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.7", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+   "\x0c\x08\x43\x61\x6d\x70\x69\x6e\x61\x73", 10, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.6", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+   "\x13\x06\x42\x72\x61\x73\x69\x6c", 8, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.10", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value", "\x0c\x02\x49\x43", 4,
+   ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.11", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value", "\x0c\x03\x4c\x41\x53", 5,
+   ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.8", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+   "\x0c\x09\x53\x61\x6f\x20\x50\x61\x75\x6c\x6f", 11, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "1.2.840.113549.1.9.1", 0,
+   ASN1_SUCCESS},
+  {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+   "\x16\x19\x65\x64\x75\x61\x72\x64\x6f\x40\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",
+   27, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 152, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 151, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 152, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.CertTemplate", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?1", "", 0, ASN1_SUCCESS},
+  {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?1", "", 0,
+   ASN1_ELEMENT_NOT_FOUND},
+  {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?3", "", 0, ASN1_SUCCESS},
+  {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?5", "", 0, ASN1_SUCCESS},
+  {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?7", "", 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: Empty sequnces */
-  {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"seq1.int",NULL,0,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,11,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,10,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,11,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"seq1","START",5,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"seq1","END",6,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"set1","START",7,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"set1","END",10,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.sequenceEmpty", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "int1", "1", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "seq1.int", NULL, 0, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 11, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 10, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 11, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.sequenceEmpty", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "seq1", "START", 5, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "seq1", "END", 6, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "set1", "START", 7, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "set1", "END", 10, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: Indefinite Length */
-  {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"seq1.int","2",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set1.?LAST","1.2.3.4",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set1.?LAST","1.2.5.6",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,255,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_SET_DER,"\x30\x18\xa1\x80\x02\x01\x02\x00\x00\x31\x80\x06\x03\x2a\x03\x04\x06\x03\x2a\x05\x06\x00\x00\x02\x01\x01",
-   0,26,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"seq1","START",2,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"seq1","END",8,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"set1","START",9,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"set1","END",22,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.IndefiniteLengthTest", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "int1", "1", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "seq1.int", "2", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set1", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set1.?LAST", "1.2.3.4", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set1", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set1.?LAST", "1.2.5.6", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 255, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_SET_DER,
+   "\x30\x18\xa1\x80\x02\x01\x02\x00\x00\x31\x80\x06\x03\x2a\x03\x04\x06\x03\x2a\x05\x06\x00\x00\x02\x01\x01",
+   0, 26, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.IndefiniteLengthTest", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "seq1", "START", 2, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "seq1", "END", 8, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "set1", "START", 9, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "set1", "END", 22, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: OID */
-  {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
-  {ACT_READ_LENGTH,"oid",NULL,9,ASN1_MEM_ERROR},
-  {ACT_READ,"oid","2.5.29.2",9,ASN1_SUCCESS},
-  {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
-  {ACT_WRITE,"oid2","2.5.29.1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"oid3","1.2.29.2",0,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"oid","START",2,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"oid","END",6,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"","START",0,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"","END",6,ASN1_SUCCESS},
-  {ACT_READ,"oid2","2.5.29.1",9,ASN1_SUCCESS},
-  {ACT_READ,"oid3","1.2.29.2",9,ASN1_SUCCESS},
-  {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.OidTest", 0, 0, ASN1_SUCCESS},
+  {ACT_READ_LENGTH, "oid", NULL, 9, ASN1_MEM_ERROR},
+  {ACT_READ, "oid", "2.5.29.2", 9, ASN1_SUCCESS},
+  {ACT_WRITE, "oid", "1.2.3.4", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "oid2", "2.5.29.1", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "oid3", "1.2.29.2", 0, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 7, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 6, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 7, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.OidTest", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "oid", "START", 2, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "oid", "END", 6, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "", "START", 0, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "", "END", 6, ASN1_SUCCESS},
+  {ACT_READ, "oid2", "2.5.29.1", 9, ASN1_SUCCESS},
+  {ACT_READ, "oid3", "1.2.29.2", 9, ASN1_SUCCESS},
+  {ACT_WRITE, "oid", "1.2.3.4", 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: ENCODING_LENGTH and READ_LEN */
-  {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
-  {ACT_WRITE,"time1","9801011200Z",1,ASN1_SUCCESS},
-  {ACT_WRITE,"time2","2001010112001.12-0700",1,ASN1_SUCCESS},
-  {ACT_WRITE,"oct","ABCD",4,ASN1_SUCCESS},
-  {ACT_WRITE,"bol","TRUE",1,ASN1_SUCCESS},
-  {ACT_WRITE,"enum","2",0,ASN1_SUCCESS},
-  {ACT_WRITE,"bit","1\xC0",10,ASN1_SUCCESS},
-  {ACT_WRITE,"any","\x30\x01\x01",3,ASN1_SUCCESS},
-  {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set.?LAST","10",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
-  {ACT_WRITE,"set.?LAST","1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"gen","Prova",5,ASN1_SUCCESS},
-  {ACT_READ_LENGTH,"oid",NULL,8,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"time1",NULL,12,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"time2",NULL,22,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"oct",NULL,4,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"bol",NULL,5,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"enum",NULL,1,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"any",NULL,3,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"gen",NULL,5,ASN1_MEM_ERROR},
-  {ACT_READ_LENGTH,"bit",NULL,10,ASN1_MEM_ERROR},
-  {ACT_READ_BIT,"bit","1\xC0",10,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,79,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,78,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,79,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.OidAndTimeTest", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "oid", "1.2.3.4", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "time1", "9801011200Z", 1, ASN1_SUCCESS},
+  {ACT_WRITE, "time2", "2001010112001.12-0700", 1, ASN1_SUCCESS},
+  {ACT_WRITE, "oct", "ABCD", 4, ASN1_SUCCESS},
+  {ACT_WRITE, "bol", "TRUE", 1, ASN1_SUCCESS},
+  {ACT_WRITE, "enum", "2", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "bit", "1\xC0", 10, ASN1_SUCCESS},
+  {ACT_WRITE, "any", "\x30\x01\x01", 3, ASN1_SUCCESS},
+  {ACT_WRITE, "set", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set.?LAST", "10", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set", "NEW", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "set.?LAST", "1", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "gen", "Prova", 5, ASN1_SUCCESS},
+  {ACT_READ_LENGTH, "oid", NULL, 8, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "time1", NULL, 12, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "time2", NULL, 22, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "oct", NULL, 4, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "bol", NULL, 5, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "enum", NULL, 1, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "any", NULL, 3, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "gen", NULL, 5, ASN1_MEM_ERROR},
+  {ACT_READ_LENGTH, "bit", NULL, 10, ASN1_MEM_ERROR},
+  {ACT_READ_BIT, "bit", "1\xC0", 10, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 79, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 78, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 79, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.OidAndTimeTest", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: OID to STRUCTURE */
-  {ACT_OID_2_STRUCTURE,"2.5.29.3","",0,ASN1_ELEMENT_NOT_FOUND},
-  {ACT_OID_2_STRUCTURE,"1.2.29.2","",0,ASN1_ELEMENT_NOT_FOUND},
-  {ACT_OID_2_STRUCTURE,"2.5.29.2","anyTest2",0,ASN1_SUCCESS},
+  {ACT_OID_2_STRUCTURE, "2.5.29.3", "", 0, ASN1_ELEMENT_NOT_FOUND},
+  {ACT_OID_2_STRUCTURE, "1.2.29.2", "", 0, ASN1_ELEMENT_NOT_FOUND},
+  {ACT_OID_2_STRUCTURE, "2.5.29.2", "anyTest2", 0, ASN1_SUCCESS},
 
   /* Test: READ TAG and CLASS */
-  {ACT_CREATE,"TEST_TREE.SequenceTestTag",0,0,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"int","",0,ASN1_ELEMENT_NOT_FOUND},
-  {ACT_READ_TAG_CLASS,"int1","TAG",ASN1_TAG_INTEGER,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"int1","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"int2","TAG",3,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"int2","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"str1","TAG",1,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"str1","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"str2","TAG",28,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"str2","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"str3","TAG",28,ASN1_SUCCESS},
-  {ACT_READ_TAG_CLASS,"str3","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.SequenceTestTag", 0, 0, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "int", "", 0, ASN1_ELEMENT_NOT_FOUND},
+  {ACT_READ_TAG_CLASS, "int1", "TAG", ASN1_TAG_INTEGER, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "int1", "CLASS", ASN1_CLASS_UNIVERSAL, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "int2", "TAG", 3, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "int2", "CLASS", ASN1_CLASS_CONTEXT_SPECIFIC,
+   ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "str1", "TAG", 1, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "str1", "CLASS", ASN1_CLASS_CONTEXT_SPECIFIC,
+   ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "str2", "TAG", 28, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "str2", "CLASS", ASN1_CLASS_UNIVERSAL, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "str3", "TAG", 28, ASN1_SUCCESS},
+  {ACT_READ_TAG_CLASS, "str3", "CLASS", ASN1_CLASS_UNIVERSAL, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: OBJECT IDENTIFIER  elements */
-  {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"int1","v2",0,ASN1_SUCCESS},
-  {ACT_READ,"int1","\x01",1,ASN1_SUCCESS},
-  {ACT_WRITE,"int2","0",0,ASN1_SUCCESS},
-  {ACT_WRITE,"oct","\x02\x01\x0a",3,ASN1_SUCCESS},
-  {ACT_WRITE,"id","1 2 3 4 5",0,ASN1_VALUE_NOT_VALID},
-  {ACT_WRITE,"id","2.5.29.2",0,ASN1_SUCCESS},
-  {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
-  {ACT_READ_LENGTH,"id",NULL,9,ASN1_MEM_ERROR},
-  {ACT_WRITE,"any1","\x02\x01\x05",3,ASN1_SUCCESS},
-  {ACT_READ_DEFINITIONS,"TEST_TREE.id-anyTest","2.5.29.1",9,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,20,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,19,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,200,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"id","START",7,ASN1_SUCCESS},
-  {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
-  {ACT_EXPAND_ANY,"",NULL,0,ASN1_SUCCESS},
-  {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "int1", "v2", 0, ASN1_SUCCESS},
+  {ACT_READ, "int1", "\x01", 1, ASN1_SUCCESS},
+  {ACT_WRITE, "int2", "0", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "oct", "\x02\x01\x0a", 3, ASN1_SUCCESS},
+  {ACT_WRITE, "id", "1 2 3 4 5", 0, ASN1_VALUE_NOT_VALID},
+  {ACT_WRITE, "id", "2.5.29.2", 0, ASN1_SUCCESS},
+  {ACT_READ, "id", "2.5.29.2", 9, ASN1_SUCCESS},
+  {ACT_READ_LENGTH, "id", NULL, 9, ASN1_MEM_ERROR},
+  {ACT_WRITE, "any1", "\x02\x01\x05", 3, ASN1_SUCCESS},
+  {ACT_READ_DEFINITIONS, "TEST_TREE.id-anyTest", "2.5.29.1", 9, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 20, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 19, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 200, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "id", "START", 7, ASN1_SUCCESS},
+  {ACT_READ, "id", "2.5.29.2", 9, ASN1_SUCCESS},
+  {ACT_EXPAND_ANY, "", NULL, 0, ASN1_SUCCESS},
+  {ACT_EXPAND_OCTET, "oct", "id", 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Test: CHOICE elements */
-  {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"","teletexString",0,ASN1_SUCCESS},
-  {ACT_WRITE,"teletexString","PROVA",5,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  
+  {ACT_CREATE, "TEST_TREE.X520LocalityName", 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "", "teletexString", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "teletexString", "PROVA", 5, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 7, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 6, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 7, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.X520LocalityName", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
   /* Test: OPTIONAL elements */
-  {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"prime","1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"base","2",0,ASN1_SUCCESS},
-  {ACT_WRITE,"privateValueLength",NULL,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,8,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,7,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,8,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  
+  {ACT_CREATE, "TEST_TREE.DHParameter", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "prime", "1", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "base", "2", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "privateValueLength", NULL, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 8, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 7, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 8, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.DHParameter", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
   /* Test: Integer */
-  {ACT_CREATE,"TEST_TREE.AnyTest2",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"","int",0,ASN1_SUCCESS},
-  {ACT_WRITE,"int","0",0,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,3,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,2,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,3,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"int","-1",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"int","1",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"int","2000000000",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"int","-2000000000",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"int","-20000000000",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_WRITE,"int","20000000000",0,ASN1_SUCCESS},
-  {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  
+  {ACT_CREATE, "TEST_TREE.AnyTest2", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "", "int", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "0", 0, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 3, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 2, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 3, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "-1", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "1", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "2000000000", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "-2000000000", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "-20000000000", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_WRITE, "int", "20000000000", 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
   /* Test: elements without names */
-  {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"int2","10",0,ASN1_SUCCESS},
-  {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
-  {ACT_WRITE,"seq.?LAST","1",0,ASN1_SUCCESS},
-  {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
-  {ACT_WRITE,"seq.?LAST","2",0,ASN1_SUCCESS},
-  {ACT_WRITE,"any1",NULL,0,ASN1_SUCCESS},
-  {ACT_NUMBER_OF_ELEMENTS,"seq","",2,ASN1_SUCCESS},
-  {ACT_WRITE,"id","1.2.3.4",0,ASN1_SUCCESS},
-  {ACT_WRITE,"oct","\x30\x03\x02\x01\x15",5,ASN1_SUCCESS},
-  {ACT_ENCODING,"int2",0,1024,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_ENCODING,"seq.?2",0,2,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"seq.?2",0,3,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,25,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,24,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,25,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
-  {ACT_DECODING_ELEMENT,"int2",0,0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_READ,"int2","\x0a",1,ASN1_SUCCESS},
-  {ACT_READ_LENGTH,"int2",NULL,1,ASN1_MEM_ERROR},
-  {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS},
-  {ACT_DECODING_START_END,"seq.?2","START",10,ASN1_SUCCESS},
-  {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  
+  {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "int2", "10", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "seq", "NEW", 1, ASN1_SUCCESS},
+  {ACT_WRITE, "seq.?LAST", "1", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "seq", "NEW", 1, ASN1_SUCCESS},
+  {ACT_WRITE, "seq.?LAST", "2", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "any1", NULL, 0, ASN1_SUCCESS},
+  {ACT_NUMBER_OF_ELEMENTS, "seq", "", 2, ASN1_SUCCESS},
+  {ACT_WRITE, "id", "1.2.3.4", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "oct", "\x30\x03\x02\x01\x15", 5, ASN1_SUCCESS},
+  {ACT_ENCODING, "int2", 0, 1024, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_ENCODING, "seq.?2", 0, 2, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "seq.?2", 0, 3, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 25, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 24, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 25, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_ELEMENT, "int2", 0, 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_READ, "int2", "\x0a", 1, ASN1_SUCCESS},
+  {ACT_READ_LENGTH, "int2", NULL, 1, ASN1_MEM_ERROR},
+  {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_START_END, "seq.?2", "START", 10, ASN1_SUCCESS},
+  {ACT_EXPAND_OCTET, "oct", "id", 0, ASN1_SUCCESS},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
   /* Test GeneralString */
-  {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"a","1234",0,ASN1_SUCCESS},
-  {ACT_WRITE,"b","prova",5,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,17,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,16,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,17,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS}, 
-  {ACT_DECODING_ELEMENT,"b",0,0,ASN1_SUCCESS},
-  {ACT_READ,"b","prova",5,ASN1_SUCCESS},
-  {ACT_READ_LENGTH,"b",NULL,5,ASN1_MEM_ERROR},
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Test3", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "a", "1234", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "b", "prova", 5, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 17, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 16, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 17, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Test3", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_ELEMENT, "b", 0, 0, ASN1_SUCCESS},
+  {ACT_READ, "b", "prova", 5, ASN1_SUCCESS},
+  {ACT_READ_LENGTH, "b", NULL, 5, ASN1_MEM_ERROR},
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* Bug regression test: Empty write on 64-bit platforms */
-  {ACT_CREATE,"TEST_TREE.Checksum",0,0,ASN1_SUCCESS},
-  {ACT_WRITE,"checksum","foo",0,ASN1_SUCCESS},
-  {ACT_WRITE,"checksum","",0,ASN1_SUCCESS},
-  {ACT_ENCODING_LENGTH,"",0,4,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,3,ASN1_MEM_ERROR},
-  {ACT_ENCODING,"",0,4,ASN1_SUCCESS},
-  {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
-  {ACT_CREATE,"TEST_TREE.Checksum",0,0,ASN1_SUCCESS},
-  {ACT_DECODING,0,0,0,ASN1_SUCCESS}, 
-  {ACT_DECODING_ELEMENT,"checksum",0,0,ASN1_SUCCESS},
-  {ACT_READ,"checksum","",0,ASN1_SUCCESS},
-  {ACT_READ_LENGTH,"checksum",NULL,0,ASN1_SUCCESS}, /* MEM_FAILURE? */
-  {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
-  {ACT_DELETE,"","",0,ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Checksum", 0, 0, ASN1_SUCCESS},
+  {ACT_WRITE, "checksum", "foo", 0, ASN1_SUCCESS},
+  {ACT_WRITE, "checksum", "", 0, ASN1_SUCCESS},
+  {ACT_ENCODING_LENGTH, "", 0, 4, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 3, ASN1_MEM_ERROR},
+  {ACT_ENCODING, "", 0, 4, ASN1_SUCCESS},
+  {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+  {ACT_CREATE, "TEST_TREE.Checksum", 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+  {ACT_DECODING_ELEMENT, "checksum", 0, 0, ASN1_SUCCESS},
+  {ACT_READ, "checksum", "", 0, ASN1_SUCCESS},
+  {ACT_READ_LENGTH, "checksum", NULL, 0, ASN1_SUCCESS},	/* MEM_FAILURE? */
+  {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+  {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
 
   /* end */
   {ACT_NULL}
@@ -415,319 +430,347 @@ test_type test_array[]={
 };
 
 
-int 
-main(int argc,char *argv[])
+int
+main (int argc, char *argv[])
 {
   asn1_retCode result;
-  ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
-  ASN1_TYPE asn1_element=ASN1_TYPE_EMPTY;
+  ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+  ASN1_TYPE asn1_element = ASN1_TYPE_EMPTY;
   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
   FILE *out;
   test_type *test;
-  int errorCounter=0,testCounter=0,der_len;
-  unsigned char value[1024],der[1024];
-  int valueLen,tag=0,class=0;
+  int errorCounter = 0, testCounter = 0, der_len;
+  unsigned char value[1024], der[1024];
+  int valueLen, tag = 0, class = 0;
   int k;
-  int start,end;
-  const char *str_p=NULL;
+  int start, end;
+  const char *str_p = NULL;
   const char *treefile = getenv ("ASN1TREE");
 
   if (!treefile)
     treefile = "Test_tree.asn";
 
-  printf("\n\n/****************************************/\n");
-  printf(    "/*     Test sequence : Test_tree        */\n");
-  printf(    "/****************************************/\n\n");
-  printf("ASN1TREE: %s\n", treefile);
+  printf ("\n\n/****************************************/\n");
+  printf ("/*     Test sequence : Test_tree        */\n");
+  printf ("/****************************************/\n\n");
+  printf ("ASN1TREE: %s\n", treefile);
 
   /* Check version */
-  if(asn1_check_version("0.2.11")==NULL)
-    printf("\nLibrary version check ERROR:\n actual version: %s\n\n",asn1_check_version(NULL));
+  if (asn1_check_version ("0.2.11") == NULL)
+    printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
+	    asn1_check_version (NULL));
 
-  if(1)
-    result=asn1_parser2tree(treefile,&definitions,errorDescription);
+  if (1)
+    result = asn1_parser2tree (treefile, &definitions, errorDescription);
   else
-    result=asn1_array2tree(Test_tree_asn1_tab,&definitions,errorDescription);
-
-  if(result!=ASN1_SUCCESS){
-    asn1_perror(result);
-    printf("ErrorDescription = %s\n\n",errorDescription);
-    exit(1);
-  }
-
-  if(1)
-    out=stdout;
-  else
-    out=fopen("Test_tree.out","w");
-
-  if(out==NULL){
-    printf("Output file ERROR\n");
-    exit(1);
-  }
-
-  if(0){
-    asn1_print_structure(out,definitions,"TEST_TREE",ASN1_PRINT_ALL);
-    fprintf(out,"\n");
-  }
-
-  test=test_array;
-
-  while(test->action != ACT_NULL){
-    testCounter++;
-
-    switch(test->action){
-    case ACT_CREATE:
-      result=asn1_create_element(definitions,test->par1,&asn1_element);
-      break;
-    case ACT_DELETE:
-      result=asn1_delete_structure(&asn1_element);
-      break;
-    case ACT_DELETE_ELEMENT:
-      result=asn1_delete_element(asn1_element,test->par1);
-      break;
-    case ACT_WRITE:
-      if((test->par2) && (!strcmp("DER",test->par2)))
-	result=asn1_write_value(asn1_element,test->par1,der,der_len);
-      else
-	result=asn1_write_value(asn1_element,test->par1,test->par2,test->par3);
-      break;
-    case ACT_READ:
-    case ACT_READ_BIT:
-      valueLen=test->par3;
-      result=asn1_read_value(asn1_element,test->par1,value,&valueLen);
-      break;
-    case ACT_READ_LENGTH:
-      valueLen=0;
-      result=asn1_read_value(asn1_element,test->par1,NULL,&valueLen);
-      break;
-    case ACT_READ_DEFINITIONS:
-      valueLen=1024;
-      result=asn1_read_value(definitions,test->par1,value,&valueLen);
-      break;
-    case ACT_READ_TAG_CLASS:
-      result=asn1_read_tag(asn1_element,test->par1,&tag,&class);
-      break;
-    case ACT_ENCODING:
-      der_len=test->par3;
-      result=asn1_der_coding(asn1_element,test->par1,der,&der_len,
-			     errorDescription);
-      break;
-    case ACT_ENCODING_LENGTH:
-      der_len=0;
-      result=asn1_der_coding(asn1_element,test->par1,NULL,&der_len,
-			     errorDescription);
-      break;
-    case ACT_DECODING:
-      result=asn1_der_decoding(&asn1_element,der,der_len,
-			     errorDescription);
-      break;
-    case ACT_DECODING_ELEMENT:
-      result=asn1_der_decoding_element(&asn1_element,test->par1,der,der_len,
-			     errorDescription);
-      break;
-    case ACT_DECODING_START_END:
-      result=asn1_der_decoding_startEnd(asn1_element,der,der_len,test->par1,
-					&start,&end);
-      break;
-    case ACT_EXPAND_ANY:
-      result=asn1_expand_any_defined_by(definitions,&asn1_element);
-      break;
-    case ACT_EXPAND_OCTET:
-      result=asn1_expand_octet_string(definitions,&asn1_element,test->par1,
-                                      test->par2);
-      break;
-    case ACT_OID_2_STRUCTURE:
-      str_p=asn1_find_structure_from_oid(definitions,test->par1);
-      break;
-    case ACT_VISIT:
-      asn1_print_structure(out,asn1_element,test->par1,test->par3);
-      fprintf(out,"\n");
-      result=ASN1_SUCCESS;
-      break;
-    case ACT_PRINT_DER:
-      printf("DER encoding len:%i\n",der_len);
-      printf("DER encoding: ");
-      for(k=0;k<der_len;k++)
-	printf("%02x ",der[k]);
-      printf("\n\n");
-      result=ASN1_SUCCESS;
-      break;
-    case ACT_SET_DER:
-      der_len=test->par3;
-      memcpy(der,test->par1,der_len);
-      result=ASN1_SUCCESS;
-      break;
-    case ACT_NUMBER_OF_ELEMENTS:
-      result=asn1_number_of_elements(asn1_element,test->par1,&valueLen);
-      break;
-    default:
-      break;
+    result =
+      asn1_array2tree (Test_tree_asn1_tab, &definitions, errorDescription);
+
+  if (result != ASN1_SUCCESS)
+    {
+      asn1_perror (result);
+      printf ("ErrorDescription = %s\n\n", errorDescription);
+      exit (1);
     }
 
+  if (1)
+    out = stdout;
+  else
+    out = fopen ("Test_tree.out", "w");
 
-    switch(test->action){
-    case ACT_CREATE:
-    case ACT_DELETE:
-    case ACT_DELETE_ELEMENT:
-    case ACT_WRITE:
-    case ACT_VISIT:
-    case ACT_ENCODING:
-    case ACT_DECODING:
-    case ACT_PRINT_DER:
-    case ACT_EXPAND_ANY:
-    case ACT_EXPAND_OCTET:
-    case ACT_SET_DER:
-      if(result != test->errorNumber){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
-	       test->par2,test->par3);
-	printf("  Error expected: %s\n",asn1_strerror(test->errorNumber));
-	printf("  Error detected: %s\n\n",asn1_strerror(result));
-      }
-      break;
-    case ACT_DECODING_ELEMENT:
-      if(result != test->errorNumber){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
-	       test->par2,test->par3);
-	printf("  Error expected: %s\n",asn1_strerror(test->errorNumber));
-	printf("  Error detected: %s\n",asn1_strerror(result));
-	printf("  Error description : %s\n\n",errorDescription);
-      }
-      break;
-    case ACT_NUMBER_OF_ELEMENTS:
-    case ACT_READ_LENGTH:
-      if((result != test->errorNumber) ||
-	 (valueLen != test->par3)){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s\n",test->action,test->par1);
-	printf("  Error expected: %s - %d\n",asn1_strerror(test->errorNumber),
-                                             test->par3);
-	printf("  Error detected: %s - %d\n\n",asn1_strerror(result),
-                                          valueLen);
-      }
-      break;
-    case ACT_ENCODING_LENGTH:
-      if((result != test->errorNumber) ||
-	 (der_len != test->par3)){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s\n",test->action,test->par1);
-	printf("  Error expected: %s - %d\n",asn1_strerror(test->errorNumber),
-                                             test->par3);
-	printf("  Error detected: %s - %d\n\n",asn1_strerror(result),
-                                          der_len);
-      }
-      break;
-    case ACT_OID_2_STRUCTURE:
-      if(((test->errorNumber!=ASN1_SUCCESS) && (str_p!=NULL)) ||
-	 ((test->errorNumber==ASN1_SUCCESS) && (str_p==NULL)) ||
-	 ((test->errorNumber==ASN1_SUCCESS) && (strcmp(str_p,test->par2)))){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s\n",test->action,test->par1);
-	printf("  Error expected: %s - %s\n",asn1_strerror(test->errorNumber),test->par2);
-	printf("  Value detected: %s\n\n",str_p);
-      }
-      break;
-    case ACT_DECODING_START_END:
-      if((result != test->errorNumber) ||
-	 ((!strcmp(test->par2,"START")) && (start != test->par3)) ||
-	 ((!strcmp(test->par2,"END")) && (end != test->par3)) ){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s - %d\n",test->action,test->par1,
-	                                 test->par3);
-	printf("  Error expected: %s - %s - %d\n",asn1_strerror(test->errorNumber),
-                                             test->par2,test->par3);
-	printf("  Error detected: %s - %d - %d\n\n",asn1_strerror(result),
-                                          start,end);
-      }
-      break;
-
-    case ACT_READ_TAG_CLASS:
-      if((result != test->errorNumber) || 
-	 ((!strcmp(test->par2,"TAG")) && (tag != test->par3)) ||      
-	 ((!strcmp(test->par2,"CLASS")) && (class != test->par3))){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s - %d\n",test->action,test->par1,
-	                                 test->par3);
-	printf("  Error expected: %s - %s - %d\n",asn1_strerror(test->errorNumber),
-                                             test->par2,test->par3);
-	printf("  Error detected: %s - %d - %d\n\n",asn1_strerror(result),
-                                          tag,class);
-      }
-
-      break;
-
-    case ACT_READ:
-    case ACT_READ_DEFINITIONS:
-    case ACT_READ_BIT:
-      if(test->action==ACT_READ_BIT){
-	if((valueLen-(valueLen/8.0))==0) tag=valueLen/8;
-	else tag=(valueLen/8)+1;
-	if((test->par3-(test->par3/8.0))==0) class=test->par3/8;
-	else class=(test->par3/8)+1;
-      }
-
-      for(k=0;k<class;k++) 
-	if(test->par2[k] != value[k]){
-	  k=-1;
-	  break;
-	}
+  if (out == NULL)
+    {
+      printf ("Output file ERROR\n");
+      exit (1);
+    }
 
-      if((result != test->errorNumber) ||
-	 (valueLen != test->par3) ||
-	 (k == -1)){
-	errorCounter++;
-	printf("ERROR N. %d:\n",errorCounter);
-	printf("  Action %d - %s\n",test->action,test->par1);
-	printf("  Error expected: %s - %d - ",asn1_strerror(test->errorNumber),
-                                             test->par3);
-	for(k=0;k<test->par3;k++)
-	  printf("%02x",test->par2[k]); 
-	printf("\n  Error detected: %s - %d - ",asn1_strerror(result),
-                                          valueLen);
-	for(k=0;k<valueLen;k++)
-	  printf("%02x",value[k]);
-	printf("\n\n");
-
-      }
-
-      break;
-    default:
-      break;
+  if (0)
+    {
+      asn1_print_structure (out, definitions, "TEST_TREE", ASN1_PRINT_ALL);
+      fprintf (out, "\n");
     }
 
-    test++;
-  }
+  test = test_array;
 
+  while (test->action != ACT_NULL)
+    {
+      testCounter++;
 
-  printf("Total tests : %d\n",testCounter);
-  printf("Total errors: %d\n",errorCounter);
+      switch (test->action)
+	{
+	case ACT_CREATE:
+	  result =
+	    asn1_create_element (definitions, test->par1, &asn1_element);
+	  break;
+	case ACT_DELETE:
+	  result = asn1_delete_structure (&asn1_element);
+	  break;
+	case ACT_DELETE_ELEMENT:
+	  result = asn1_delete_element (asn1_element, test->par1);
+	  break;
+	case ACT_WRITE:
+	  if ((test->par2) && (!strcmp ("DER", test->par2)))
+	    result =
+	      asn1_write_value (asn1_element, test->par1, der, der_len);
+	  else
+	    result =
+	      asn1_write_value (asn1_element, test->par1, test->par2,
+				test->par3);
+	  break;
+	case ACT_READ:
+	case ACT_READ_BIT:
+	  valueLen = test->par3;
+	  result =
+	    asn1_read_value (asn1_element, test->par1, value, &valueLen);
+	  break;
+	case ACT_READ_LENGTH:
+	  valueLen = 0;
+	  result =
+	    asn1_read_value (asn1_element, test->par1, NULL, &valueLen);
+	  break;
+	case ACT_READ_DEFINITIONS:
+	  valueLen = 1024;
+	  result =
+	    asn1_read_value (definitions, test->par1, value, &valueLen);
+	  break;
+	case ACT_READ_TAG_CLASS:
+	  result = asn1_read_tag (asn1_element, test->par1, &tag, &class);
+	  break;
+	case ACT_ENCODING:
+	  der_len = test->par3;
+	  result = asn1_der_coding (asn1_element, test->par1, der, &der_len,
+				    errorDescription);
+	  break;
+	case ACT_ENCODING_LENGTH:
+	  der_len = 0;
+	  result = asn1_der_coding (asn1_element, test->par1, NULL, &der_len,
+				    errorDescription);
+	  break;
+	case ACT_DECODING:
+	  result = asn1_der_decoding (&asn1_element, der, der_len,
+				      errorDescription);
+	  break;
+	case ACT_DECODING_ELEMENT:
+	  result =
+	    asn1_der_decoding_element (&asn1_element, test->par1, der,
+				       der_len, errorDescription);
+	  break;
+	case ACT_DECODING_START_END:
+	  result =
+	    asn1_der_decoding_startEnd (asn1_element, der, der_len,
+					test->par1, &start, &end);
+	  break;
+	case ACT_EXPAND_ANY:
+	  result = asn1_expand_any_defined_by (definitions, &asn1_element);
+	  break;
+	case ACT_EXPAND_OCTET:
+	  result =
+	    asn1_expand_octet_string (definitions, &asn1_element, test->par1,
+				      test->par2);
+	  break;
+	case ACT_OID_2_STRUCTURE:
+	  str_p = asn1_find_structure_from_oid (definitions, test->par1);
+	  break;
+	case ACT_VISIT:
+	  asn1_print_structure (out, asn1_element, test->par1, test->par3);
+	  fprintf (out, "\n");
+	  result = ASN1_SUCCESS;
+	  break;
+	case ACT_PRINT_DER:
+	  printf ("DER encoding len:%i\n", der_len);
+	  printf ("DER encoding: ");
+	  for (k = 0; k < der_len; k++)
+	    printf ("%02x ", der[k]);
+	  printf ("\n\n");
+	  result = ASN1_SUCCESS;
+	  break;
+	case ACT_SET_DER:
+	  der_len = test->par3;
+	  memcpy (der, test->par1, der_len);
+	  result = ASN1_SUCCESS;
+	  break;
+	case ACT_NUMBER_OF_ELEMENTS:
+	  result =
+	    asn1_number_of_elements (asn1_element, test->par1, &valueLen);
+	  break;
+	default:
+	  break;
+	}
 
 
-  /* Clear the definition structures */
-  asn1_delete_structure(&definitions);
+      switch (test->action)
+	{
+	case ACT_CREATE:
+	case ACT_DELETE:
+	case ACT_DELETE_ELEMENT:
+	case ACT_WRITE:
+	case ACT_VISIT:
+	case ACT_ENCODING:
+	case ACT_DECODING:
+	case ACT_PRINT_DER:
+	case ACT_EXPAND_ANY:
+	case ACT_EXPAND_OCTET:
+	case ACT_SET_DER:
+	  if (result != test->errorNumber)
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s - %s - %d\n", test->action,
+		      test->par1, test->par2, test->par3);
+	      printf ("  Error expected: %s\n",
+		      asn1_strerror (test->errorNumber));
+	      printf ("  Error detected: %s\n\n", asn1_strerror (result));
+	    }
+	  break;
+	case ACT_DECODING_ELEMENT:
+	  if (result != test->errorNumber)
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s - %s - %d\n", test->action,
+		      test->par1, test->par2, test->par3);
+	      printf ("  Error expected: %s\n",
+		      asn1_strerror (test->errorNumber));
+	      printf ("  Error detected: %s\n", asn1_strerror (result));
+	      printf ("  Error description : %s\n\n", errorDescription);
+	    }
+	  break;
+	case ACT_NUMBER_OF_ELEMENTS:
+	case ACT_READ_LENGTH:
+	  if ((result != test->errorNumber) || (valueLen != test->par3))
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s\n", test->action, test->par1);
+	      printf ("  Error expected: %s - %d\n",
+		      asn1_strerror (test->errorNumber), test->par3);
+	      printf ("  Error detected: %s - %d\n\n", asn1_strerror (result),
+		      valueLen);
+	    }
+	  break;
+	case ACT_ENCODING_LENGTH:
+	  if ((result != test->errorNumber) || (der_len != test->par3))
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s\n", test->action, test->par1);
+	      printf ("  Error expected: %s - %d\n",
+		      asn1_strerror (test->errorNumber), test->par3);
+	      printf ("  Error detected: %s - %d\n\n", asn1_strerror (result),
+		      der_len);
+	    }
+	  break;
+	case ACT_OID_2_STRUCTURE:
+	  if (((test->errorNumber != ASN1_SUCCESS) && (str_p != NULL)) ||
+	      ((test->errorNumber == ASN1_SUCCESS) && (str_p == NULL)) ||
+	      ((test->errorNumber == ASN1_SUCCESS)
+	       && (strcmp (str_p, test->par2))))
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s\n", test->action, test->par1);
+	      printf ("  Error expected: %s - %s\n",
+		      asn1_strerror (test->errorNumber), test->par2);
+	      printf ("  Value detected: %s\n\n", str_p);
+	    }
+	  break;
+	case ACT_DECODING_START_END:
+	  if ((result != test->errorNumber) ||
+	      ((!strcmp (test->par2, "START")) && (start != test->par3)) ||
+	      ((!strcmp (test->par2, "END")) && (end != test->par3)))
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s - %d\n", test->action, test->par1,
+		      test->par3);
+	      printf ("  Error expected: %s - %s - %d\n",
+		      asn1_strerror (test->errorNumber), test->par2,
+		      test->par3);
+	      printf ("  Error detected: %s - %d - %d\n\n",
+		      asn1_strerror (result), start, end);
+	    }
+	  break;
 
+	case ACT_READ_TAG_CLASS:
+	  if ((result != test->errorNumber) ||
+	      ((!strcmp (test->par2, "TAG")) && (tag != test->par3)) ||
+	      ((!strcmp (test->par2, "CLASS")) && (class != test->par3)))
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s - %d\n", test->action, test->par1,
+		      test->par3);
+	      printf ("  Error expected: %s - %s - %d\n",
+		      asn1_strerror (test->errorNumber), test->par2,
+		      test->par3);
+	      printf ("  Error detected: %s - %d - %d\n\n",
+		      asn1_strerror (result), tag, class);
+	    }
 
-  if(out != stdout) fclose(out);
+	  break;
 
-  if(errorCounter > 0)
-    return 1;
+	case ACT_READ:
+	case ACT_READ_DEFINITIONS:
+	case ACT_READ_BIT:
+	  if (test->action == ACT_READ_BIT)
+	    {
+	      if ((valueLen - (valueLen / 8.0)) == 0)
+		tag = valueLen / 8;
+	      else
+		tag = (valueLen / 8) + 1;
+	      if ((test->par3 - (test->par3 / 8.0)) == 0)
+		class = test->par3 / 8;
+	      else
+		class = (test->par3 / 8) + 1;
+	    }
+
+	  for (k = 0; k < class; k++)
+	    if (test->par2[k] != value[k])
+	      {
+		k = -1;
+		break;
+	      }
+
+	  if ((result != test->errorNumber) ||
+	      (valueLen != test->par3) || (k == -1))
+	    {
+	      errorCounter++;
+	      printf ("ERROR N. %d:\n", errorCounter);
+	      printf ("  Action %d - %s\n", test->action, test->par1);
+	      printf ("  Error expected: %s - %d - ",
+		      asn1_strerror (test->errorNumber), test->par3);
+	      for (k = 0; k < test->par3; k++)
+		printf ("%02x", test->par2[k]);
+	      printf ("\n  Error detected: %s - %d - ",
+		      asn1_strerror (result), valueLen);
+	      for (k = 0; k < valueLen; k++)
+		printf ("%02x", value[k]);
+	      printf ("\n\n");
+
+	    }
 
-  exit(0);
-}
+	  break;
+	default:
+	  break;
+	}
 
+      test++;
+    }
 
 
+  printf ("Total tests : %d\n", testCounter);
+  printf ("Total errors: %d\n", errorCounter);
 
 
+  /* Clear the definition structures */
+  asn1_delete_structure (&definitions);
 
 
+  if (out != stdout)
+    fclose (out);
 
+  if (errorCounter > 0)
+    return 1;
 
+  exit (0);
+}
diff --git a/windows/asn1-parser/config.h b/windows/asn1-parser/config.h
index d3205c2..50f98e7 100755
--- a/windows/asn1-parser/config.h
+++ b/windows/asn1-parser/config.h
@@ -1 +1 @@
-#define HAVE_GETOPT_H 1
\ No newline at end of file
+#define HAVE_GETOPT_H 1
diff --git a/windows/gnulib/getopt.h b/windows/gnulib/getopt.h
index 8c4cef1..d8c6e4d 100755
--- a/windows/gnulib/getopt.h
+++ b/windows/gnulib/getopt.h
@@ -1,2 +1,2 @@
 #define HAVE_GETOPT_LONG 1

-#include "getopt_.h"
\ No newline at end of file
+#include "getopt_.h"