1 files changed, 224 insertions, 148 deletions

diff --git a/nss/lib/nss/utilwrap.c b/nss/lib/nss/utilwrap.c
index d3b6037..938d95c 100644
--- a/nss/lib/nss/utilwrap.c
+++ b/nss/lib/nss/utilwrap.c
@@ -236,518 +236,595 @@ PORT_SetUCS4_UTF8ConversionFunction(PORTCharConversionFunc convFunc)
 
 void
 PORT_SetUCS2_ASCIIConversionFunction(PORTCharConversionWSwapFunc convFunc)
-{ 
+{
     PORT_SetUCS2_ASCIIConversionFunction_Util(convFunc);
 }
 
 void
 PORT_SetUCS2_UTF8ConversionFunction(PORTCharConversionFunc convFunc)
-{ 
+{
     PORT_SetUCS2_UTF8ConversionFunction_Util(convFunc);
 }
 
-PRBool 
+PRBool
 PORT_UCS2_UTF8Conversion(PRBool toUnicode, unsigned char *inBuf,
-			 unsigned int inBufLen, unsigned char *outBuf,
-			 unsigned int maxOutBufLen, unsigned int *outBufLen)
+                         unsigned int inBufLen, unsigned char *outBuf,
+                         unsigned int maxOutBufLen, unsigned int *outBufLen)
 {
     return PORT_UCS2_UTF8Conversion_Util(toUnicode, inBuf, inBufLen, outBuf,
-                                          maxOutBufLen, outBufLen);
-} 
+                                         maxOutBufLen, outBufLen);
+}
 
-PRBool 
+PRBool
 PORT_UCS2_ASCIIConversion(PRBool toUnicode, unsigned char *inBuf,
-			  unsigned int inBufLen, unsigned char *outBuf,
-			  unsigned int maxOutBufLen, unsigned int *outBufLen,
-			  PRBool swapBytes)
+                          unsigned int inBufLen, unsigned char *outBuf,
+                          unsigned int maxOutBufLen, unsigned int *outBufLen,
+                          PRBool swapBytes)
 {
     return PORT_UCS2_ASCIIConversion_Util(toUnicode, inBuf, inBufLen, outBuf,
-			  maxOutBufLen, outBufLen, swapBytes);
+                                          maxOutBufLen, outBufLen, swapBytes);
 }
 
 int
-NSS_PutEnv(const char * envVarName, const char * envValue)
+NSS_PutEnv(const char *envVarName, const char *envValue)
 {
     return NSS_PutEnv_Util(envVarName, envValue);
 }
 
-SECOidData *SECOID_FindOID( const SECItem *oid)
+SECOidData *
+SECOID_FindOID(const SECItem *oid)
 {
     return SECOID_FindOID_Util(oid);
 }
 
-SECOidTag SECOID_FindOIDTag(const SECItem *oid)
+SECOidTag
+SECOID_FindOIDTag(const SECItem *oid)
 {
     return SECOID_FindOIDTag_Util(oid);
 }
 
-SECOidData *SECOID_FindOIDByTag(SECOidTag tagnum)
+SECOidData *
+SECOID_FindOIDByTag(SECOidTag tagnum)
 {
     return SECOID_FindOIDByTag_Util(tagnum);
 }
 
-SECStatus SECOID_SetAlgorithmID(PLArenaPool *arena, SECAlgorithmID *aid,
-				   SECOidTag tag, SECItem *params)
+SECStatus
+SECOID_SetAlgorithmID(PLArenaPool *arena, SECAlgorithmID *aid,
+                      SECOidTag tag, SECItem *params)
 {
     return SECOID_SetAlgorithmID_Util(arena, aid, tag, params);
 }
 
-SECStatus SECOID_CopyAlgorithmID(PLArenaPool *arena, SECAlgorithmID *dest,
-				 const SECAlgorithmID *src)
+SECStatus
+SECOID_CopyAlgorithmID(PLArenaPool *arena, SECAlgorithmID *dest,
+                       const SECAlgorithmID *src)
 {
     return SECOID_CopyAlgorithmID_Util(arena, dest, src);
 }
 
-SECOidTag SECOID_GetAlgorithmTag(const SECAlgorithmID *aid)
+SECOidTag
+SECOID_GetAlgorithmTag(const SECAlgorithmID *aid)
 {
     return SECOID_GetAlgorithmTag_Util(aid);
 }
 
-void SECOID_DestroyAlgorithmID(SECAlgorithmID *aid, PRBool freeit)
+void
+SECOID_DestroyAlgorithmID(SECAlgorithmID *aid, PRBool freeit)
 {
     SECOID_DestroyAlgorithmID_Util(aid, freeit);
 }
 
-SECComparison SECOID_CompareAlgorithmID(SECAlgorithmID *a,
-					   SECAlgorithmID *b)
+SECComparison
+SECOID_CompareAlgorithmID(SECAlgorithmID *a,
+                          SECAlgorithmID *b)
 {
     return SECOID_CompareAlgorithmID_Util(a, b);
 }
 
-const char *SECOID_FindOIDTagDescription(SECOidTag tagnum)
+const char *
+SECOID_FindOIDTagDescription(SECOidTag tagnum)
 {
     return SECOID_FindOIDTagDescription_Util(tagnum);
 }
 
-SECOidTag SECOID_AddEntry(const SECOidData * src)
+SECOidTag
+SECOID_AddEntry(const SECOidData *src)
 {
     return SECOID_AddEntry_Util(src);
 }
 
-SECItem *SECITEM_AllocItem(PLArenaPool *arena, SECItem *item,
-				  unsigned int len)
+SECItem *
+SECITEM_AllocItem(PLArenaPool *arena, SECItem *item,
+                  unsigned int len)
 {
     return SECITEM_AllocItem_Util(arena, item, len);
 }
 
-SECComparison SECITEM_CompareItem(const SECItem *a, const SECItem *b)
+SECComparison
+SECITEM_CompareItem(const SECItem *a, const SECItem *b)
 {
     return SECITEM_CompareItem_Util(a, b);
 }
 
-PRBool SECITEM_ItemsAreEqual(const SECItem *a, const SECItem *b)
+PRBool
+SECITEM_ItemsAreEqual(const SECItem *a, const SECItem *b)
 {
     return SECITEM_ItemsAreEqual_Util(a, b);
 }
 
-SECStatus SECITEM_CopyItem(PLArenaPool *arena, SECItem *to,
-                                  const SECItem *from)
+SECStatus
+SECITEM_CopyItem(PLArenaPool *arena, SECItem *to,
+                 const SECItem *from)
 {
     return SECITEM_CopyItem_Util(arena, to, from);
 }
 
-SECItem *SECITEM_DupItem(const SECItem *from)
+SECItem *
+SECITEM_DupItem(const SECItem *from)
 {
     return SECITEM_DupItem_Util(from);
 }
 
-SECItem *SECITEM_ArenaDupItem(PLArenaPool *arena, const SECItem *from)
+SECItem *
+SECITEM_ArenaDupItem(PLArenaPool *arena, const SECItem *from)
 {
     return SECITEM_ArenaDupItem_Util(arena, from);
 }
 
-void SECITEM_FreeItem(SECItem *zap, PRBool freeit)
+void
+SECITEM_FreeItem(SECItem *zap, PRBool freeit)
 {
     SECITEM_FreeItem_Util(zap, freeit);
 }
 
-void SECITEM_ZfreeItem(SECItem *zap, PRBool freeit)
+void
+SECITEM_ZfreeItem(SECItem *zap, PRBool freeit)
 {
     SECITEM_ZfreeItem_Util(zap, freeit);
 }
 
-SGNDigestInfo *SGN_CreateDigestInfo(SECOidTag algorithm,
-					   unsigned char *sig,
-					   unsigned int sigLen)
+SGNDigestInfo *
+SGN_CreateDigestInfo(SECOidTag algorithm,
+                     unsigned char *sig,
+                     unsigned int sigLen)
 {
     return SGN_CreateDigestInfo_Util(algorithm, sig, sigLen);
 }
 
