![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m_seqnew.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / sbr|
Return to m_seqnew.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / sbr |
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.