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