-void SGN_DestroyDigestInfo(SGNDigestInfo *info)
+void
+SGN_DestroyDigestInfo(SGNDigestInfo *info)
 {
     SGN_DestroyDigestInfo_Util(info);
 }
 
-SECStatus  SGN_CopyDigestInfo(PLArenaPool *poolp,
-					SGNDigestInfo *a, 
-					SGNDigestInfo *b)
+SECStatus
+SGN_CopyDigestInfo(PLArenaPool *poolp,
+                   SGNDigestInfo *a,
+                   SGNDigestInfo *b)
 {
     return SGN_CopyDigestInfo_Util(poolp, a, b);
 }
 
-SECComparison SGN_CompareDigestInfo(SGNDigestInfo *a, SGNDigestInfo *b)
+SECComparison
+SGN_CompareDigestInfo(SGNDigestInfo *a, SGNDigestInfo *b)
 {
     return SGN_CompareDigestInfo_Util(a, b);
 }
 
-SECStatus DER_Encode(PLArenaPool *arena, SECItem *dest, DERTemplate *t,
-			   void *src)
+SECStatus
+DER_Encode(PLArenaPool *arena, SECItem *dest, DERTemplate *t,
+           void *src)
 {
     return DER_Encode_Util(arena, dest, t, src);
 }
 
-SECStatus DER_Lengths(SECItem *item, int *header_len_p,
-                             PRUint32 *contents_len_p)
+SECStatus
+DER_Lengths(SECItem *item, int *header_len_p,
+            PRUint32 *contents_len_p)
 {
     return DER_Lengths_Util(item, header_len_p, contents_len_p);
 }
 
-long DER_GetInteger(const SECItem *src)
+long
+DER_GetInteger(const SECItem *src)
 {
     return DER_GetInteger_Util(src);
 }
 
-SECStatus DER_TimeToUTCTime(SECItem *result, PRTime time)
+SECStatus
+DER_TimeToUTCTime(SECItem *result, PRTime time)
 {
     return DER_TimeToUTCTime_Util(result, time);
 }
 
-SECStatus DER_AsciiToTime(PRTime *result, const char *string)
+SECStatus
+DER_AsciiToTime(PRTime *result, const char *string)
 {
     return DER_AsciiToTime_Util(result, string);
 }
 
-SECStatus DER_UTCTimeToTime(PRTime *result, const SECItem *time)
+SECStatus
+DER_UTCTimeToTime(PRTime *result, const SECItem *time)
 {
     return DER_UTCTimeToTime_Util(result, time);
 }
 
-char *DER_UTCTimeToAscii(SECItem *utcTime)
+char *
+DER_UTCTimeToAscii(SECItem *utcTime)
 {
     return DER_UTCTimeToAscii_Util(utcTime);
 }
 
-char *DER_UTCDayToAscii(SECItem *utctime)
+char *
+DER_UTCDayToAscii(SECItem *utctime)
 {
     return DER_UTCDayToAscii_Util(utctime);
 }
 
-char *DER_GeneralizedDayToAscii(SECItem *gentime)
+char *
+DER_GeneralizedDayToAscii(SECItem *gentime)
 {
     return DER_GeneralizedDayToAscii_Util(gentime);
 }
 
-char *DER_TimeChoiceDayToAscii(SECItem *timechoice)
+char *
+DER_TimeChoiceDayToAscii(SECItem *timechoice)
 {
     return DER_TimeChoiceDayToAscii_Util(timechoice);
 }
 
-SECStatus DER_TimeToGeneralizedTime(SECItem *dst, PRTime gmttime)
+SECStatus
+DER_TimeToGeneralizedTime(SECItem *dst, PRTime gmttime)
 {
     return DER_TimeToGeneralizedTime_Util(dst, gmttime);
 }
 
