]>
Commit | Line | Data |
---|---|---|
3e10560e | 1 | /* |
2 | * $Source$ | |
3 | * $Author$ | |
4 | * $Header$ | |
5 | * | |
6 | * Copyright (C) 1987 by the Massachusetts Institute of Technology | |
7 | * | |
8 | * $Log$ | |
ab70c698 | 9 | * Revision 1.3 1987-08-22 17:44:39 wesommer |
10 | * Cleaning up after mike again. | |
3e10560e | 11 | * |
ab70c698 | 12 | * Revision 1.2 87/06/08 03:08:15 wesommer |
13 | * Reindented; added header. | |
14 | * | |
3e10560e | 15 | */ |
16 | ||
17 | #ifndef lint | |
18 | static char *rcsid_qsubs_c = "$Header$"; | |
19 | #endif lint | |
20 | ||
97479f6f | 21 | #include "query.h" |
22 | ||
23 | extern struct query Queries[]; | |
24 | extern int QueryCount; | |
3e10560e | 25 | #ifdef notdef |
97479f6f | 26 | extern struct s_query S_Queries[]; |
27 | extern int S_QueryCount; | |
3e10560e | 28 | #endif notdef |
97479f6f | 29 | |
30 | struct query * | |
31 | get_query_by_name(name) | |
3e10560e | 32 | register char *name; |
97479f6f | 33 | { |
3e10560e | 34 | register struct query *q; |
35 | register int i; | |
36 | ||
37 | q = Queries; | |
38 | i = QueryCount; | |
39 | ||
40 | if (strlen(name) == 4) { | |
41 | while (--i >= 0) { | |
42 | if (!strcmp(q->shortname, name)) return(q); | |
43 | q++; | |
97479f6f | 44 | } |
3e10560e | 45 | } else { |
46 | while (--i >= 0) { | |
47 | if (!strcmp(q->name, name)) return(q); | |
48 | q++; | |
49 | } | |
50 | } | |
97479f6f | 51 | |
3e10560e | 52 | return((struct query *)0); |
97479f6f | 53 | } |
54 | ||
ab70c698 | 55 | list_queries(action, actarg) |
56 | int (*action)(); | |
57 | int actarg; | |
58 | { | |
59 | register struct query *q; | |
60 | register int i; | |
61 | static struct query **squeries = (struct query **)0; | |
62 | register struct query **sq; | |
63 | char qnames[80]; | |
64 | char *qnp; | |
65 | int qcmp(); | |
66 | ||
67 | if (squeries == (struct query **)0) | |
68 | { | |
69 | sq = (struct query **)malloc(QueryCount * sizeof (struct query *)); | |
70 | squeries = sq; | |
71 | q = Queries; | |
72 | for (i = QueryCount; --i >= 0; ) | |
73 | *sq++ = q++; | |
74 | qsort(squeries, QueryCount, sizeof (struct query *), qcmp); | |
75 | } | |
76 | ||
77 | q = Queries; | |
78 | sq = squeries; | |
79 | ||
80 | qnp = qnames; | |
81 | for (i = QueryCount; --i >= 0; sq++) { | |
82 | sprintf(qnames, "%s (%s)", (*sq)->name, (*sq)->shortname); | |
83 | (*action)(1, &qnp, actarg); | |
84 | } | |
85 | } | |
86 | ||
87 | help_query(q, action, actarg) | |
88 | register struct query *q; | |
89 | int (*action)(); | |
90 | int actarg; | |
91 | { | |
92 | register int argcount; | |
93 | register int i; | |
94 | char argn[32]; | |
95 | char qname[80]; | |
96 | char *argv[32]; | |
97 | ||
98 | argcount = q->argc; | |
99 | if (q->type == UPDATE || q->type == APPEND) argcount += q->vcnt; | |
100 | ||
101 | switch (argcount) { | |
102 | case 0: | |
103 | sprintf(qname, " %s ()", q->shortname); | |
104 | argv[0] = qname; | |
105 | (*action)(1, argv, actarg); | |
106 | break; | |
107 | ||
108 | case 1: | |
109 | sprintf(qname, " %s (%s)", q->shortname, q->fields[0]); | |
110 | argv[0] = qname; | |
111 | (*action)(1, argv, actarg); | |
112 | break; | |
113 | ||
114 | case 2: | |
115 | sprintf(qname, " %s (%s, %s)", q->shortname, q->fields[0], | |
116 | q->fields[1]); | |
117 | argv[0] = qname; | |
118 | (*action)(1, argv, actarg); | |
119 | break; | |
120 | ||
121 | default: | |
122 | sprintf(qname, " %s (%s", q->shortname, q->fields[0]); | |
123 | argv[0] = qname; | |
124 | argcount--; | |
125 | for (i = 1; i < argcount; i++) argv[i] = q->fields[i]; | |
126 | sprintf(argn, "%s)", q->fields[argcount]); | |
127 | argv[argcount] = argn; | |
128 | (*action)(argcount+1, argv, actarg); | |
129 | break; | |
130 | } | |
131 | } | |
132 | ||
133 | qcmp(q1, q2) | |
134 | struct query **q1; | |
135 | struct query **q2; | |
136 | { | |
137 | return(strcmp((*q1)->name, (*q2)->name)); | |
138 | } | |
139 | ||
97479f6f | 140 | get_input_fields(q, argc, argv) |
3e10560e | 141 | register struct query *q; |
142 | int *argc; | |
143 | char ***argv; | |
97479f6f | 144 | { |
3e10560e | 145 | *argv = q->fields; |
ab70c698 | 146 | *argc = q->argc; |
3e10560e | 147 | if (q->type == UPDATE || q->type == APPEND) |
148 | *argc += q->vcnt; | |
97479f6f | 149 | } |
150 | ||
151 | get_output_fields(q, argc, argv) | |
3e10560e | 152 | register struct query *q; |
153 | int *argc; | |
154 | char ***argv; | |
97479f6f | 155 | { |
3e10560e | 156 | if (q->type == RETRIEVE) { |
157 | *argc = q->vcnt; | |
ab70c698 | 158 | *argv = &q->fields[q->argc]; |
3e10560e | 159 | } else { |
160 | *argc = 0; | |
161 | *argv = (char **)0; | |
162 | } | |
97479f6f | 163 | } |
164 | ||
165 | char * | |
166 | get_field(q, argv, name) | |
3e10560e | 167 | register struct query *q; |
168 | char *argv[]; | |
169 | char *name; | |
97479f6f | 170 | { |
3e10560e | 171 | register char **fp; |
172 | register char *field; | |
173 | register int i; | |
174 | ||
175 | if (q->type != RETRIEVE) return((char *)0); | |
176 | ||
177 | if (*name == '*') name++; | |
ab70c698 | 178 | fp = &q->fields[q->argc]; |
3e10560e | 179 | for (i = 0; i < q->vcnt; i++) { |
180 | field = *fp++; | |
181 | if (*field == '*') field++; | |
182 | if (!strcmp(field, name)) return(argv[i]); | |
183 | } | |
184 | return((char *)0); | |
97479f6f | 185 | } |
186 | ||
187 | put_field(q, argv, name, value) | |
3e10560e | 188 | register struct query *q; |
189 | char *argv[]; | |
190 | char *name; | |
191 | char *value; | |
97479f6f | 192 | { |
3e10560e | 193 | register char **fp; |
194 | register char *field; | |
195 | register int i; | |
196 | register int n; | |
197 | ||
ab70c698 | 198 | n = q->argc; |
3e10560e | 199 | if (q->type == UPDATE || q->type == APPEND) n += q->vcnt; |
200 | ||
201 | if (*name == '*') name++; | |
202 | fp = q->fields; | |
203 | for (i = 0; i < n; i++) { | |
204 | field = *fp++; | |
205 | if (*field == '*') field++; | |
206 | if (!strcmp(field, name)) { | |
207 | strcpy(argv[i], value); | |
208 | return(0); | |
97479f6f | 209 | } |
3e10560e | 210 | } |
211 | return(-1); | |
97479f6f | 212 | } |
213 | ||
214 | ||
215 | /* Generic Queue Routines */ | |
216 | ||
217 | struct save_queue * | |
218 | sq_create() | |
219 | { | |
3e10560e | 220 | register struct save_queue *sq; |
97479f6f | 221 | |
3e10560e | 222 | sq = (struct save_queue *)malloc(sizeof (struct save_queue)); |
223 | sq->q_next = sq; | |
224 | sq->q_prev = sq; | |
225 | sq->q_lastget = 0; | |
226 | return(sq); | |
97479f6f | 227 | } |
228 | ||
229 | sq_save_data(sq, data) | |
3e10560e | 230 | register struct save_queue *sq; |
231 | char *data; | |
97479f6f | 232 | { |
3e10560e | 233 | register struct save_queue *q; |
234 | ||
235 | q = (struct save_queue *)malloc(sizeof (struct save_queue)); | |
236 | q->q_next = sq; | |
237 | q->q_prev = sq->q_prev; | |
238 | sq->q_prev->q_next = q; | |
239 | sq->q_prev = q; | |
240 | q->q_data = data; | |
97479f6f | 241 | } |
242 | ||
ab70c698 | 243 | sq_save_args(argc, argv, sq) |
244 | register struct save_queue *sq; | |
245 | register int argc; | |
246 | register char *argv[]; | |
247 | { | |
248 | register char **argv_copy; | |
249 | register int i; | |
250 | register int n; | |
251 | ||
252 | argv_copy = (char **)malloc(argc * sizeof (char *)); | |
253 | for (i = 0; i < argc; i++) { | |
254 | n = strlen(argv[i]) + 1; | |
255 | argv_copy[i] = (char *)malloc(n); | |
256 | bcopy(argv[i], argv_copy[i], n); | |
257 | } | |
258 | ||
259 | sq_save_data(sq, argv_copy); | |
260 | } | |
261 | ||
262 | sq_save_unique_data(sq, data) | |
263 | register struct save_queue *sq; | |
264 | char *data; | |
265 | { | |
266 | register struct save_queue *q; | |
267 | ||
268 | for (q = sq->q_next; q != sq; q = sq->q_next) | |
269 | if (q->q_data == data) return; | |
270 | ||
271 | sq_save_data(sq, data); | |
272 | } | |
273 | ||
97479f6f | 274 | sq_get_data(sq, data) |
3e10560e | 275 | register struct save_queue *sq; |
276 | register char **data; | |
97479f6f | 277 | { |
3e10560e | 278 | if (sq->q_lastget == (struct save_queue *)0) { |
279 | sq->q_lastget = sq->q_next; | |
280 | } else { | |
281 | sq->q_lastget = sq->q_lastget->q_next; | |
282 | } | |
283 | ||
284 | if (sq->q_lastget == sq) return(0); | |
285 | *data = sq->q_lastget->q_data; | |
286 | return(1); | |
97479f6f | 287 | } |
288 | ||
289 | sq_destroy(sq) | |
3e10560e | 290 | register struct save_queue *sq; |
97479f6f | 291 | { |
3e10560e | 292 | register struct save_queue *q; |
97479f6f | 293 | |
3e10560e | 294 | for (q = sq->q_next; q != sq; q = sq->q_next) { |
295 | sq->q_next = q->q_next; | |
296 | free(q); | |
297 | } | |
298 | free(sq); | |
97479f6f | 299 | } |
3e10560e | 300 | |
301 | ||
302 | /* | |
303 | * Local Variables: | |
304 | * mode: c | |
305 | * c-indent-level: 4 | |
306 | * c-continued-statement-offset: 4 | |
307 | * c-brace-offset: -4 | |
308 | * c-argdecl-indent: 4 | |
309 | * c-label-offset: -4 | |
310 | * End: | |
311 | */ |