Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/util/secasn1e.c

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*
  * Support for ENcoding ASN.1 data based on BER/DER (Basic/Distinguished
  * Encoding Rules).
  */
 
 #include "secasn1.h"
@@ skipping 53 matching lines @@
            disallowStreaming;   /* disallow streaming in all sub-templates */   
 } sec_asn1e_state;
 
 /*
  * An "outsider" will have an opaque pointer to this, created by calling
  * SEC_ASN1EncoderStart().  It will be passed back in to all subsequent
  * calls to SEC_ASN1EncoderUpdate() and related routines, and when done
  * it is passed to SEC_ASN1EncoderFinish().
  */
 struct sec_EncoderContext_struct {
-    PRArenaPool *our_pool;              /* for our internal allocs */
+    PLArenaPool *our_pool;              /* for our internal allocs */
 
     sec_asn1e_state *current;
     sec_asn1e_parse_status status;
 
     PRBool streaming;
     PRBool from_buf;
 
     SEC_ASN1NotifyProc notify_proc;     /* call before/after handling field */
     void *notify_arg;                   /* argument to notify_proc */
     PRBool during_notify;               /* true during call to notify_proc */
@@ skipping 1216 matching lines @@
      */
 
     PORT_FreeArena (cx->our_pool, PR_FALSE);
 }
 
 
 SEC_ASN1EncoderContext *
 SEC_ASN1EncoderStart (const void *src, const SEC_ASN1Template *theTemplate,
                       SEC_ASN1WriteProc output_proc, void *output_arg)
 {
-    PRArenaPool *our_pool;
+    PLArenaPool *our_pool;
     SEC_ASN1EncoderContext *cx;
 
     our_pool = PORT_NewArena (SEC_ASN1_DEFAULT_ARENA_SIZE);
     if (our_pool == NULL)
         return NULL;
 
     cx = (SEC_ASN1EncoderContext*)PORT_ArenaZAlloc (our_pool, sizeof(*cx));
     if (cx == NULL) {
         PORT_FreeArena (our_pool, PR_FALSE);
         return NULL;
@@ skipping 148 matching lines @@
 
 
 /*
  * Allocate an entire SECItem, or just the data part of it, to hold
  * "len" bytes of stuff.  Allocate from the given pool, if specified,
  * otherwise just do a vanilla PORT_Alloc.
  *
  * XXX This seems like a reasonable general-purpose function (for SECITEM_)?
  */
 static SECItem *
-sec_asn1e_allocate_item (PRArenaPool *poolp, SECItem *dest, unsigned long len)
+sec_asn1e_allocate_item (PLArenaPool *poolp, SECItem *dest, unsigned long len)
 {
     if (poolp != NULL) {
         void *release;
 
         release = PORT_ArenaMark (poolp);
         if (dest == NULL)
             dest = (SECItem*)PORT_ArenaAlloc (poolp, sizeof(SECItem));
         if (dest != NULL) {
             dest->data = (unsigned char*)PORT_ArenaAlloc (poolp, len);
             if (dest->data == NULL) {
@@ skipping 22 matching lines @@
                 dest = NULL;
             }
         }
     }
 
     return dest;
 }
 
 
 SECItem *
-SEC_ASN1EncodeItem (PRArenaPool *poolp, SECItem *dest, const void *src,
+SEC_ASN1EncodeItem (PLArenaPool *poolp, SECItem *dest, const void *src,
                     const SEC_ASN1Template *theTemplate)
 {
     unsigned long encoding_length;
     SECStatus rv;
 
     PORT_Assert (dest == NULL || dest->data == NULL);
 
     encoding_length = 0;
     rv = SEC_ASN1Encode (src, theTemplate,
                          sec_asn1e_encode_item_count, &encoding_length);
@@ skipping 11 matching lines @@
 
     dest->len = 0;
     (void) SEC_ASN1Encode (src, theTemplate, sec_asn1e_encode_item_store, dest);
 
     PORT_Assert (encoding_length == dest->len);
     return dest;
 }
 
 
 static SECItem *
-sec_asn1e_integer(PRArenaPool *poolp, SECItem *dest, unsigned long value,
+sec_asn1e_integer(PLArenaPool *poolp, SECItem *dest, unsigned long value,
                   PRBool is_unsigned)
 {
     unsigned long copy;
     unsigned char sign;
     int len = 0;
 
     /*
      * Determine the length of the encoded value (minimum of 1).
      */
     copy = value;
@@ skipping 26 matching lines @@
         dest->data[--len] = (unsigned char)value;
         value >>= 8;
     }
     PORT_Assert (value == 0);
 
     return dest;
 }
 
 
 SECItem *
-SEC_ASN1EncodeInteger(PRArenaPool *poolp, SECItem *dest, long value)
+SEC_ASN1EncodeInteger(PLArenaPool *poolp, SECItem *dest, long value)
 {
     return sec_asn1e_integer (poolp, dest, (unsigned long) value, PR_FALSE);
 }
 
 
 SECItem *
-SEC_ASN1EncodeUnsignedInteger(PRArenaPool *poolp,
+SEC_ASN1EncodeUnsignedInteger(PLArenaPool *poolp,
                               SECItem *dest, unsigned long value)
 {
     return sec_asn1e_integer (poolp, dest, value, PR_TRUE);
 }