Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/util/secasn1d.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 DEcoding ASN.1 data based on BER/DER (Basic/Distinguished
  * Encoding Rules).
  */
 
 /* #define DEBUG_ASN1D_STATES 1 */
@@ skipping 254 matching lines @@
 #define HIGH_BITS(field,cnt)    ((field) >> ((sizeof(field) * 8) - (cnt)))
 
 
 /*
  * An "outsider" will have an opaque pointer to this, created by calling
  * SEC_ASN1DecoderStart().  It will be passed back in to all subsequent
  * calls to SEC_ASN1DecoderUpdate(), and when done it is passed to
  * SEC_ASN1DecoderFinish().
  */
 struct sec_DecoderContext_struct {
-    PRArenaPool *our_pool;              /* for our internal allocs */
-    PRArenaPool *their_pool;            /* for destination structure allocs */
+    PLArenaPool *our_pool;              /* for our internal allocs */
+    PLArenaPool *their_pool;            /* for destination structure allocs */
 #ifdef SEC_ASN1D_FREE_ON_ERROR          /*
                                          * XXX see comment below (by same
                                          * ifdef) that explains why this
                                          * does not work (need more smarts
                                          * in order to free back to mark)
                                          */
     /*
      * XXX how to make their_mark work in the case where they do NOT
      * give us a pool pointer?
      */
@@ skipping 10 matching lines @@
     SEC_ASN1WriteProc filter_proc;      /* pass field bytes to this  */
     void *filter_arg;                   /* argument to that function */
     PRBool filter_only;                 /* do not allocate/store fields */
 };
 
 
 /*
  * XXX this is a fairly generic function that may belong elsewhere
  */
 static void *
-sec_asn1d_alloc (PRArenaPool *poolp, unsigned long len)
+sec_asn1d_alloc (PLArenaPool *poolp, unsigned long len)
 {
     void *thing;
 
     if (poolp != NULL) {
         /*
          * Allocate from the pool.
          */
         thing = PORT_ArenaAlloc (poolp, len);
     } else {
         /*
          * Allocate generically.
          */
         thing = PORT_Alloc (len);
     }
 
     return thing;
 }
 
 
 /*
  * XXX this is a fairly generic function that may belong elsewhere
  */
 static void *
-sec_asn1d_zalloc (PRArenaPool *poolp, unsigned long len)
+sec_asn1d_zalloc (PLArenaPool *poolp, unsigned long len)
 {
     void *thing;
 
     thing = sec_asn1d_alloc (poolp, len);
     if (thing != NULL)
         PORT_Memset (thing, 0, len);
     return thing;
 }
 
 
@@ skipping 607 matching lines @@
         state->place = afterLength;
 
     return count;
 }
 
 
 static void
 sec_asn1d_prepare_for_contents (sec_asn1d_state *state)
 {
     SECItem *item;
-    PRArenaPool *poolp;
+    PLArenaPool *poolp;
     unsigned long alloc_len;
 
 #ifdef DEBUG_ASN1D_STATES
     {
         printf("Found Length %d %s\n", state->contents_length,
                state->indefinite ? "indefinite" : "");
     }
 #endif
 
     /*
@@ skipping 1841 matching lines @@
      * XXX anything else that needs to be finished?
      */
 
     PORT_FreeArena (cx->our_pool, PR_TRUE);
 
     return rv;
 }
 
 
 SEC_ASN1DecoderContext *
-SEC_ASN1DecoderStart (PRArenaPool *their_pool, void *dest,
+SEC_ASN1DecoderStart (PLArenaPool *their_pool, void *dest,
                       const SEC_ASN1Template *theTemplate)
 {
-    PRArenaPool *our_pool;
+    PLArenaPool *our_pool;
     SEC_ASN1DecoderContext *cx;
 
     our_pool = PORT_NewArena (SEC_ASN1_DEFAULT_ARENA_SIZE);
     if (our_pool == NULL)
         return NULL;
 
     cx = (SEC_ASN1DecoderContext*)PORT_ArenaZAlloc (our_pool, sizeof(*cx));
     if (cx == NULL) {
         PORT_FreeArena (our_pool, PR_FALSE);
         return NULL;
@@ skipping 68 matching lines @@
 void
 SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error)
 {
     PORT_Assert(cx);
     PORT_SetError(error);
     cx->status = decodeError;
 }
 
 
 SECStatus
-SEC_ASN1Decode (PRArenaPool *poolp, void *dest,
+SEC_ASN1Decode (PLArenaPool *poolp, void *dest,
                 const SEC_ASN1Template *theTemplate,
                 const char *buf, long len)
 {
     SEC_ASN1DecoderContext *dcx;
     SECStatus urv, frv;
 
     dcx = SEC_ASN1DecoderStart (poolp, dest, theTemplate);
     if (dcx == NULL)
         return SECFailure;
 
     urv = SEC_ASN1DecoderUpdate (dcx, buf, len);
     frv = SEC_ASN1DecoderFinish (dcx);
 
     if (urv != SECSuccess)
         return urv;
 
     return frv;
 }
 
 
 SECStatus
-SEC_ASN1DecodeItem (PRArenaPool *poolp, void *dest,
+SEC_ASN1DecodeItem (PLArenaPool *poolp, void *dest,
                     const SEC_ASN1Template *theTemplate,
                     const SECItem *src)
 {
     return SEC_ASN1Decode (poolp, dest, theTemplate,
                            (const char *)src->data, src->len);
 }
 
 #ifdef DEBUG_ASN1D_STATES
 void sec_asn1d_Assert(const char *s, const char *file, PRIntn ln)
 {
@@ skipping 280 matching lines @@
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_EnumeratedTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_PointerToEnumeratedTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SequenceOfAnyTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SequenceOfObjectIDTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SkipTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_UniversalStringTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_PrintableStringTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_T61StringTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_PointerToGeneralizedTimeTemplate)