VirtualBox

Ignore:
Timestamp:
Nov 4, 2023 4:53:22 PM (17 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
159860
Message:

libs/xpcom: Remove unused code, bugref:10545

Location:
trunk/src/libs/xpcom18a4/nsprpub/lib/libc
Files:
2 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/libs/xpcom18a4/nsprpub/lib/libc/include/plstr.h

    r11551 r101764  
    7575#define PL_strcaserstr VBoxNsplPL_strcaserstr
    7676#define PL_strcasestr VBoxNsplPL_strcasestr
    77 #define PL_strcat VBoxNsplPL_strcat
    78 #define PL_strcatn VBoxNsplPL_strcatn
    79 #define PL_strchr VBoxNsplPL_strchr
    80 #define PL_strcpy VBoxNsplPL_strcpy
    81 #define PL_strncaserstr VBoxNsplPL_strncaserstr
    82 #define PL_strncasestr VBoxNsplPL_strncasestr
    83 #define PL_strncat VBoxNsplPL_strncat
    84 #define PL_strnchr VBoxNsplPL_strnchr
    8577#define PL_strndup VBoxNsplPL_strndup
    8678#define PL_strnlen VBoxNsplPL_strnlen
    87 #define PL_strnpbrk VBoxNsplPL_strnpbrk
    88 #define PL_strnprbrk VBoxNsplPL_strnprbrk
    89 #define PL_strnrchr VBoxNsplPL_strnrchr
    90 #define PL_strnrstr VBoxNsplPL_strnrstr
    9179#define PL_strnstr VBoxNsplPL_strnstr
    9280#define PL_strpbrk VBoxNsplPL_strpbrk
    93 #define PL_strprbrk VBoxNsplPL_strprbrk
    9481#define PL_strrstr VBoxNsplPL_strrstr
    95 #define PL_strstr VBoxNsplPL_strstr
    96 #define PL_strtok_r VBoxNsplPL_strtok_r
    9782#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
    9883
    … …  
    117102PR_EXTERN(PRUint32)
    118103PL_strnlen(const char *str, PRUint32 max);
    119 
    120 /*
    121  * PL_strcpy
    122  *
    123  * Copies the source string, up to and including the trailing '\0', into the
    124  * destination buffer.  It does not (can not) verify that the destination
    125  * buffer is large enough.  It returns the "dest" argument.
    126  */
    127 
    128 PR_EXTERN(char *)
    129 PL_strcpy(char *dest, const char *src);
    130104
    131105/*
    … …  
    202176PR_EXTERN(char *)
    203177PL_strndup(const char *s, PRUint32 max);
    204 
    205 /*
    206  * PL_strcat
    207  *
    208  * Appends a copy of the string pointed to by the second argument to the
    209  * end of the string pointed to by the first.  The destination buffer is
    210  * not (can not be) checked for sufficient size.  A null destination
    211  * argument returns null; otherwise, the first argument is returned.
    212  */
    213 
    214 PR_EXTERN(char *)
    215 PL_strcat(char *dst, const char *src);
    216 
    217 /*
    218  * PL_strncat
    219  *
    220  * Appends a copy of the string pointed to by the second argument, up to
    221  * the maximum size specified, to the end of the string pointed to by the
    222  * first.  The destination buffer is not (can not be) checked for sufficient
    223  * size.  A null destination argument returns null; otherwise, the first
    224  * argument is returned.  If the maximum size limits the copy, then the
    225  * result will *not* be null-terminated (JLRU).  A null destination
    226  * returns null; otherwise, the destination argument is returned.
    227  */
    228 
    229 PR_EXTERN(char *)
    230 PL_strncat(char *dst, const char *src, PRUint32 max);
    231 
    232 /*
    233  * PL_strcatn
    234  *
    235  * Appends a copy of the string pointed to by the third argument, to the
    236  * end of the string pointed to by the first.  The second argument specifies
    237  * the maximum size of the destination buffer, including the null termination.
    238  * If the existing string in dst is longer than the max, no action is taken.
    239  * The resulting string will be null-terminated.  A null destination returns
    240  * null; otherwise, the destination argument is returned.
    241  */
    242 
    243 PR_EXTERN(char *)
    244 PL_strcatn(char *dst, PRUint32 max, const char *src);
    245178
    246179/*
    … …  
    295228
    296229/*
    297  * PL_strchr
    298  *
    299  * Returns a pointer to the first instance of the specified character in the
    300  * provided string.  It returns null if the character is not found, or if the
    301  * provided string is null.  The character may be the null character.
    302  */
    303 
    304 PR_EXTERN(char *)
    305 PL_strchr(const char *s, char c);
    306 
    307 /*
    308230 * PL_strrchr
    309231 *
    … …  
    317239
    318240/*
    319  * PL_strnchr
    320  *
    321  * Returns a pointer to the first instance of the specified character within the
    322  * first n characters of the provided string.  It returns null if the character
    323  * is not found, or if the provided string is null.  The character may be the
    324  * null character.
    325  */
    326 
    327 PR_EXTERN(char *)
    328 PL_strnchr(const char *s, char c, PRUint32 n);
    329 
    330 /*
    331  * PL_strnrchr
    332  *
    333  * Returns a pointer to the last instance of the specified character within the
    334  * first n characters of the provided string.  It returns null if the character is
    335  * not found, or if the provided string is null.  The character may be the null
    336  * character.
    337  */
    338 
    339 PR_EXTERN(char *)
    340 PL_strnrchr(const char *s, char c, PRUint32 n);
    341 
    342 /*
    343241 * NOTE: Looking for strcasechr, strcaserchr, strncasechr, or strncaserchr?
    344242 * Use strpbrk, strprbrk, strnpbrk or strnprbrk.
    … …  
    357255
    358256/*
    359  * PL_strprbrk
    360  *
    361  * Returns a pointer to the last instance in the first string of any character
    362  * (not including the terminating null character) of the second string.  It returns
    363  * null if either string is null.
    364  */
    365 
    366 PR_EXTERN(char *)
    367 PL_strprbrk(const char *s, const char *list);
    368 
    369 /*
    370  * PL_strnpbrk
    371  *
    372  * Returns a pointer to the first instance (within the first n characters) of any
    373  * character (not including the terminating null character) of the second string.
    374  * It returns null if either string is null.
    375  */
    376 
    377 PR_EXTERN(char *)
    378 PL_strnpbrk(const char *s, const char *list, PRUint32 n);
    379 
    380 /*
    381  * PL_strnprbrk
    382  *
    383  * Returns a pointer to the last instance (within the first n characters) of any
    384  * character (not including the terminating null character) of the second string.
    385  * It returns null if either string is null.
    386  */
    387 
    388 PR_EXTERN(char *)
    389 PL_strnprbrk(const char *s, const char *list, PRUint32 n);
    390 
    391 /*
    392  * PL_strstr
    393  *
    394  * Returns a pointer to the first instance of the little string within the
    395  * big one.  It returns null if either string is null.
    396  */
    397 
    398 PR_EXTERN(char *)
    399 PL_strstr(const char *big, const char *little);
    400 
    401 /*
    402257 * PL_strrstr
    403258 *
    … …  
    421276
    422277/*
    423  * PL_strnrstr
    424  *
    425  * Returns a pointer to the last instance of the little string within the first
    426  * n characters of the big one.  It returns null if either string is null.  It
    427  * returns null if the length of the little string is greater than n.
    428  */
    429 
    430 PR_EXTERN(char *)
    431 PL_strnrstr(const char *big, const char *little, PRUint32 max);
    432 
    433 /*
    434278 * PL_strcasestr
    435279 *
    … …  
    440284PR_EXTERN(char *)
    441285PL_strcasestr(const char *big, const char *little);
    442 
    443 /*
    444  * PL_strcaserstr
    445  *
    446  * Returns a pointer to the last instance of the little string within the big one,
    447  * ignoring case.  It returns null if either string is null.
    448  */
    449 
    450 PR_EXTERN(char *)
    451 PL_strcaserstr(const char *big, const char *little);
    452 
    453 /*
    454  * PL_strncasestr
    455  *
    456  * Returns a pointer to the first instance of the listtle string within the first
    457  * n characters of the big one, ignoring case.  It returns null if either string is
    458  * null.  It returns null if the length of the little string is greater than n.
    459  */
    460 
    461 PR_EXTERN(char *)
    462 PL_strncasestr(const char *big, const char *little, PRUint32 max);
    463 
    464 /*
    465  * PL_strncaserstr
    466  *
    467  * Returns a pointer to the last instance of the little string within the first
    468  * n characters of the big one, ignoring case.  It returns null if either string is
    469  * null.  It returns null if the length of the little string is greater than n.
    470  */
    471 
    472 PR_EXTERN(char *)
    473 PL_strncaserstr(const char *big, const char *little, PRUint32 max);
    474 
    475 /*
    476  * PL_strtok_r
    477  *
    478  * Splits the string s1 into tokens, separated by one or more characters
    479  * from the separator string s2.  The argument lasts points to a
    480  * user-supplied char * pointer in which PL_strtok_r stores information
    481  * for it to continue scanning the same string.
    482  *
    483  * In the first call to PL_strtok_r, s1 points to a string and the value
    484  * of *lasts is ignored.  PL_strtok_r returns a pointer to the first
    485  * token, writes '\0' into the character following the first token, and
    486  * updates *lasts.
    487  *
    488  * In subsequent calls, s1 is null and lasts must stay unchanged from the
    489  * previous call.  The separator string s2 may be different from call to
    490  * call.  PL_strtok_r returns a pointer to the next token in s1.  When no
    491  * token remains in s1, PL_strtok_r returns null.
    492  */
    493 
    494 PR_EXTERN(char *)
    495 PL_strtok_r(char *s1, const char *s2, char **lasts);
    496286
    497287/*

  • trunk/src/libs/xpcom18a4/nsprpub/lib/libc/src/strchr.c

    r1 r101764  
    4040
    4141PR_IMPLEMENT(char *)
    42 PL_strchr(const char *s, char c)
    43 {
    44     if( (const char *)0 == s ) return (char *)0;
    45 
    46     return strchr(s, c);
    47 }
    48 
    49 PR_IMPLEMENT(char *)
    5042PL_strrchr(const char *s, char c)
    5143{
    … …  
    5446    return strrchr(s, c);
    5547}
    56 
    57 PR_IMPLEMENT(char *)
    58 PL_strnchr(const char *s, char c, PRUint32 n)
    59 {
    60     if( (const char *)0 == s ) return (char *)0;
    61 
    62     for( ; n && *s; s++, n-- )
    63         if( *s == c )
    64             return (char *)s;
    65 
    66     if( ((char)0 == c) && (n > 0) && ((char)0 == *s) ) return (char *)s;
    67 
    68     return (char *)0;
    69 }
    70 
    71 PR_IMPLEMENT(char *)
    72 PL_strnrchr(const char *s, char c, PRUint32 n)
    73 {
    74     const char *p;
    75 
    76     if( (const char *)0 == s ) return (char *)0;
    77 
    78     for( p = s; n && *p; p++, n-- )
    79         ;
    80 
    81     if( ((char)0 == c) && (n > 0) && ((char)0 == *p) ) return (char *)p;
    82 
    83     for( p--; p >= s; p-- )
    84         if( *p == c )
    85             return (char *)p;
    86 
    87     return (char *)0;
    88 }

  • trunk/src/libs/xpcom18a4/nsprpub/lib/libc/src/strcpy.c

    r1 r101764  
    4040
    4141PR_IMPLEMENT(char *)
    42 PL_strcpy(char *dest, const char *src)
    43 {
    44     if( ((char *)0 == dest) || ((const char *)0 == src) ) return (char *)0;
    45 
    46     return strcpy(dest, src);
    47 }
    48 
    49 PR_IMPLEMENT(char *)
    5042PL_strncpy(char *dest, const char *src, PRUint32 max)
    5143{

  • trunk/src/libs/xpcom18a4/nsprpub/lib/libc/src/strcstr.c

    r1 r101764  
    5555    return (char *)0;
    5656}
    57 
    58 PR_IMPLEMENT(char *)
    59 PL_strcaserstr(const char *big, const char *little)
    60 {
    61     const char *p;
    62     PRUint32 ll;
    63 
    64     if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
    65     if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
    66 
    67     ll = PL_strlen(little);
    68     p = &big[ PL_strlen(big) - ll ];
    69     if( p < big ) return (char *)0;
    70 
    71     for( ; p >= big; p-- )
    72         /* obvious improvement available here */
    73             if( 0 == PL_strncasecmp(p, little, ll) )
    74                 return (char *)p;
    75 
    76     return (char *)0;
    77 }
    78 
    79 PR_IMPLEMENT(char *)
    80 PL_strncasestr(const char *big, const char *little, PRUint32 max)
    81 {
    82     PRUint32 ll;
    83 
    84     if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
    85     if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
    86 
    87     ll = PL_strlen(little);
    88     if( ll > max ) return (char *)0;
    89     max -= ll;
    90     max++;
    91 
    92     for( ; max && *big; big++, max-- )
    93         /* obvious improvement available here */
    94             if( 0 == PL_strncasecmp(big, little, ll) )
    95                 return (char *)big;
    96 
    97     return (char *)0;
    98 }
    99 
    100 PR_IMPLEMENT(char *)
    101 PL_strncaserstr(const char *big, const char *little, PRUint32 max)
    102 {
    103     const char *p;
    104     PRUint32 ll;
    105 
    106     if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
    107     if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
    108 
    109     ll = PL_strlen(little);
    110 
    111     for( p = big; max && *p; p++, max-- )
    112         ;
    113 
    114     p -= ll;
    115     if( p < big ) return (char *)0;
    116 
    117     for( ; p >= big; p-- )
    118         /* obvious improvement available here */
    119             if( 0 == PL_strncasecmp(p, little, ll) )
    120                 return (char *)p;
    121 
    122     return (char *)0;
    123 }

  • trunk/src/libs/xpcom18a4/nsprpub/lib/libc/src/strpbrk.c

    r1 r101764  
    4646    return strpbrk(s, list);
    4747}
    48 
    49 PR_IMPLEMENT(char *)
    50 PL_strprbrk(const char *s, const char *list)
    51 {
    52     const char *p;
    53     const char *r;
    54 
    55     if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
    56 
    57     for( r = s; *r; r++ )
    58         ;
    59 
    60     for( r--; r >= s; r-- )
    61         for( p = list; *p; p++ )
    62             if( *r == *p )
    63                 return (char *)r;
    64 
    65     return (char *)0;
    66 }
    67 
    68 PR_IMPLEMENT(char *)
    69 PL_strnpbrk(const char *s, const char *list, PRUint32 max)
    70 {
    71     const char *p;
    72 
    73     if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
    74 
    75     for( ; max && *s; s++, max-- )
    76         for( p = list; *p; p++ )
    77             if( *s == *p )
    78                 return (char *)s;
    79 
    80     return (char *)0;
    81 }
    82 
    83 PR_IMPLEMENT(char *)
    84 PL_strnprbrk(const char *s, const char *list, PRUint32 max)
    85 {
    86     const char *p;
    87     const char *r;
    88 
    89     if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
    90 
    91     for( r = s; max && *r; r++, max-- )
    92         ;
    93 
    94     for( r--; r >= s; r-- )
    95         for( p = list; *p; p++ )
    96             if( *r == *p )
    97                 return (char *)r;
    98 
    99     return (char *)0;
    100 }

  • trunk/src/libs/xpcom18a4/nsprpub/lib/libc/src/strstr.c

    r1 r101764  
    3838#include "plstr.h"
    3939#include <string.h>
    40 
    41 PR_IMPLEMENT(char *)
    42 PL_strstr(const char *big, const char *little)
    43 {
    44     if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
    45     if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
    46 
    47     return strstr(big, little);
    48 }
    4940
    5041PR_IMPLEMENT(char *)
    … …  
    9182    return (char *)0;
    9283}
    93 
    94 PR_IMPLEMENT(char *)
    95 PL_strnrstr(const char *big, const char *little, PRUint32 max)
    96 {
    97     const char *p;
    98     size_t ll;
    99 
    100     if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
    101     if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
    102 
    103     ll = strlen(little);
    104 
    105     for( p = big; max && *p; p++, max-- )
    106         ;
    107 
    108     p -= ll;
    109     if( p < big ) return (char *)0;
    110 
    111     for( ; p >= big; p-- )
    112         if( *little == *p )
    113             if( 0 == strncmp(p, little, ll) )
    114                 return (char *)p;
    115 
    116     return (char *)0;
    117 }
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette