Start development on 386BSD 0.0

[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / contrib / isode / dsap / common / cilist.c

/* cilist.c - Case Ignore List */

#ifndef	lint
static char *rcsid = "$Header: /f/osi/dsap/common/RCS/cilist.c,v 7.1 91/02/22 09:18:49 mrose Interim $";
#endif

/* 
 * $Header: /f/osi/dsap/common/RCS/cilist.c,v 7.1 91/02/22 09:18:49 mrose Interim $
 *
 *
 * $Log:	cilist.c,v $
 * Revision 7.1  91/02/22  09:18:49  mrose
 * Interim 6.8
 * 
 * Revision 7.0  90/08/24  12:10:42  mrose
 * *** empty log message ***
 * 
 */

/*
 *				  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.
 *
 */


/*
	SYNTAX:
	list = <list_component> | <list_component> '$' <list>
	list_component = [ '{T61}' ] <string>

	EXAMPLE:
		An example $ of a case ignore list $ syntax attribute
*/

/* LINTLIBRARY */

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

static cilistfree (cilist)
struct CIList * cilist;
{
	struct CIList * next;
	for (; cilist != NULLCILIST; cilist = next) {
	        next = cilist->l_next;
		free (cilist->l_str);
		free ( (char *)cilist);
	}
}

static cilistcmp (a,b)
struct CIList * a, *b;
{
int res;

        for (; (a != NULLCILIST) && (b != NULLCILIST) ;
			a = a->l_next, b=b->l_next) 
		if ((res = lexequ (a->l_str, b->l_str)) != 0)
			return (res);

	if ( a != b)
		return ( a > b ? 1 : -1 );
	else
		return (0);
	
}

static struct CIList * cilistcpy (a)
struct CIList * a;
{
struct CIList * b, *c, *result = NULLCILIST;

	c = result; /* to keep lint quiet ! */

        for (; a != NULLCILIST; a = a->l_next) {
	        b = (struct CIList *) smalloc (sizeof (struct CIList));
		b -> l_type = a->l_type;
		b -> l_str = strdup (a->l_str);
		
		if (result == NULLCILIST) 
			result = b;
		else 
			c->l_next = b;
		c = b;
	}

	b->l_next = NULLCILIST;
	return (result);
}

static struct CIList* cilistparse (str)
char * str;
{
struct CIList * result = NULLCILIST;
struct CIList * a, *b;
char * ptr;
char * mark = NULLCP;
char t61_str = FALSE;
extern char t61_flag;
char * octparse ();
char * prtparse ();

   b = result; /* to keep lint quiet */

   if (t61_flag) {
	t61_str = TRUE;
	t61_flag = FALSE;  /* indicate recognition */
   }

   ptr = str = SkipSpace(str);

   while (ptr) {
	mark = NULLCP;
	a = (struct CIList *) smalloc (sizeof (struct CIList));

	if ( (ptr=index (str,'$')) != NULLCP) {
		*ptr-- = 0;
		if (isspace (*ptr)) {
			*ptr = 0;
			mark = ptr;
		}
		ptr++;
	}

	if (*str == 0) {
		parse_error ("Null string not allowed",NULLCP);	
		return NULLCILIST;
	}

	if ((t61_str) || (! check_print_string(str))) {
		a -> l_type = 1;
		if ((a -> l_str = octparse (str)) == NULLCP)
			return (NULLCILIST);
	} else {
		a -> l_str = strdup(str);
		a -> l_type = 2;
	}

	if (result == NULLCILIST) 
		result = a;
	else 
		b->l_next = a;
	b = a;

	t61_str = FALSE;

	if (ptr != NULLCP) {
		*ptr++ = '$';
		if (mark != NULLCP)
			*mark = ' ';
		str = (SkipSpace(ptr));	
		ptr = str;

		if (*ptr++ == '{') {
			if (( str = index (ptr,'}')) == 0) {
	                        parse_error ("close bracket missing '%s'",--ptr);
        	                return (NULLCILIST);
	                }
			*str = 0;
			if (lexequ ("T.61",ptr) != 0) {
				*str = '}';
                                parse_error ("{T.61} expected '%s'",--ptr);
                                return (NULLCILIST);
                        }
			*str++ = '}';
			str = (SkipSpace(str));
			t61_str = TRUE;
		}
	}
   }

   a -> l_next = NULLCILIST ;

   return (result);
}

static cilistprint (ps,cilist,format)
PS ps;
struct CIList * cilist;
int format;
{
char * prefix = NULLCP;

	for (; cilist != NULLCILIST; cilist = cilist->l_next) {
		if (prefix != NULLCP)
			ps_print (ps,prefix);

		if (cilist->l_type == 1) {
			if (format != READOUT)
				ps_print (ps,"{T.61}");
			octprint (ps,cilist->l_str,format);
		} else
			ps_print (ps,cilist->l_str);

		if (format == READOUT)
			prefix = "\n\t\t\t";
		else 
			prefix = " $\\\n\t";
	}
}


static PE cilistenc (m)
struct CIList * m;
{
PE ret_pe;

        (void) encode_SA_CaseIgnoreList (&ret_pe,0,0,NULLCP,m);

	return (ret_pe);
}

static struct CIList * cilistdec (pe)
PE pe;
{
struct CIList * m;

	if (decode_SA_CaseIgnoreList (pe,1,NULLIP,NULLVP,&m) == NOTOK)
		return (NULLCILIST);
	return (m);
}

cilist_syntax ()
{
	(void) add_attribute_syntax ("CaseIgnoreList",
		(IFP) cilistenc,	(IFP) cilistdec,
		(IFP) cilistparse,	cilistprint,
		(IFP) cilistcpy,	cilistcmp,
		cilistfree,	NULLCP,
		NULLIFP,	TRUE);

}