-SECStatus DER_TimeToGeneralizedTimeArena(PLArenaPool* arenaOpt,
-                                         SECItem *dst, PRTime gmttime)
+SECStatus
+DER_TimeToGeneralizedTimeArena(PLArenaPool *arenaOpt,
+                               SECItem *dst, PRTime gmttime)
 {
     return DER_TimeToGeneralizedTimeArena_Util(arenaOpt, dst, gmttime);
 }
 
-SECStatus DER_GeneralizedTimeToTime(PRTime *dst, const SECItem *time)
+SECStatus
+DER_GeneralizedTimeToTime(PRTime *dst, const SECItem *time)
 {
     return DER_GeneralizedTimeToTime_Util(dst, time);
 }
 
-char *CERT_GenTime2FormattedAscii(PRTime genTime, char *format)
+char *
+CERT_GenTime2FormattedAscii(PRTime genTime, char *format)
 {
     return CERT_GenTime2FormattedAscii_Util(genTime, format);
 }
 
-SECStatus DER_DecodeTimeChoice(PRTime* output, const SECItem* input)
+SECStatus
+DER_DecodeTimeChoice(PRTime *output, const SECItem *input)
 {
     return DER_DecodeTimeChoice_Util(output, input);
 }
 
-SECStatus DER_EncodeTimeChoice(PLArenaPool* arena, SECItem* output,
-                                       PRTime input)
+SECStatus
+DER_EncodeTimeChoice(PLArenaPool *arena, SECItem *output,
+                     PRTime input)
 {
     return DER_EncodeTimeChoice_Util(arena, output, input);
 }
 
-SEC_ASN1DecoderContext *SEC_ASN1DecoderStart(PLArenaPool *pool,
-						    void *dest,
-						    const SEC_ASN1Template *t)
+SEC_ASN1DecoderContext *
+SEC_ASN1DecoderStart(PLArenaPool *pool,
+                     void *dest,
+                     const SEC_ASN1Template *t)
 {
     return SEC_ASN1DecoderStart_Util(pool, dest, t);
 }
 
-SECStatus SEC_ASN1DecoderUpdate(SEC_ASN1DecoderContext *cx,
-				       const char *buf,
-				       unsigned long len)
+SECStatus
+SEC_ASN1DecoderUpdate(SEC_ASN1DecoderContext *cx,
+                      const char *buf,
+                      unsigned long len)
 {
     return SEC_ASN1DecoderUpdate_Util(cx, buf, len);
 }
 
-SECStatus SEC_ASN1DecoderFinish(SEC_ASN1DecoderContext *cx)
+SECStatus
+SEC_ASN1DecoderFinish(SEC_ASN1DecoderContext *cx)
 {
     return SEC_ASN1DecoderFinish_Util(cx);
 }
 
-void SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error)
+void
+SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error)
 {
     SEC_ASN1DecoderAbort_Util(cx, error);
 }
 
-void SEC_ASN1DecoderSetFilterProc(SEC_ASN1DecoderContext *cx,
-					 SEC_ASN1WriteProc fn,
-					 void *arg, PRBool no_store)
+void
+SEC_ASN1DecoderSetFilterProc(SEC_ASN1DecoderContext *cx,
+                             SEC_ASN1WriteProc fn,
+                             void *arg, PRBool no_store)
 {
     SEC_ASN1DecoderSetFilterProc_Util(cx, fn, arg, no_store);
 }
 
-void SEC_ASN1DecoderClearFilterProc(SEC_ASN1DecoderContext *cx)
+void
+SEC_ASN1DecoderClearFilterProc(SEC_ASN1DecoderContext *cx)
 {
     SEC_ASN1DecoderClearFilterProc_Util(cx);
 }
 
-void SEC_ASN1DecoderSetNotifyProc(SEC_ASN1DecoderContext *cx,
-					 SEC_ASN1NotifyProc fn,
-					 void *arg)
+void
+SEC_ASN1DecoderSetNotifyProc(SEC_ASN1DecoderContext *cx,
+                             SEC_ASN1NotifyProc fn,
+                             void *arg)
 {
     SEC_ASN1DecoderSetNotifyProc_Util(cx, fn, arg);
 }
 
