[moira.git] / server / qsubs.c

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *
 *	$Log$
 *	Revision 1.5  1988-02-16 16:24:24  mar
 *	sq_save_unique_data and sq_save_unique_string didn't used to
 *	cdr down the queue correctly
 *
 * Revision 1.5  88/02/16  15:12:58  mar
 * sq_save_unique_data and sq_save_unique_string didn't used
 * to cdr down the queue correctly.
 * 
 * Revision 1.4  87/08/29  00:04:14  mike
 * added sq_save_unique_string
 * 
 * Revision 1.3  87/08/22  17:44:39  wesommer
 * Cleaning up after mike again.
 * 
 * Revision 1.2  87/06/08  03:08:15  wesommer
 * Reindented; added header.
 * 
 */

#ifndef lint
static char *rcsid_qsubs_c = "$Header$";
#endif lint

#include "query.h"

extern struct query Queries[];
extern int QueryCount;
#ifdef notdef
extern struct s_query S_Queries[];
extern int S_QueryCount;
#endif notdef

struct query *
get_query_by_name(name)
    register char *name;
{
    register struct query *q;
    register int i;

    q = Queries;
    i = QueryCount;

    if (strlen(name) == 4) {
	while (--i >= 0) {
	    if (!strcmp(q->shortname, name)) return(q);
	    q++;
	}
    } else {
	while (--i >= 0) {
	    if (!strcmp(q->name, name)) return(q);
	    q++;
	}
    }

    return((struct query *)0);
}

list_queries(action, actarg)
    int (*action)();
    int actarg;
{
  register struct query *q;
  register int i;
  static struct query **squeries = (struct query **)0;
  register struct query **sq;
  char qnames[80];
  char *qnp;
  int qcmp();

  if (squeries == (struct query **)0)
    {
      sq = (struct query **)malloc(QueryCount * sizeof (struct query *));
      squeries = sq;
      q = Queries;
      for (i = QueryCount; --i >= 0; )
	*sq++ = q++;
      qsort(squeries, QueryCount, sizeof (struct query *), qcmp);
    }

  q = Queries;
  sq = squeries;

  qnp = qnames;
  for (i = QueryCount; --i >= 0; sq++) {
      sprintf(qnames, "%s (%s)", (*sq)->name, (*sq)->shortname);
      (*action)(1, &qnp, actarg);
  }
}

help_query(q, action, actarg)
    register struct query *q;
    int (*action)();
    int actarg;
{
    register int argcount;
    register int i;
    char argn[32];
    char qname[80];
    char *argv[32];

    argcount = q->argc;
    if (q->type == UPDATE || q->type == APPEND) argcount += q->vcnt;

    switch (argcount) {
    case 0:
	sprintf(qname, "      %s ()", q->shortname);
	argv[0] = qname;
	(*action)(1, argv, actarg);
	break;

    case 1:
	sprintf(qname, "      %s (%s)", q->shortname, q->fields[0]);
	argv[0] = qname;
	(*action)(1, argv, actarg);
	break;

    case 2:
	sprintf(qname, "      %s (%s, %s)", q->shortname, q->fields[0],
		q->fields[1]);
	argv[0] = qname;
	(*action)(1, argv, actarg);
	break;

    default:
	sprintf(qname, "      %s (%s", q->shortname, q->fields[0]);
	argv[0] = qname;
	argcount--;
	for (i = 1; i < argcount; i++) argv[i] = q->fields[i];
	sprintf(argn, "%s)", q->fields[argcount]);
	argv[argcount] = argn;
	(*action)(argcount+1, argv, actarg);
	break;
    }
}

qcmp(q1, q2)
    struct query **q1;
    struct query **q2;
{
  return(strcmp((*q1)->name, (*q2)->name));
}

get_input_fields(q, argc, argv)
    register struct query *q;
    int *argc;
    char ***argv;
{
    *argv = q->fields;
    *argc = q->argc;
    if (q->type == UPDATE || q->type == APPEND)
	*argc += q->vcnt;
}

get_output_fields(q, argc, argv)
    register struct query *q;
    int *argc;
    char ***argv;
{
    if (q->type == RETRIEVE) {
	*argc = q->vcnt;
	*argv = &q->fields[q->argc];
    } else {
	*argc = 0;
	*argv = (char **)0;
    }
}

char *
get_field(q, argv, name)
    register struct query *q;
    char *argv[];
    char *name;
{
    register char **fp;
    register char *field;
    register int i;

    if (q->type != RETRIEVE) return((char *)0);

    if (*name == '*') name++;
    fp = &q->fields[q->argc];
    for (i = 0; i < q->vcnt; i++)     {
	field = *fp++;
	if (*field == '*') field++;
	if (!strcmp(field, name)) return(argv[i]);
    }
    return((char *)0);
}

put_field(q, argv, name, value)
    register struct query *q;
    char *argv[];
    char *name;
    char *value;
{
    register char **fp;
    register char *field;
    register int i;
    register int n;

    n = q->argc;
    if (q->type == UPDATE || q->type == APPEND) n += q->vcnt;

    if (*name == '*') name++;
    fp = q->fields;
    for (i = 0; i < n; i++) {
	field = *fp++;
	if (*field == '*') field++;
	if (!strcmp(field, name)) {
	    strcpy(argv[i], value);
	    return(0);
	}
    }
    return(-1);
}


/* Generic Queue Routines */

struct save_queue *
sq_create()
{
    register struct save_queue *sq;

    sq = (struct save_queue *)malloc(sizeof (struct save_queue));
    sq->q_next = sq;
    sq->q_prev = sq;
    sq->q_lastget = 0;
    return(sq);
}

sq_save_data(sq, data)
    register struct save_queue *sq;
    char *data;
{
    register struct save_queue *q;

    q = (struct save_queue *)malloc(sizeof (struct save_queue));
    q->q_next = sq;
    q->q_prev = sq->q_prev;
    sq->q_prev->q_next = q;
    sq->q_prev = q;
    q->q_data = data;
}

sq_save_args(argc, argv, sq)
    register struct save_queue *sq;
    register int argc;
    register char *argv[];
{
    register char **argv_copy;
    register int i;
    register int n;

    argv_copy = (char **)malloc(argc * sizeof (char *));
    for (i = 0; i < argc; i++) {
	n = strlen(argv[i]) + 1;
	argv_copy[i] = (char *)malloc(n);
	bcopy(argv[i], argv_copy[i], n);
    }

    sq_save_data(sq, argv_copy);
}

sq_save_unique_data(sq, data)
    register struct save_queue *sq;
    char *data;
{
    register struct save_queue *q;

    for (q = sq->q_next; q != sq; q = q->q_next)
	if (q->q_data == data) return;

    sq_save_data(sq, data);
}

sq_save_unique_string(sq, data)
    register struct save_queue *sq;
    char *data;
{
    register struct save_queue *q;

    for (q = sq->q_next; q != sq; q = q->q_next)
	if (!strcmp(q->q_data, data)) return;

    sq_save_data(sq, data);
}

sq_get_data(sq, data)
    register struct save_queue *sq;
    register char **data;
{
    if (sq->q_lastget == (struct save_queue *)0) {
	sq->q_lastget = sq->q_next;
    } else {
	sq->q_lastget = sq->q_lastget->q_next;
    }

    if (sq->q_lastget == sq) return(0);
    *data = sq->q_lastget->q_data;
    return(1);
}

sq_destroy(sq)
    register struct save_queue *sq;
{
    register struct save_queue *q;

    for (q = sq->q_next; q != sq; q = sq->q_next) {
	sq->q_next = q->q_next;
	free(q);			
    }
    free(sq);
}


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