⟦81ed01ab0⟧

TextFile

/* as.c - General Attribute Sequence routines */

#ifndef lint
static char *rcsid = "$Header: /f/osi/dsap/common/RCS/as.c,v 6.0 89/03/18 23:27:21 mrose Rel $";
#endif

/*
 * $Header: /f/osi/dsap/common/RCS/as.c,v 6.0 89/03/18 23:27:21 mrose Rel $
 *
 *
 * $Log:	as.c,v $
 * Revision 6.0  89/03/18  23:27:21  mrose
 * Release 5.0
 * 
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "quipu/util.h"
#include "quipu/attrvalue.h"

extern LLog * log_dsap;

static Attr_Sequence eptr;
#define foreach(a)       for(eptr = a; eptr != NULLATTR; eptr=eptr->attr_link)

as_comp_free (as)
Attr_Sequence as;
{
	AttrT_free (as->attr_type);
	avs_free (as->attr_value);
	/* acl_info_free (as->attr_acl); */
	free ((char *) as);
}

as_free (as)
Attr_Sequence as;
{
	foreach (as) {
		as_comp_free (eptr);
		}
}

Attr_Sequence  as_comp_new (at,as,acl)
AttributeType  at;
AV_Sequence    as;
struct acl_info * acl;
{
Attr_Sequence ptr;
	ptr = as_comp_alloc ();
	as_comp_fill (ptr,at,as,acl);
	ptr->attr_link = NULLATTR;
	return (ptr);
}

as_decode (x)
Attr_Sequence x;
{
	foreach (x) {
		AttrT_decode (eptr->attr_type);
		avs_decode (eptr->attr_type,eptr->attr_value);
	}
}


Attr_Sequence as_merge (a,b)
Attr_Sequence a,b;
{
register Attr_Sequence aptr, bptr, result, trail;

	if ( a == NULLATTR )
		return (b);
	if ( b == NULLATTR )
		return (a);

	/* start sequence off, make sure 'a' is the first */
	switch (AttrT_cmp (a->attr_type,b->attr_type)) {
		case 0: /* equal */
			result = a;
			a->attr_value = avs_merge (a->attr_value, b->attr_value);
			aptr = a->attr_link;
			bptr = b->attr_link;
			AttrT_free (b->attr_type);
			free ((char *) b);
			break;
		case -1:
			result = b;
			aptr = a;
			bptr = b->attr_link;
			break;
		case 1:
			result = a;
			aptr = a->attr_link;
			bptr = b;
			break;
		}

	trail = result;
	while (  (aptr != NULLATTR) && (bptr != NULLATTR) ) {

	   switch (AttrT_cmp (aptr->attr_type,bptr->attr_type)) {
		case 0: /* equal */
			aptr->attr_value = avs_merge (aptr->attr_value, bptr->attr_value);
			AttrT_free (bptr->attr_type);
			free ((char *) bptr);
			trail->attr_link = aptr;
			trail = aptr;
			aptr = aptr->attr_link;
			bptr = bptr->attr_link;
			break;
		case -1:
			trail->attr_link = bptr;
			trail = bptr;
			bptr = bptr->attr_link;
			break;
		case 1:
			trail->attr_link = aptr;
			trail = aptr;
			aptr = aptr->attr_link;
			break;
	    }
	}
	if (aptr == NULLATTR)
		trail->attr_link = bptr;
	else
		trail->attr_link = aptr;

	return (result);
}

as_delnext (as)
Attr_Sequence  as;
{
Attr_Sequence ptr;

	if (as == NULLATTR)
		DLOG (log_dsap,LLOG_DEBUG,("delnext of null as!"));
	else    {
		ptr = as->attr_link;
		if (ptr == NULLATTR)
			DLOG (log_dsap,LLOG_DEBUG,("no new as to delete!"));
		else    {
			as->attr_link = ptr->attr_link;
			as_comp_free (ptr);
			}
		}
}

Attr_Sequence  as_comp_cpy (as)
Attr_Sequence  as;
{
Attr_Sequence ptr;
	if (as==NULLATTR) {
		DLOG (log_dsap,LLOG_DEBUG,("copy of null as"));
		return (NULLATTR);
	}
	ptr = (Attr_Sequence) smalloc (sizeof(attrcomp));
	ptr->attr_type = AttrT_cpy (as->attr_type);
	ptr->attr_value = avs_cpy  (as->attr_value);
	ptr->attr_link = NULLATTR;
	ptr->attr_acl = NULLACL_INFO;

	return (ptr);
}

