Return to m_seqnew.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / sbr

Annotation of 43BSDReno/contrib/mh/sbr/m_seqnew.c, revision 1.1

1.1     ! root        1: /* m_seqnew.c - manage sequences */
        !             2: 
        !             3: #include "../h/mh.h"
        !             4: #include <ctype.h>
        !             5: #include <stdio.h>
        !             6: 
        !             7: static int m_seqok();
        !             8: 
        !             9: int
        !            10: m_seqnew(mp, cp, public)
        !            11:        register struct msgs *mp;
        !            12:        register char *cp;
        !            13:        register int public;
        !            14: {
        !            15:     int     bits;
        !            16:     register int    i,
        !            17:                     j;
        !            18: 
        !            19:     if (!m_seqok (cp))
        !            20:        return 0;
        !            21: 
        !            22:     if (public == -1)          /* XXX */
        !            23:        public = mp -> msgflags & READONLY ? 0 : 1;
        !            24: 
        !            25:     bits = FFATTRSLOT;
        !            26:     for (i = 0; mp -> msgattrs[i]; i++)
        !            27:        if (strcmp (mp -> msgattrs[i], cp) == 0) {
        !            28:            for (j = mp -> lowmsg; j <= mp -> hghmsg; j++)
        !            29:                mp -> msgstats[j] &= ~(1 << (bits + i));
        !            30:            if (public)
        !            31:                mp -> attrstats &= ~(1 << (bits + i));
        !            32:            else
        !            33:                mp -> attrstats |= 1 << (bits + i);
        !            34:            mp -> msgflags |= SEQMOD;
        !            35: 
        !            36:            return 1;
        !            37:        }
        !            38: 
        !            39:     if (i >= NATTRS) {
        !            40:        advise (NULLCP, "only %d sequences allowed (no room for %s)!",
        !            41:                NATTRS, cp);
        !            42:        return 0;
        !            43:     }
        !            44: 
        !            45:     mp -> msgattrs[i] = getcpy (cp);
        !            46:     for (j = mp -> lowmsg; j <= mp -> hghmsg; j++)
        !            47:        mp -> msgstats[j] &= ~(1 << (bits + i));
        !            48:     if (public)
        !            49:        mp -> attrstats &= ~(1 << (bits + i));
        !            50:     else
        !            51:        mp -> attrstats |= 1 << (bits + i);
        !            52:     mp -> msgflags |= SEQMOD;
        !            53: 
        !            54:     mp -> msgattrs[++i] = NULL;
        !            55: 
        !            56:     return 1;
        !            57: }
        !            58: 
        !            59: /*  */
        !            60: 
        !            61: int
        !            62: m_seqadd(mp, cp, j, public)
        !            63:        register struct msgs *mp;
        !            64:        register char *cp;
        !            65:        register int j,
        !            66:                 public;
        !            67: {
        !            68:     int     bits;
        !            69:     register int    i,
        !            70:                     k;
        !            71: 
        !            72:     if (!m_seqok (cp))
        !            73:        return 0;
        !            74: 
        !            75:     if (public == -1)          /* XXX */
        !            76:        public = mp -> msgflags & READONLY ? 0 : 1;
        !            77: 
        !            78:     bits = FFATTRSLOT;
        !            79:     for (i = 0; mp -> msgattrs[i]; i++)
        !            80:        if (strcmp (mp -> msgattrs[i], cp) == 0) {
        !            81:            mp -> msgstats[j] |= 1 << (bits + i);
        !            82:            if (public)
        !            83:                mp -> attrstats &= ~(1 << (bits + i));
        !            84:            else
        !            85:                mp -> attrstats |= 1 << (bits + i);
        !            86:            mp -> msgflags |= SEQMOD;
        !            87: 
        !            88:            return 1;
        !            89:        }
        !            90: 
        !            91:     if (i >= NATTRS) {
        !            92:        advise (NULLCP, "only %d sequences allowed (no room for %s)!",
        !            93:                NATTRS, cp);
        !            94:        return 0;
        !            95:     }
        !            96: 
        !            97:     mp -> msgattrs[i] = getcpy (cp);
        !            98:     for (k = mp -> lowmsg; k <= mp -> hghmsg; k++)
        !            99:        mp -> msgstats[k] &= ~(1 << (bits + i));
        !           100:     mp -> msgstats[j] |= 1 << (bits + i);
        !           101:     if (public)
        !           102:        mp -> attrstats &= ~(1 << (bits + i));
        !           103:     else
        !           104:        mp -> attrstats |= 1 << (bits + i);
        !           105:     mp -> msgflags |= SEQMOD;
        !           106: 
        !           107:     mp -> msgattrs[++i] = NULL;
        !           108: 
        !           109:     return 1;
        !           110: }
        !           111: 
        !           112: /*  */
        !           113: 
        !           114: int
        !           115: m_seqdel(mp, cp, j)
        !           116:        register struct msgs *mp;
        !           117:        register char *cp;
        !           118:        register int j;
        !           119: {
        !           120:     int     bits;
        !           121:     register int    i;
        !           122: 
        !           123:     if (!m_seqok (cp))
        !           124:        return 0;
        !           125: 
        !           126:     bits = FFATTRSLOT;
        !           127:     for (i = 0; mp -> msgattrs[i]; i++)
        !           128:        if (strcmp (mp -> msgattrs[i], cp) == 0) {
        !           129:            mp -> msgstats[j] &= ~(1 << (bits + i));
        !           130:            mp -> msgflags |= SEQMOD;
        !           131: 
        !           132:            return 1;
        !           133:        }
        !           134: 
        !           135:     advise (NULLCP, "no such sequence as %s", cp);
        !           136:     return 0;
        !           137: }
        !           138: 
        !           139: /*  */
        !           140: 
        !           141: static int
        !           142: m_seqok(cp)
        !           143:        register char *cp;
        !           144: {
        !           145:     register char  *pp;
        !           146: 
        !           147:     if (cp == NULL || *cp == NULL) {
        !           148:        advise (NULLCP, "empty sequence name");
        !           149:        return 0;
        !           150:     }
        !           151: 
        !           152:     if (strcmp (cp, "new") == 0
        !           153: #ifdef notdef
        !           154:            || strcmp (cp, "cur") == 0
        !           155: #endif notdef
        !           156:            || strcmp (cp, "all") == 0
        !           157:            || strcmp (cp, "first") == 0
        !           158:            || strcmp (cp, "last") == 0
        !           159:            || strcmp (cp, "prev") == 0
        !           160:            || strcmp (cp, "next") == 0) {
        !           161:        advise (NULLCP, "illegal sequence name: %s", cp);
        !           162:        return 0;
        !           163:     }
        !           164: 
        !           165:     if (!isalpha (*cp)) {
        !           166:        advise (NULLCP, "illegal sequence name: %s", cp);
        !           167:        return 0;
        !           168:     }
        !           169:     for (pp = cp + 1; *pp; pp++)
        !           170:        if (!isalnum (*pp)) {
        !           171:            advise (NULLCP, "illegal sequence name: %s", cp);
        !           172:            return 0;
        !           173:        }
        !           174: 
        !           175:     return 1;
        !           176: }

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