Return to case.c CVS log

Up to [Apple XNU] / GNUtools / libg++ / libio / dbz

Annotation of GNUtools/libg++/libio/dbz/case.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * case-mapping stuff
        !             3:  *
        !             4:  * We exploit the fact that we are dealing only with headers here, and
        !             5:  * headers are limited to the ASCII characters by RFC822.  It is barely
        !             6:  * possible that we might be dealing with a translation into another
        !             7:  * character set, but in particular it's very unlikely for a header
        !             8:  * character to be outside -128..255.
        !             9:  *
        !            10:  * Life would be a whole lot simpler if tolower() could safely and portably
        !            11:  * be applied to any char.
        !            12:  */
        !            13: #include <stdio.h>
        !            14: #include "string.h"
        !            15: #include "case.h"
        !            16: 
        !            17: /* note that case.h knows the value of OFFSET */
        !            18: #define        OFFSET  128             /* avoid trouble with negative chars */
        !            19: #define        MAPSIZE (256+OFFSET)
        !            20: char casemap[MAPSIZE];         /* relies on init to '\0' */
        !            21: static int primed = 0;         /* has casemap been set up? */
        !            22: 
        !            23: /*
        !            24:  - prime - set up case-mapping stuff
        !            25:  */
        !            26: static void
        !            27: prime()
        !            28: {
        !            29:        register char *lp;
        !            30:        register char *up;
        !            31:        register int c;
        !            32:        register int i;
        !            33:        static char lower[] = "abcdefghijklmnopqrstuvwxyz";
        !            34:        static char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        !            35: 
        !            36:        for (lp = lower, up = upper; *lp != '\0'; lp++, up++) {
        !            37:                c = *lp;
        !            38:                casemap[c+OFFSET] = c;
        !            39:                casemap[*up+OFFSET] = c;
        !            40:        }
        !            41:        for (i = 0; i < MAPSIZE; i++)
        !            42:                if (casemap[i] == '\0')
        !            43:                        casemap[i] = (char)(i-OFFSET);
        !            44:        primed = 1;
        !            45: }
        !            46: 
        !            47: /*
        !            48:  - cistrncmp - case-independent strncmp
        !            49:  */
        !            50: int                            /* < == > 0 */
        !            51: cistrncmp(s1, s2, len)
        !            52: char *s1;
        !            53: char *s2;
        !            54: int len;
        !            55: {
        !            56:        register char *p1;
        !            57:        register char *p2;
        !            58:        register int n;
        !            59: 
        !            60:        if (!primed)
        !            61:                prime();
        !            62: 
        !            63:        p1 = s1;
        !            64:        p2 = s2;
        !            65:        n = len;
        !            66:        while (--n >= 0 && *p1 != '\0' && TOLOW(*p1) == TOLOW(*p2)) {
        !            67:                p1++;
        !            68:                p2++;
        !            69:        }
        !            70:        if (n < 0)
        !            71:                return(0);
        !            72: 
        !            73:        /*
        !            74:         * The following case analysis is necessary so that characters
        !            75:         * which look negative collate low against normal characters but
        !            76:         * high against the end-of-string NUL.
        !            77:         */
        !            78:        if (*p1 == '\0' && *p2 == '\0')
        !            79:                return(0);
        !            80:        else if (*p1 == '\0')
        !            81:                return(-1);
        !            82:        else if (*p2 == '\0')
        !            83:                return(1);
        !            84:        else
        !            85:                return(TOLOW(*p1) - TOLOW(*p2));
        !            86: }
        !            87: 
        !            88: /*
        !            89:  - rfc822ize - do the bizarre case conversion needed for rfc822 message-ids
        !            90:  *
        !            91:  * Actually, this is not quite complete.  Absolute, total, full RFC822
        !            92:  * compliance requires a horrible parsing job, because of the arcane
        !            93:  * quoting conventions -- abc"def"ghi is not equivalent to abc"DEF"ghi,
        !            94:  * for example.  There are three or four things that might occur in the
        !            95:  * domain part of a message-id that are case-sensitive.  They don't seem
        !            96:  * to ever occur in real news, thank Cthulhu.  (What?  You were expecting
        !            97:  * a merciful and forgiving deity to be invoked in connection with RFC822?
        !            98:  * Forget it; none of them would come near it.)
        !            99:  */
        !           100: char *                         /* returns the argument */
        !           101: rfc822ize(s)
        !           102: char *s;
        !           103: {
        !           104:        register char *p;
        !           105:        static char post[] = "postmaster";
        !           106:        static int postlen = sizeof(post)-1;
        !           107: 
        !           108:        if (!primed)
        !           109:                prime();
        !           110: 
        !           111:        p = strrchr(s, '@');
        !           112:        if (p == NULL)                  /* no local/domain split */
        !           113:                p = "";                 /* assume all local */
        !           114:        else if (p - (s+1) == postlen && CISTREQN(s+1, post, postlen)) {
        !           115:                /* crazy special case -- "postmaster" is case-insensitive */
        !           116:                p = s;
        !           117:        }
        !           118: #ifdef NONSTANDARD
        !           119: #ifdef RFCVIOLATION
        !           120: #ifdef B_2_11_MISTAKE
        !           121:        p = s;                          /* all case-insensitive */
        !           122: #endif
        !           123: #endif
        !           124: #endif
        !           125:        for (; *p != '\0'; p++)
        !           126:                *p = TOLOW(*p);
        !           127: 
        !           128:        return(s);
        !           129: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.