warning-cleanup-20010414
[openafs.git] / src / config / mc.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #define MAXLINELEN      1024
11 #define MAXTOKLEN       100
12 #include <sys/param.h>
13 #include <sys/types.h>
14 #include <sys/file.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17
18 #define TOK_DONTUSE 1 /* Don't copy if match and this flag is set. */
19 struct token {
20     struct token *next;
21     char *key;
22     int flags;
23 };
24
25 /* free token list returned by parseLine */
26 static int FreeTokens(alist)
27     register struct token *alist; {
28     register struct token *nlist;
29     for(; alist; alist = nlist) {
30         nlist = alist->next;
31         free(alist->key);
32         free(alist);
33     }
34     return 0;
35 }
36
37 #define space(x)    ((x) == ' ' || (x) == '\t' || (x) == '<' || (x) == '>')
38 static int ParseLine(aline, alist)
39     char *aline;
40     struct token **alist; {
41     char tbuffer[MAXTOKLEN+1];
42     register char *tptr = NULL;
43     int inToken;
44     struct token *first, *last;
45     register struct token *ttok;
46     register int tc;
47     int dontUse = 0;
48     
49     inToken = 0;        /* not copying token chars at start */
50     first = (struct token *) 0;
51     last = (struct token *) 0;
52     while (1) {
53         tc = *aline++;
54         if (tc == 0 || space(tc)) {    /* terminating null gets us in here, too */
55             if (inToken) {
56                 inToken = 0;    /* end of this token */
57                 if ( !tptr )
58                     return -1; /* should never get here */
59                 else
60                     *tptr++ = 0;
61                 ttok = (struct token *) malloc(sizeof(struct token));
62                 ttok->next = (struct token *) 0;
63                 if (dontUse) {
64                     ttok->key = (char *) malloc(strlen(tbuffer));
65                     strcpy(ttok->key, tbuffer+1);
66                     ttok->flags = TOK_DONTUSE;
67                     dontUse = 0;
68                 }
69                 else {
70                     ttok->key = (char *) malloc(strlen(tbuffer)+1);
71                     strcpy(ttok->key, tbuffer);
72                     ttok->flags = 0;
73                 }
74                 if (last) {
75                     last->next = ttok;
76                     last = ttok;
77                 }
78                 else last = ttok;
79                 if (!first) first = ttok;
80             }
81         }
82         else {
83             /* an alpha character */
84             if (!inToken) {
85                 if (tc == '-') {
86                     dontUse = 1;
87                 }
88                 tptr = tbuffer;
89                 inToken = 1;
90             }
91             if (tptr - tbuffer >= MAXTOKLEN) return -1;   /* token too long */
92             *tptr++ = tc;
93         }
94         if (tc == 0) {
95             /* last token flushed 'cause space(0) --> true */
96             if (last) last->next = (struct token *) 0;
97             *alist = first;
98             return 0;
99         }
100     }
101 }
102 /* read a line into a buffer, putting in null termination and stopping on appropriate
103     end of line char.  Returns 0 at eof, > 0 at normal line end, and < 0 on error */
104 static int GetLine(afile, abuffer, amax)
105     FILE *afile;
106     int amax;
107     register char *abuffer; {
108     register int tc;
109     int first;
110
111     first = 1;
112     while (1) {
113         tc = getc(afile);
114         if (first && tc < 0) return 0;
115         first = 0;
116         if (tc <= 0 || tc == '\012') {
117             if (amax > 0) *abuffer++ = 0;
118             return (amax > 0? 1 : -1);
119         }
120         if (amax > 0) {
121             /* keep reading to end of line so next one isn't bogus */
122             *abuffer++ = tc;
123             amax--;
124         }
125     }
126 }
127
128 int mc_copy(ain, aout, alist)
129     register FILE *ain;
130     register FILE *aout;
131     char *alist[]; {
132     char tbuffer[MAXLINELEN];
133     struct token *tokens;
134     register char **tp;
135     register struct token *tt;
136     register int code;
137     int copying;
138     int done;
139
140     copying = 1;        /* start off copying data */
141     while (1) {
142         /* copy lines, handling modes appropriately */
143         code = GetLine(ain, tbuffer, MAXLINELEN);
144         if (code <= 0) break;
145         /* otherwise process the line */
146         if (tbuffer[0] == '<') {
147             /* interpret the line as a set of options, any one of which will cause us
148                 to start copying the data again. */
149             code = ParseLine(tbuffer, &tokens);
150             if (code != 0) return -1;
151             copying = 0;
152             done = 0;
153             for(tp = alist; (!done) && (*tp != (char *)0) ; tp++) {
154                 for(tt = tokens; tt; tt=tt->next) {
155                     if (!strcmp(*tp, tt->key)) {
156                         /* Need to search all tokens in case a dont use
157                          * flag is set. But we can stop on the first
158                          * don't use.
159                          */
160                         if (tt->flags & TOK_DONTUSE) {
161                             copying = 0;
162                             done = 1;
163                             break;
164                         }
165                         else {
166                             copying = 1;
167                         }
168                     }
169                 }
170             }
171             FreeTokens(tokens);
172         }
173         else {
174             /* just copy the line */
175             if (copying) {
176                 fwrite(tbuffer, 1, strlen(tbuffer), aout);
177                 putc('\n', aout);
178             }
179         }
180     }
181     return 0;
182 }