-void SEC_ASN1DecoderClearNotifyProc(SEC_ASN1DecoderContext *cx)
+void
+SEC_ASN1DecoderClearNotifyProc(SEC_ASN1DecoderContext *cx)
 {
     SEC_ASN1DecoderClearNotifyProc_Util(cx);
 }
 
-SECStatus SEC_ASN1Decode(PLArenaPool *pool, void *dest,
-				const SEC_ASN1Template *t,
-				const char *buf, long len)
+SECStatus
+SEC_ASN1Decode(PLArenaPool *pool, void *dest,
+               const SEC_ASN1Template *t,
+               const char *buf, long len)
 {
     return SEC_ASN1Decode_Util(pool, dest, t, buf, len);
 }
 
-SECStatus SEC_ASN1DecodeItem(PLArenaPool *pool, void *dest,
-				    const SEC_ASN1Template *t,
-				    const SECItem *src)
+SECStatus
+SEC_ASN1DecodeItem(PLArenaPool *pool, void *dest,
+                   const SEC_ASN1Template *t,
+                   const SECItem *src)
 {
     return SEC_ASN1DecodeItem_Util(pool, dest, t, src);
 }
 
-SECStatus SEC_QuickDERDecodeItem(PLArenaPool* arena, void* dest,
-                     const SEC_ASN1Template* templateEntry,
-                     const SECItem* src)
+SECStatus
+SEC_QuickDERDecodeItem(PLArenaPool *arena, void *dest,
+                       const SEC_ASN1Template *templateEntry,
+                       const SECItem *src)
 {
     return SEC_QuickDERDecodeItem_Util(arena, dest, templateEntry, src);
 }
 
-SEC_ASN1EncoderContext *SEC_ASN1EncoderStart(const void *src,
-						    const SEC_ASN1Template *t,
-						    SEC_ASN1WriteProc fn,
-						    void *output_arg)
+SEC_ASN1EncoderContext *
+SEC_ASN1EncoderStart(const void *src,
+                     const SEC_ASN1Template *t,
+                     SEC_ASN1WriteProc fn,
+                     void *output_arg)
 {
     return SEC_ASN1EncoderStart_Util(src, t, fn, output_arg);
 }
 
-SECStatus SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx,
-				       const char *buf,
-				       unsigned long len)
+SECStatus
+SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx,
+                      const char *buf,
+                      unsigned long len)
 {
     return SEC_ASN1EncoderUpdate_Util(cx, buf, len);
 }
 
-void SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx)
+void
+SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx)
 {
     SEC_ASN1EncoderFinish_Util(cx);
 }
 
-void SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error)
+void
+SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error)
 {
     SEC_ASN1EncoderAbort_Util(cx, error);
 }
 
-void SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx,
-					 SEC_ASN1NotifyProc fn,
-					 void *arg)
+void
+SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx,
+                             SEC_ASN1NotifyProc fn,
+                             void *arg)
 {
     SEC_ASN1EncoderSetNotifyProc_Util(cx, fn, arg);
 }
 
-void SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx)
+void
+SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx)
 {
     SEC_ASN1EncoderClearNotifyProc_Util(cx);
 }
 
-void SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx)
+void
+SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx)
 {
     SEC_ASN1EncoderSetStreaming_Util(cx);
 }
 
-void SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx)
+void
+SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx)
 {
     SEC_ASN1EncoderClearStreaming_Util(cx);
 }
 
-void SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx)
+void
+SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx)
 {
     SEC_ASN1EncoderSetTakeFromBuf_Util(cx);
 }
 
-void SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx)
+void
+SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx)
 {
     SEC_ASN1EncoderClearTakeFromBuf_Util(cx);
 }
 
-SECStatus SEC_ASN1Encode(const void *src, const SEC_ASN1Template *t,
-				SEC_ASN1WriteProc output_proc,
-				void *output_arg)
+SECStatus
+SEC_ASN1Encode(const void *src, const SEC_ASN1Template *t,
+               SEC_ASN1WriteProc output_proc,
+               void *output_arg)
 {
     return SEC_ASN1Encode_Util(src, t, output_proc, output_arg);
 }
 
-SECItem * SEC_ASN1EncodeItem(PLArenaPool *pool, SECItem *dest,
-				    const void *src, const SEC_ASN1Template *t)
+SECItem *
+SEC_ASN1EncodeItem(PLArenaPool *pool, SECItem *dest,
+                   const void *src, const SEC_ASN1Template *t)
 {
     return SEC_ASN1EncodeItem_Util(pool, dest, src, t);
 }
 
-SECItem * SEC_ASN1EncodeInteger(PLArenaPool *pool,
-				       SECItem *dest, long value)
+SECItem *
+SEC_ASN1EncodeInteger(PLArenaPool *pool,
+                      SECItem *dest, long value)
 {
     return SEC_ASN1EncodeInteger_Util(pool, dest, value);
 }
 
-SECItem * SEC_ASN1EncodeUnsignedInteger(PLArenaPool *pool,
-					       SECItem *dest,
-					       unsigned long value)
+SECItem *
+SEC_ASN1EncodeUnsignedInteger(PLArenaPool *pool,
+                              SECItem *dest,
+                              unsigned long value)
 {
     return SEC_ASN1EncodeUnsignedInteger_Util(pool, dest, value);
 }
 
-SECStatus SEC_ASN1DecodeInteger(SECItem *src,
-				       unsigned long *value)
+SECStatus
+SEC_ASN1DecodeInteger(SECItem *src,
+                      unsigned long *value)
 {
     return SEC_ASN1DecodeInteger_Util(src, value);
 }
 
-int SEC_ASN1LengthLength (unsigned long len)
+int
+SEC_ASN1LengthLength(unsigned long len)
 {
     return SEC_ASN1LengthLength_Util(len);
 }
 
-char *BTOA_DataToAscii(const unsigned char *data, unsigned int len)
+char *
+BTOA_DataToAscii(const unsigned char *data, unsigned int len)
 {
     return BTOA_DataToAscii_Util(data, len);
 }
 
-unsigned char *ATOB_AsciiToData(const char *string, unsigned int *lenp)
+unsigned char *
+ATOB_AsciiToData(const char *string, unsigned int *lenp)
 {
     return ATOB_AsciiToData_Util(string, lenp);
 }
- 
-SECStatus ATOB_ConvertAsciiToItem(SECItem *binary_item, const char *ascii)
+
+SECStatus
+ATOB_ConvertAsciiToItem(SECItem *binary_item, const char *ascii)
 {
     return ATOB_ConvertAsciiToItem_Util(binary_item, ascii);
 }
 
-char *BTOA_ConvertItemToAscii(SECItem *binary_item)
+char *
+BTOA_ConvertItemToAscii(SECItem *binary_item)
 {
     return BTOA_ConvertItemToAscii_Util(binary_item);
 }
 
 NSSBase64Decoder *
-NSSBase64Decoder_Create (PRInt32 (*output_fn) (void *, const unsigned char *,
-					       PRInt32),
-			 void *output_arg)
+NSSBase64Decoder_Create(PRInt32 (*output_fn)(void *, const unsigned char *,
+                                             PRInt32),
+                        void *output_arg)
 {
     return NSSBase64Decoder_Create_Util(output_fn, output_arg);
 }
 
 NSSBase64Encoder *
-NSSBase64Encoder_Create (PRInt32 (*output_fn) (void *, const char *, PRInt32),
-			 void *output_arg)
+NSSBase64Encoder_Create(PRInt32 (*output_fn)(void *, const char *, PRInt32),
+                        void *output_arg)
 {
     return NSSBase64Encoder_Create_Util(output_fn, output_arg);
 }
 
 SECStatus
-NSSBase64Decoder_Update (NSSBase64Decoder *data, const char *buffer,
-			 PRUint32 size)
+NSSBase64Decoder_Update(NSSBase64Decoder *data, const char *buffer,
+                        PRUint32 size)
 {
     return NSSBase64Decoder_Update_Util(data, buffer, size);
 }
 
 SECStatus
