![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to head.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / rn|
Return to head.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / rn |
1.1 root 1: /* $Header: head.c,v 4.3.1.2 85/05/10 13:47:25 lwall Exp $
2: *
3: * $Log: head.c,v $
4: * Revision 4.3.1.2 85/05/10 13:47:25 lwall
5: * Added debugging stuff.
6: *
7: * Revision 4.3.1.1 85/05/10 11:32:30 lwall
8: * Branch for patches.
9: *
10: * Revision 4.3 85/05/01 11:38:21 lwall
11: * Baseline for release with 4.3bsd.
12: *
13: */
14:
15: #include "EXTERN.h"
16: #include "common.h"
17: #include "artio.h"
18: #include "bits.h"
19: #include "util.h"
20: #include "INTERN.h"
21: #include "head.h"
22:
23: bool first_one; /* is this the 1st occurance of this header line? */
24:
25: static char htypeix[26] =
26: {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
27:
28: void
29: head_init()
30: {
31: register int i;
32:
33: for (i=HEAD_FIRST+1; i<HEAD_LAST; i++)
34: htypeix[*htype[i].ht_name - 'a'] = i;
35: }
36:
37: #ifdef DEBUGGING
38: dumpheader(where)
39: char *where;
40: {
41: register int i;
42:
43: printf("header: %d %s", parsed_art, where);
44:
45: for (i=0; i<HEAD_LAST; i++) {
46: printf("%15s %4d %4d %03o\n",htype[i].ht_name,
47: htype[i].ht_minpos,
48: htype[i].ht_maxpos,
49: htype[i].ht_flags) FLUSH;
50: }
51: }
52: #endif
53:
54: int
55: set_line_type(bufptr,colon)
56: char *bufptr;
57: register char *colon;
58: {
59: char lc[LONGKEY+3];
60: register char *t, *f;
61: register int i, len;
62:
63: for (t=lc,f=bufptr; f<colon; f++, t++) {
64: if (isspace(*f))
65: /* guard against space before : */
66: break;
67: *t = isupper(*f) ? tolower(*f) : *f;
68: }
69: *t = '\0';
70: f = lc; /* get lc into register */
71: len = t - f;
72:
73: /* now scan the headtype table, backwards so we don't have to supply an
74: * extra terminating value, using first letter as index, and length as
75: * optimization to avoid calling subroutine strEQ unnecessarily. Hauls.
76: */
77:
78: if (islower(*f)) {
79: for (i = htypeix[*f - 'a']; *htype[i].ht_name == *f; --i) {
80: if (len == htype[i].ht_length && strEQ(f, htype[i].ht_name)) {
81: return i;
82: }
83: }
84: }
85: return SOME_LINE;
86: }
87:
88: void
89: start_header(artnum)
90: ART_NUM artnum;
91: {
92: register int i;
93:
94: #ifdef DEBUGGING
95: if (debug & 4)
96: dumpheader("start_header\n");
97: #endif
98: for (i=0; i<HEAD_LAST; i++) {
99: htype[i].ht_minpos = -1;
100: htype[i].ht_maxpos = 0;
101: }
102: in_header = SOME_LINE;
103: first_one = FALSE;
104: #ifdef ASYNC_PARSE
105: parsed_art = artnum;
106: #endif
107: }
108:
109: bool
110: parseline(art_buf,newhide,oldhide)
111: char *art_buf;
112: int newhide, oldhide;
113: {
114: if (*art_buf == ' ' || *art_buf == '\t')
115: /* header continuation line? */
116: return oldhide;
117: else { /* maybe another header line */
118: char *s;
119:
120: if (first_one) { /* did we just pass 1st occurance? */
121: first_one = FALSE;
122: htype[in_header].ht_maxpos = artpos;
123: /* remember where line left off */
124: }
125: s = index(art_buf,':');
126: if (s == Nullch || s-art_buf > LONGKEY+2) {
127: /* is it the end of the header? */
128: htype[PAST_HEADER].ht_minpos =
129: (*art_buf == '\n') ? ftell(artfp) : artpos;
130: /* remember where body starts */
131: in_header = PAST_HEADER;
132: }
133: else { /* it is a new header line */
134: in_header = set_line_type(art_buf,s);
135: first_one = (htype[in_header].ht_minpos < 0);
136: if (first_one)
137: htype[in_header].ht_minpos = artpos;
138: #ifdef DEBUGGING
139: if (debug & 4)
140: dumpheader(art_buf);
141: #endif
142: if (htype[in_header].ht_flags & HT_HIDE)
143: return newhide;
144: }
145: }
146: return FALSE; /* don't hide this line */
147: }
148:
149: #ifdef ASYNC_PARSE
150: int
151: parse_maybe(artnum)
152: ART_NUM artnum;
153: {
154: char tmpbuf[LBUFLEN];
155:
156: if (parsed_art == artnum)
157: return 0;
158: /* no maybe about it now */
159: if (artopen(artnum) == Nullfp) {
160: return -1;
161: }
162: start_header(artnum);
163: while (in_header) {
164: artpos = ftell(artfp);
165: if (fgets(tmpbuf,LBUFLEN,artfp) == Nullch)
166: break;
167: parseline(tmpbuf,FALSE,FALSE);
168: }
169: in_header = PAST_HEADER;
170: return 0;
171: }
172: #endif
173:
174: /* get the subject line for an article */
175:
176: char *
177: fetchsubj(artnum,current_subject,copy)
178: ART_NUM artnum; /* article to get subject from */
179: bool current_subject; /* is it in a parsed header? */
180: bool copy; /* do you want it savestr()ed? */
181: {
182: char *s = Nullch, *t;
183:
184: #ifdef CACHESUBJ
185: if (!subj_list) {
186: register ART_NUM i;
187:
188:
189: #ifndef lint
190: subj_list =
191: (char**)safemalloc((MEM_SIZE)((OFFSET(lastart)+2)*sizeof(char *)));
192: #endif lint
193: for (i=0; i<=OFFSET(lastart); i++)
194: subj_list[i] = Nullch;
195: }
196: if (!artnum || artnum > lastart)
197: s = nullstr;
198: else
199: s = subj_list[OFFSET(artnum)];
200: #endif
201: if (s == Nullch) {
202: if (current_subject) {
203: s = fetchlines(artnum,SUBJ_LINE);
204: #ifdef CACHESUBJ
205: subj_list[OFFSET(artnum)] = s;
206: #endif
207: }
208: else {
209: s = safemalloc((MEM_SIZE)256);
210: *s = '\0';
211: if (artopen(artnum) != Nullfp) {
212: do {
213: if (fgets(s,256,artfp) == Nullch)
214: strcpy(s, "Title: \n");
215: } while (strnNE(s,"Title:",6) && strnNE(s,"Subject:",8));
216: s[strlen(s)-1] = '\0';
217: t = index(s,':')+1;
218: while (*t == ' ') t++;
219: strcpy(s, t);
220: }
221: s = saferealloc(s, (MEM_SIZE)strlen(s)+1);
222: #ifdef CACHESUBJ
223: subj_list[OFFSET(artnum)] = s;
224: #endif
225: }
226: }
227: #ifdef CACHESUBJ
228: if (copy) {
229: t = savestr(s);
230: return t;
231: }
232: else
233: return s;
234: #else
235: if (copy)
236: return s;
237: else {
238: safecpy(cmd_buf,s,CBUFLEN); /* hope this is okay--we're */
239: free(s);
240: return cmd_buf; /* really scraping for space here */
241: }
242: #endif
243: }
244:
245: /* get header lines from an article */
246:
247: char *
248: fetchlines(artnum,which_line)
249: ART_NUM artnum; /* article to get line from */
250: int which_line; /* type of line desired */
251: {
252: char *newbuf, *t, tmp_buf[LBUFLEN];
253: register ART_POS curpos;
254: int size;
255: register ART_POS firstpos;
256: register ART_POS lastpos;
257:
258: #ifdef ASYNC_PARSE
259: if (parse_maybe(artnum))
260: artnum = 0;
261: #endif
262: firstpos = htype[which_line].ht_minpos;
263: lastpos = htype[which_line].ht_maxpos;
264: if (!artnum || firstpos < 0 || artopen(artnum) == Nullfp) {
265: newbuf = safemalloc((unsigned int)1);
266: *newbuf = '\0';
267: return newbuf;
268: }
269: #ifndef lint
270: size = lastpos - firstpos + 1;
271: #else
272: size = Null(int);
273: #endif lint
274: #ifdef DEBUGGING
275: if (debug && (size < 1 || size > 1000)) {
276: printf("Firstpos = %ld, lastpos = %ld\n",(long)firstpos,(long)lastpos);
277: gets(tmp_buf);
278: }
279: #endif
280: newbuf = safemalloc((unsigned int)size);
281: *newbuf = '\0';
282: fseek(artfp,firstpos,0);
283: for (curpos = firstpos; curpos < lastpos; curpos = ftell(artfp)) {
284: if (fgets(tmp_buf,LBUFLEN,artfp) == Nullch)
285: break;
286: if (*tmp_buf == ' ' || *tmp_buf == '\t')
287: t = tmp_buf;
288: else
289: t = index(tmp_buf,':')+1;
290: if (t == Nullch)
291: break;
292: else {
293: while (*t == ' ' || *t == '\t') t++;
294: safecat(newbuf,t,size);
295: }
296: }
297: return newbuf;
298: }
299:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.