Attr_Sequence  as_cpy (as)
Attr_Sequence  as;
{
Attr_Sequence start;
Attr_Sequence ptr,ptr2;

	if (as == NULLATTR) {
		DLOG (log_dsap,LLOG_DEBUG,("as_cpy of null as"));
		return (NULLATTR);
	}
	start = as_comp_cpy (as);
	ptr2 = start;
	foreach (as->attr_link) {
		ptr = as_comp_cpy (eptr);
		ptr2->attr_link = ptr;
		ptr2 = ptr;
	}
	return (start);
}

as_cmp_comp (a,b)
Attr_Sequence  a,b;
{
int i;
	if (( i= AttrT_cmp (a->attr_type,b->attr_type)) != 0)
		return (i);

	return (avs_cmp (a->attr_value,b->attr_value));
}

as_cmp (a,b)
Attr_Sequence  a,b;
{
int i;
	for (; (a != NULLATTR) && (b != NULLATTR) ; a = a->attr_link, b = b->attr_link)
		if ( (i =as_cmp_comp (a,b)) != 0)
			return (i);

	if ( (a == NULLATTR) && (b == NULLATTR) )
		return (0);
	else
		return (a ? 1  : -1);

}

Attr_Sequence as_find_type (a,b)
Attr_Sequence a;
AttributeType b;
{
register int i;
register Attr_Sequence ptr;
	/* if Attr_cmp returns <0 no point in continuing due to ordering */

	for(ptr = a; ptr != NULLATTR; ptr=ptr->attr_link) {
		if (  (i = AttrT_cmp (ptr->attr_type,b)) <= 0)
			return (i ? NULLATTR : ptr);
	}
	return (NULLATTR);
}


as_comp_print (ps,as,format)
PS   ps;
Attr_Sequence  as;
int  format;
{
AV_Sequence avs;
char buffer [LINESIZE];
extern int oidformat;

	if (as!=NULLATTR) {
		switch (format) {
			case EDBOUT:
				AttrT_print (ps,as->attr_type,format);
				ps_print (ps,"= ");
				avs_print (ps,as->attr_value,format);
				break;

			case READOUT:
				if (as->attr_type->at_table == NULLTABLE_ATTR)
					AttrT_decode(as->attr_type);

				if (as->attr_type->at_table == NULLTABLE_ATTR) 
					/* can't decode */
					(void) sprintf (buffer,"%s",oid2name (as->attr_type->at_oid,oidformat));
				else {
					(void) sprintf (buffer,"%s",attr2name (as->attr_type->at_table,oidformat));
					if (as->attr_type->at_table->oa_syntax == AV_OBJECTCLASS) {
						ps_printf (ps, "%-21s - ", buffer);
						oc_print (ps,as->attr_value,format);
						ps_print (ps,"\n");
						return;
					}

				}

				for (avs = as->attr_value; avs != NULLAV; avs = avs->avseq_next) {
					ps_printf (ps, "%-21s - ", buffer);
					avs_comp_print (ps, avs, format);
					ps_print (ps, "\n");
				}
				break;
		}

	}
}

as_print (ps,as,format)
Attr_Sequence  as;
PS   ps;
int  format;
{

	if ( as != NULLATTR )
		foreach (as)
			as_comp_print (ps,eptr,format);

}

Attr_Sequence str2as (str)
register char * str;
{
register char * ptr;
char * save, val;
AttributeType at;
AV_Sequence avs;

	if (str == NULLCP)
		return (NULLATTR);

	if ((ptr = index (str,'=')) == 0) {
		parse_error ("equals missing %s",str);
		return (NULLATTR);
	}

	save = ptr++;
	if (! isspace (*--save))
		save++;

	val = *save;
	*save = 0;
	
	if ((at = AttrT_new (str)) == NULLAttrT) {
		parse_error ("unknown attribute type '%s'",str);
		*ptr = '=';
		return (NULLATTR);
	}

	*save = val;

	if ((avs = str2avs (ptr,at)) == NULLAV) {
		AttrT_free (at);
		return (NULLATTR);
	}

	return (as_comp_new (at,avs,NULLACL_INFO));

}
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦81ed01ab0⟧ TextFile

Derivation

TextFile