-NSSBase64Encoder_Update (NSSBase64Encoder *data, const unsigned char *buffer,
-			 PRUint32 size)
+NSSBase64Encoder_Update(NSSBase64Encoder *data, const unsigned char *buffer,
+                        PRUint32 size)
 {
     return NSSBase64Encoder_Update_Util(data, buffer, size);
 }
 
 SECStatus
-NSSBase64Decoder_Destroy (NSSBase64Decoder *data, PRBool abort_p)
+NSSBase64Decoder_Destroy(NSSBase64Decoder *data, PRBool abort_p)
 {
     return NSSBase64Decoder_Destroy_Util(data, abort_p);
 }
 
 SECStatus
-NSSBase64Encoder_Destroy (NSSBase64Encoder *data, PRBool abort_p)
+NSSBase64Encoder_Destroy(NSSBase64Encoder *data, PRBool abort_p)
 {
     return NSSBase64Encoder_Destroy_Util(data, abort_p);
 }
 
 SECItem *
-NSSBase64_DecodeBuffer (PLArenaPool *arenaOpt, SECItem *outItemOpt,
-			const char *inStr, unsigned int inLen)
+NSSBase64_DecodeBuffer(PLArenaPool *arenaOpt, SECItem *outItemOpt,
+                       const char *inStr, unsigned int inLen)
 {
     return NSSBase64_DecodeBuffer_Util(arenaOpt, outItemOpt, inStr, inLen);
 }
 
 char *
-NSSBase64_EncodeItem (PLArenaPool *arenaOpt, char *outStrOpt,
-		      unsigned int maxOutLen, SECItem *inItem)
+NSSBase64_EncodeItem(PLArenaPool *arenaOpt, char *outStrOpt,
+                     unsigned int maxOutLen, SECItem *inItem)
 {
     return NSSBase64_EncodeItem_Util(arenaOpt, outStrOpt, maxOutLen, inItem);
 }
 
-NSSRWLock* NSSRWLock_New(PRUint32 lock_rank, const char *lock_name)
+NSSRWLock *
+NSSRWLock_New(PRUint32 lock_rank, const char *lock_name)
 {
     return NSSRWLock_New_Util(lock_rank, lock_name);
 }
 
-void NSSRWLock_Destroy(NSSRWLock *lock)
+void
+NSSRWLock_Destroy(NSSRWLock *lock)
 {
     NSSRWLock_Destroy_Util(lock);
 }
 
-void NSSRWLock_LockRead(NSSRWLock *lock)
+void
+NSSRWLock_LockRead(NSSRWLock *lock)
 {
     NSSRWLock_LockRead_Util(lock);
 }
 
-void NSSRWLock_LockWrite(NSSRWLock *lock)
+void
+NSSRWLock_LockWrite(NSSRWLock *lock)
 {
     NSSRWLock_LockWrite_Util(lock);
 }
 
-void NSSRWLock_UnlockRead(NSSRWLock *lock)
+void
+NSSRWLock_UnlockRead(NSSRWLock *lock)
 {
     NSSRWLock_UnlockRead_Util(lock);
 }
 
-void NSSRWLock_UnlockWrite(NSSRWLock *lock)
+void
+NSSRWLock_UnlockWrite(NSSRWLock *lock)
 {
     NSSRWLock_UnlockWrite_Util(lock);
 }
 
-PRBool NSSRWLock_HaveWriteLock(NSSRWLock *rwlock)
+PRBool
+NSSRWLock_HaveWriteLock(NSSRWLock *rwlock)
 {
     return NSSRWLock_HaveWriteLock_Util(rwlock);
 }
 
-SECStatus __nss_InitLock(   PZLock    **ppLock, nssILockType ltype )
+SECStatus
+__nss_InitLock(PZLock **ppLock, nssILockType ltype)
 {
     PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
     return SECFailure;
@@ -791,4 +868,3 @@ SECStatus __nss_InitLock(   PZLock    **ppLock, nssILockType ltype )
 #undef sgn_DigestInfoTemplate
 
 #include "templates.c"
-