[net-next-2.6.git] / drivers / net / skfp / smtparse.c

/******************************************************************************
 *
 *	(C)Copyright 1998,1999 SysKonnect,
 *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
 *
 *	See the file "skfddi.c" for further information.
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *
 *	The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/


/*
	parser for SMT parameters
*/

#include "h/types.h"
#include "h/fddi.h"
#include "h/smc.h"
#include "h/smt_p.h"

#define KERNEL
#include "h/smtstate.h"

#ifndef	lint
static const char ID_sccs[] = "@(#)smtparse.c	1.12 98/10/06 (C) SK " ;
#endif

#ifdef	sun
#define _far
#endif

/*
 * convert to BCLK units
 */
#define MS2BCLK(x)      ((x)*12500L)
#define US2BCLK(x)      ((x/10)*125L)

/*
 * parameter table
 */
static struct s_ptab {
	char	*pt_name ;
	u_short	pt_num ;
	u_short	pt_type ;
	u_long	pt_min ;
	u_long	pt_max ;
} ptab[] = {
	{ "PMFPASSWD",0,	0 } ,
	{ "USERDATA",1,		0 } ,
	{ "LERCUTOFFA",2,	1,	4,	15	} ,
	{ "LERCUTOFFB",3,	1,	4,	15	} ,
	{ "LERALARMA",4,	1,	4,	15	} ,
	{ "LERALARMB",5,	1,	4,	15	} ,
	{ "TMAX",6,		1,	5,	165	} ,
	{ "TMIN",7,		1,	5,	165	} ,
	{ "TREQ",8,		1,	5,	165	} ,
	{ "TVX",9,		1,	2500,	10000	} ,
#ifdef ESS
	{ "SBAPAYLOAD",10,	1,	0,	1562	} ,
	{ "SBAOVERHEAD",11,	1,	50,	5000	} ,
	{ "MAXTNEG",12,		1,	5,	165	} ,
	{ "MINSEGMENTSIZE",13,	1,	0,	4478	} ,
	{ "SBACATEGORY",14,	1,	0,	0xffff	} ,
	{ "SYNCHTXMODE",15,	0 } ,
#endif
#ifdef SBA
	{ "SBACOMMAND",16,	0 } ,
	{ "SBAAVAILABLE",17,	1,	0,	100	} ,
#endif
	{ NULL }
} ;

/* Define maximum string size for values and keybuffer */
#define MAX_VAL	40

/*
 * local function declarations
 */
static u_long parse_num(int type, char _far *value, char *v, u_long mn,
			u_long mx, int scale);
static int parse_word(char *buf, char _far *text);

#ifdef SIM
#define DB_MAIN(a,b,c)	printf(a,b,c)
#else
#define DB_MAIN(a,b,c)
#endif

/*
 * BEGIN_MANUAL_ENTRY()
 *
 *	int smt_parse_arg(struct s_smc *,char _far *keyword,int type,
		char _far *value)
 *
 *	parse SMT parameter
 *	*keyword
 *		pointer to keyword, must be \0, \n or \r terminated
 *	*value	pointer to value, either char * or u_long *
 *		if char *
 *			pointer to value, must be \0, \n or \r terminated
 *		if u_long *
 *			contains binary value
 *
 *	type	0: integer
 *		1: string
 *	return
 *		0	parameter parsed ok
 *		!= 0	error
 *	NOTE:
 *		function can be called with DS != SS
 *
 *
 * END_MANUAL_ENTRY()
 */
int smt_parse_arg(struct s_smc *smc, char _far *keyword, int type,
		  char _far *value)
{
	char		keybuf[MAX_VAL+1];
	char		valbuf[MAX_VAL+1];
	char		c ;
	char 		*p ;
	char		*v ;
	char		*d ;
	u_long		val = 0 ;
	struct s_ptab	*pt ;
	int		st ;
	int		i ;

	/*
	 * parse keyword
	 */
	if ((st = parse_word(keybuf,keyword)))
		return(st) ;
	/*
	 * parse value if given as string
	 */
	if (type == 1) {
		if ((st = parse_word(valbuf,value)))
			return(st) ;
	}
	/*
	 * search in table
	 */
	st = 0 ;
	for (pt = ptab ; (v = pt->pt_name) ; pt++) {
		for (p = keybuf ; (c = *p) ; p++,v++) {
			if (c != *v)
				break ;
		}
		if (!c && !*v)
			break ;
	}
	if (!v)
		return(-1) ;
#if	0
	printf("=>%s<==>%s<=\n",pt->pt_name,valbuf) ;
#endif
	/*
	 * set value in MIB
	 */
	if (pt->pt_type)
		val = parse_num(type,value,valbuf,pt->pt_min,pt->pt_max,1) ;
	switch (pt->pt_num) {
	case 0 :
		v = valbuf ;
		d = (char *) smc->mib.fddiPRPMFPasswd ;
		for (i = 0 ; i < (signed)sizeof(smc->mib.fddiPRPMFPasswd) ; i++)
			*d++ = *v++ ;
		DB_MAIN("SET %s = %s\n",pt->pt_name,smc->mib.fddiPRPMFPasswd) ;
		break ;
	case 1 :
		v = valbuf ;
		d = (char *) smc->mib.fddiSMTUserData ;
		for (i = 0 ; i < (signed)sizeof(smc->mib.fddiSMTUserData) ; i++)
			*d++ = *v++ ;
		DB_MAIN("SET %s = %s\n",pt->pt_name,smc->mib.fddiSMTUserData) ;
		break ;
	case 2 :
		smc->mib.p[PA].fddiPORTLer_Cutoff = (u_char) val ;
		DB_MAIN("SET %s = %d\n",
			pt->pt_name,smc->mib.p[PA].fddiPORTLer_Cutoff) ;
		break ;
	case 3 :
		smc->mib.p[PB].fddiPORTLer_Cutoff = (u_char) val ;
		DB_MAIN("SET %s = %d\n",
			pt->pt_name,smc->mib.p[PB].fddiPORTLer_Cutoff) ;
		break ;
	case 4 :
		smc->mib.p[PA].fddiPORTLer_Alarm = (u_char) val ;
		DB_MAIN("SET %s = %d\n",
			pt->pt_name,smc->mib.p[PA].fddiPORTLer_Alarm) ;
		break ;
	case 5 :
		smc->mib.p[PB].fddiPORTLer_Alarm = (u_char) val ;
		DB_MAIN("SET %s = %d\n",
			pt->pt_name,smc->mib.p[PB].fddiPORTLer_Alarm) ;
		break ;
	case 6 :			/* TMAX */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.a[PATH0].fddiPATHT_MaxLowerBound =
			(u_long) -MS2BCLK((long)val) ;
		break ;
	case 7 :			/* TMIN */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.m[MAC0].fddiMACT_Min =
			(u_long) -MS2BCLK((long)val) ;
		break ;
	case 8 :			/* TREQ */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.a[PATH0].fddiPATHMaxT_Req =
			(u_long) -MS2BCLK((long)val) ;
		break ;
	case 9 :			/* TVX */
		DB_MAIN("SET %s = %d \n",pt->pt_name,val) ;
		smc->mib.a[PATH0].fddiPATHTVXLowerBound =
			(u_long) -US2BCLK((long)val) ;
		break ;
#ifdef	ESS
	case 10 :			/* SBAPAYLOAD */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		if (smc->mib.fddiESSPayload != val) {
			smc->ess.raf_act_timer_poll = TRUE ;
			smc->mib.fddiESSPayload = val ;
		}
		break ;
	case 11 :			/* SBAOVERHEAD */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.fddiESSOverhead = val ;
		break ;
	case 12 :			/* MAXTNEG */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.fddiESSMaxTNeg = (u_long) -MS2BCLK((long)val) ;
		break ;
	case 13 :			/* MINSEGMENTSIZE */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.fddiESSMinSegmentSize = val ;
		break ;
	case 14 :			/* SBACATEGORY */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.fddiESSCategory =
			(smc->mib.fddiESSCategory & 0xffff) |
			((u_long)(val << 16)) ;
		break ;
	case 15 :			/* SYNCHTXMODE */
		/* do not use memcmp(valbuf,"ALL",3) because DS != SS */
		if (valbuf[0] == 'A' && valbuf[1] == 'L' && valbuf[2] == 'L') {
			smc->mib.fddiESSSynchTxMode = TRUE ;
			DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
		}
		/* if (!memcmp(valbuf,"SPLIT",5)) { */
		if (valbuf[0] == 'S' && valbuf[1] == 'P' && valbuf[2] == 'L' &&
			valbuf[3] == 'I' && valbuf[4] == 'T') {
			DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
			smc->mib.fddiESSSynchTxMode = FALSE ;
		}
		break ;
#endif
#ifdef	SBA
	case 16 :			/* SBACOMMAND */
		/* if (!memcmp(valbuf,"START",5)) { */
		if (valbuf[0] == 'S' && valbuf[1] == 'T' && valbuf[2] == 'A' &&
			valbuf[3] == 'R' && valbuf[4] == 'T') {
			DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
			smc->mib.fddiSBACommand = SB_START ;
		}
		/* if (!memcmp(valbuf,"STOP",4)) { */
		if (valbuf[0] == 'S' && valbuf[1] == 'T' && valbuf[2] == 'O' &&
			valbuf[3] == 'P') {
			DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
			smc->mib.fddiSBACommand = SB_STOP ;
		}
		break ;
	case 17 :			/* SBAAVAILABLE */
		DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
		smc->mib.fddiSBAAvailable = (u_char) val ;
		break ;
#endif
	}
	return(0) ;
}

static int parse_word(char *buf, char _far *text)
{
	char		c ;
	char 		*p ;
	int		p_len ;
	int		quote ;
	int		i ;
	int		ok ;

	/*
	 * skip leading white space
	 */
	p = buf ;
	for (i = 0 ; i < MAX_VAL ; i++)
		*p++ = 0 ;
	p = buf ;
	p_len = 0 ;
	ok = 0 ;
	while ( (c = *text++) && (c != '\n') && (c != '\r')) {
		if ((c != ' ') && (c != '\t')) {
			ok = 1 ;
			break ;
		}
	}
	if (!ok)
		return(-1) ;
	if (c == '"') {
		quote = 1 ;
	}
	else {
		quote = 0 ;
		text-- ;
	}
	/*
	 * parse valbuf
	 */
	ok = 0 ;
	while (!ok && p_len < MAX_VAL-1 && (c = *text++) && (c != '\n')
		&& (c != '\r')) {
		switch (quote) {
		case 0 :
			if ((c == ' ') || (c == '\t') || (c == '=')) {
				ok = 1 ;
				break ;
			}
			*p++ = c ;
			p_len++ ;
			break ;
		case 2 :
			*p++ = c ;
			p_len++ ;
			quote = 1 ;
			break ;
		case 1 :
			switch (c) {
			case '"' :
				ok = 1 ;
				break ;
			case '\\' :
				quote = 2 ;
				break ;
			default :
				*p++ = c ;
				p_len++ ;
			}
		}
	}
	*p++ = 0 ;
	for (p = buf ; (c = *p) ; p++) {
		if (c >= 'a' && c <= 'z')
			*p = c + 'A' - 'a' ;
	}
	return(0) ;
}

static u_long parse_num(int type, char _far *value, char *v, u_long mn,
			u_long mx, int scale)
{
	u_long	x = 0 ;
	char	c ;

	if (type == 0) {		/* integer */
		u_long _far	*l ;
		u_long		u1 ;

		l = (u_long _far *) value ;
		u1 = *l ;
		/*
		 * if the value is negative take the lower limit
		 */
		if ((long)u1 < 0) {
			if (- ((long)u1) > (long) mx) {
				u1 = 0 ;
			}
			else {
				u1 = (u_long) - ((long)u1) ;
			}
		}
		x = u1 ;
	}
	else {				/* string */
		int	sign = 0 ;

		if (*v == '-') {
			sign = 1 ;
		}
		while ((c = *v++) && (c >= '0') && (c <= '9')) {
			x = x * 10 + c - '0' ;
		}
		if (scale == 10) {
			x *= 10 ;
			if (c == '.') {
				if ((c = *v++) && (c >= '0') && (c <= '9')) {
					x += c - '0' ;
				}
			}
		}
		if (sign)
			x = (u_long) - ((long)x) ;
	}
	/*
	 * if the value is negative
	 *	and the absolute value is outside the limits
	 *		take the lower limit
	 *	else
	 *		take the absoute value
	 */
	if ((long)x < 0) {
		if (- ((long)x) > (long) mx) {
			x = 0 ;
		}
		else {
			x = (u_long) - ((long)x) ;
		}
	}
	if (x < mn)
		return(mn) ;
	else if (x > mx)
		return(mx) ;
	return(x) ;
}

#if 0
struct	s_smc	SMC ;
main()
{
	char	*p ;
	char	*v ;
	char	buf[100] ;
	int	toggle = 0 ;

	while (gets(buf)) {
		p = buf ;
		while (*p && ((*p == ' ') || (*p == '\t')))
			p++ ;

		while (*p && ((*p != ' ') && (*p != '\t')))
			p++ ;

		v = p ;
		while (*v && ((*v == ' ') || (*v == '\t')))
			v++ ;
		if ((*v >= '0') && (*v <= '9')) {
			toggle = !toggle ;
			if (toggle) {
				u_long	l ;
				l = atol(v) ;
				smt_parse_arg(&SMC,buf,0,(char _far *)&l) ;
			}
			else
				smt_parse_arg(&SMC,buf,1,(char _far *)p) ;
		}
		else {
			smt_parse_arg(&SMC,buf,1,(char _far *)p) ;
		}
	}
	exit(0) ;
}
#endif
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	*
	3	* (C)Copyright 1998,1999 SysKonnect,
	4	* a business unit of Schneider & Koch & Co. Datensysteme GmbH.
	5	*
	6	* See the file "skfddi.c" for further information.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* The information in this file is provided "AS IS" without warranty.
	14	*
	15	******************************************************************************/
	16
	17
	18	/*
	19	parser for SMT parameters
	20	*/
	21
	22	#include "h/types.h"
	23	#include "h/fddi.h"
	24	#include "h/smc.h"
	25	#include "h/smt_p.h"
	26
	27	#define KERNEL
	28	#include "h/smtstate.h"
	29
	30	#ifndef lint
	31	static const char ID_sccs[] = "@(#)smtparse.c 1.12 98/10/06 (C) SK " ;
	32	#endif
	33
	34	#ifdef sun
	35	#define _far
	36	#endif
	37
	38	/*
	39	* convert to BCLK units
	40	*/
	41	#define MS2BCLK(x) ((x)*12500L)
	42	#define US2BCLK(x) ((x/10)*125L)
	43
	44	/*
	45	* parameter table
	46	*/
	47	static struct s_ptab {
	48	char *pt_name ;
	49	u_short pt_num ;
	50	u_short pt_type ;
	51	u_long pt_min ;
	52	u_long pt_max ;
	53	} ptab[] = {
	54	{ "PMFPASSWD",0, 0 } ,
	55	{ "USERDATA",1, 0 } ,
	56	{ "LERCUTOFFA",2, 1, 4, 15 } ,
	57	{ "LERCUTOFFB",3, 1, 4, 15 } ,
	58	{ "LERALARMA",4, 1, 4, 15 } ,
	59	{ "LERALARMB",5, 1, 4, 15 } ,
	60	{ "TMAX",6, 1, 5, 165 } ,
	61	{ "TMIN",7, 1, 5, 165 } ,
	62	{ "TREQ",8, 1, 5, 165 } ,
	63	{ "TVX",9, 1, 2500, 10000 } ,
	64	#ifdef ESS
65	{ "SBAPAYLOAD",10, 1, 0, 1562 } ,
66	{ "SBAOVERHEAD",11, 1, 50, 5000 } ,
67	{ "MAXTNEG",12, 1, 5, 165 } ,
68	{ "MINSEGMENTSIZE",13, 1, 0, 4478 } ,
69	{ "SBACATEGORY",14, 1, 0, 0xffff } ,
70	{ "SYNCHTXMODE",15, 0 } ,
71	#endif
72	#ifdef SBA
73	{ "SBACOMMAND",16, 0 } ,
74	{ "SBAAVAILABLE",17, 1, 0, 100 } ,
75	#endif
76	{ NULL }
77	} ;
78
79	/* Define maximum string size for values and keybuffer */
80	#define MAX_VAL 40
81
82	/*
83	* local function declarations
84	*/
85	static u_long parse_num(int type, char _far value, char v, u_long mn,
86	u_long mx, int scale);
87	static int parse_word(char buf, char _far text);
88
89	#ifdef SIM
90	#define DB_MAIN(a,b,c) printf(a,b,c)
91	#else
92	#define DB_MAIN(a,b,c)
93	#endif
94
95	/*
96	* BEGIN_MANUAL_ENTRY()
97	*
98	* int smt_parse_arg(struct s_smc ,char _far keyword,int type,
99	char _far *value)
100	*
101	* parse SMT parameter
102	* *keyword
103	* pointer to keyword, must be \0, \n or \r terminated
104	* value pointer to value, either char or u_long *
105	* if char *
106	* pointer to value, must be \0, \n or \r terminated
107	* if u_long *
108	* contains binary value
109	*
110	* type 0: integer
111	* 1: string
112	* return
113	* 0 parameter parsed ok
114	* != 0 error
115	* NOTE:
116	* function can be called with DS != SS
117	*
118	*
119	* END_MANUAL_ENTRY()
120	*/
121	int smt_parse_arg(struct s_smc smc, char _far keyword, int type,
122	char _far *value)
123	{
124	char keybuf[MAX_VAL+1];
125	char valbuf[MAX_VAL+1];
126	char c ;
127	char *p ;
128	char *v ;
129	char *d ;
130	u_long val = 0 ;
131	struct s_ptab *pt ;
132	int st ;
133	int i ;
134
135	/*
136	* parse keyword
137	*/
138	if ((st = parse_word(keybuf,keyword)))
139	return(st) ;
140	/*
141	* parse value if given as string
142	*/
143	if (type == 1) {
144	if ((st = parse_word(valbuf,value)))
145	return(st) ;
146	}
147	/*
148	* search in table
149	*/
150	st = 0 ;
151	for (pt = ptab ; (v = pt->pt_name) ; pt++) {
152	for (p = keybuf ; (c = *p) ; p++,v++) {
153	if (c != *v)
154	break ;
155	}
156	if (!c && !*v)
157	break ;
158	}
159	if (!v)
160	return(-1) ;
161	#if 0
162	printf("=>%s<==>%s<=\n",pt->pt_name,valbuf) ;
163	#endif
164	/*
165	* set value in MIB
166	*/
167	if (pt->pt_type)
168	val = parse_num(type,value,valbuf,pt->pt_min,pt->pt_max,1) ;
169	switch (pt->pt_num) {
170	case 0 :
171	v = valbuf ;
172	d = (char *) smc->mib.fddiPRPMFPasswd ;
173	for (i = 0 ; i < (signed)sizeof(smc->mib.fddiPRPMFPasswd) ; i++)
174	d++ = v++ ;
175	DB_MAIN("SET %s = %s\n",pt->pt_name,smc->mib.fddiPRPMFPasswd) ;
176	break ;
177	case 1 :
178	v = valbuf ;
179	d = (char *) smc->mib.fddiSMTUserData ;
180	for (i = 0 ; i < (signed)sizeof(smc->mib.fddiSMTUserData) ; i++)
181	d++ = v++ ;
182	DB_MAIN("SET %s = %s\n",pt->pt_name,smc->mib.fddiSMTUserData) ;
183	break ;
184	case 2 :
185	smc->mib.p[PA].fddiPORTLer_Cutoff = (u_char) val ;
186	DB_MAIN("SET %s = %d\n",
187	pt->pt_name,smc->mib.p[PA].fddiPORTLer_Cutoff) ;
188	break ;
189	case 3 :
190	smc->mib.p[PB].fddiPORTLer_Cutoff = (u_char) val ;
191	DB_MAIN("SET %s = %d\n",
192	pt->pt_name,smc->mib.p[PB].fddiPORTLer_Cutoff) ;
193	break ;
194	case 4 :
195	smc->mib.p[PA].fddiPORTLer_Alarm = (u_char) val ;
196	DB_MAIN("SET %s = %d\n",
197	pt->pt_name,smc->mib.p[PA].fddiPORTLer_Alarm) ;
198	break ;
199	case 5 :
200	smc->mib.p[PB].fddiPORTLer_Alarm = (u_char) val ;
201	DB_MAIN("SET %s = %d\n",
202	pt->pt_name,smc->mib.p[PB].fddiPORTLer_Alarm) ;
203	break ;
204	case 6 : /* TMAX */
205	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
206	smc->mib.a[PATH0].fddiPATHT_MaxLowerBound =
207	(u_long) -MS2BCLK((long)val) ;
208	break ;
209	case 7 : /* TMIN */
210	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
211	smc->mib.m[MAC0].fddiMACT_Min =
212	(u_long) -MS2BCLK((long)val) ;
213	break ;
214	case 8 : /* TREQ */
215	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
216	smc->mib.a[PATH0].fddiPATHMaxT_Req =
217	(u_long) -MS2BCLK((long)val) ;
218	break ;
219	case 9 : /* TVX */
220	DB_MAIN("SET %s = %d \n",pt->pt_name,val) ;
221	smc->mib.a[PATH0].fddiPATHTVXLowerBound =
222	(u_long) -US2BCLK((long)val) ;
223	break ;
224	#ifdef ESS
225	case 10 : /* SBAPAYLOAD */
226	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
227	if (smc->mib.fddiESSPayload != val) {
228	smc->ess.raf_act_timer_poll = TRUE ;
229	smc->mib.fddiESSPayload = val ;
230	}
231	break ;
232	case 11 : /* SBAOVERHEAD */
233	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
234	smc->mib.fddiESSOverhead = val ;
235	break ;
236	case 12 : /* MAXTNEG */
237	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
238	smc->mib.fddiESSMaxTNeg = (u_long) -MS2BCLK((long)val) ;
239	break ;
240	case 13 : /* MINSEGMENTSIZE */
241	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
242	smc->mib.fddiESSMinSegmentSize = val ;
243	break ;
244	case 14 : /* SBACATEGORY */
245	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
246	smc->mib.fddiESSCategory =
247	(smc->mib.fddiESSCategory & 0xffff) \|
248	((u_long)(val << 16)) ;
249	break ;
250	case 15 : /* SYNCHTXMODE */
251	/* do not use memcmp(valbuf,"ALL",3) because DS != SS */
252	if (valbuf[0] == 'A' && valbuf[1] == 'L' && valbuf[2] == 'L') {
253	smc->mib.fddiESSSynchTxMode = TRUE ;
254	DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
255	}
256	/* if (!memcmp(valbuf,"SPLIT",5)) { */
257	if (valbuf[0] == 'S' && valbuf[1] == 'P' && valbuf[2] == 'L' &&
258	valbuf[3] == 'I' && valbuf[4] == 'T') {
259	DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
260	smc->mib.fddiESSSynchTxMode = FALSE ;
261	}
262	break ;
263	#endif
264	#ifdef SBA
265	case 16 : /* SBACOMMAND */
266	/* if (!memcmp(valbuf,"START",5)) { */
267	if (valbuf[0] == 'S' && valbuf[1] == 'T' && valbuf[2] == 'A' &&
268	valbuf[3] == 'R' && valbuf[4] == 'T') {
269	DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
270	smc->mib.fddiSBACommand = SB_START ;
271	}
272	/* if (!memcmp(valbuf,"STOP",4)) { */
273	if (valbuf[0] == 'S' && valbuf[1] == 'T' && valbuf[2] == 'O' &&
274	valbuf[3] == 'P') {
275	DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ;
276	smc->mib.fddiSBACommand = SB_STOP ;
277	}
278	break ;
279	case 17 : /* SBAAVAILABLE */
280	DB_MAIN("SET %s = %d\n",pt->pt_name,val) ;
281	smc->mib.fddiSBAAvailable = (u_char) val ;
282	break ;
283	#endif
284	}
285	return(0) ;
286	}
287
288	static int parse_word(char buf, char _far text)
289	{
290	char c ;
291	char *p ;
292	int p_len ;
293	int quote ;
294	int i ;
295	int ok ;
296
297	/*
298	* skip leading white space
299	*/
300	p = buf ;
301	for (i = 0 ; i < MAX_VAL ; i++)
302	*p++ = 0 ;
303	p = buf ;
304	p_len = 0 ;
305	ok = 0 ;
306	while ( (c = *text++) && (c != '\n') && (c != '\r')) {
307	if ((c != ' ') && (c != '\t')) {
308	ok = 1 ;
309	break ;
310	}
311	}
312	if (!ok)
313	return(-1) ;
314	if (c == '"') {
315	quote = 1 ;
316	}
317	else {
318	quote = 0 ;
319	text-- ;
320	}
321	/*
322	* parse valbuf
323	*/
324	ok = 0 ;
325	while (!ok && p_len < MAX_VAL-1 && (c = *text++) && (c != '\n')
326	&& (c != '\r')) {
327	switch (quote) {
328	case 0 :
329	if ((c == ' ') \|\| (c == '\t') \|\| (c == '=')) {
330	ok = 1 ;
331	break ;
332	}
333	*p++ = c ;
334	p_len++ ;
335	break ;
336	case 2 :
337	*p++ = c ;
338	p_len++ ;
339	quote = 1 ;
340	break ;
341	case 1 :
342	switch (c) {
343	case '"' :
344	ok = 1 ;
345	break ;
346	case '\\' :
347	quote = 2 ;
348	break ;
349	default :
350	*p++ = c ;
351	p_len++ ;
352	}
353	}
354	}
355	*p++ = 0 ;
356	for (p = buf ; (c = *p) ; p++) {
357	if (c >= 'a' && c <= 'z')
358	*p = c + 'A' - 'a' ;
359	}
360	return(0) ;
361	}
362
363	static u_long parse_num(int type, char _far value, char v, u_long mn,
364	u_long mx, int scale)
365	{
366	u_long x = 0 ;
367	char c ;
368
369	if (type == 0) { /* integer */
370	u_long _far *l ;
371	u_long u1 ;
372
373	l = (u_long _far *) value ;
374	u1 = *l ;
375	/*
376	* if the value is negative take the lower limit
377	*/
378	if ((long)u1 < 0) {
379	if (- ((long)u1) > (long) mx) {
380	u1 = 0 ;
381	}
382	else {
383	u1 = (u_long) - ((long)u1) ;
384	}
385	}
386	x = u1 ;
387	}
388	else { /* string */
389	int sign = 0 ;
390
391	if (*v == '-') {
392	sign = 1 ;
393	}
394	while ((c = *v++) && (c >= '0') && (c <= '9')) {
395	x = x * 10 + c - '0' ;
396	}
397	if (scale == 10) {
398	x *= 10 ;
399	if (c == '.') {
400	if ((c = *v++) && (c >= '0') && (c <= '9')) {
401	x += c - '0' ;
402	}
403	}
404	}
405	if (sign)
406	x = (u_long) - ((long)x) ;
407	}
408	/*
409	* if the value is negative
410	* and the absolute value is outside the limits
411	* take the lower limit
412	* else
413	* take the absoute value
414	*/
415	if ((long)x < 0) {
416	if (- ((long)x) > (long) mx) {
417	x = 0 ;
418	}
419	else {
420	x = (u_long) - ((long)x) ;
421	}
422	}
423	if (x < mn)
424	return(mn) ;
425	else if (x > mx)
426	return(mx) ;
427	return(x) ;
428	}
429
430	#if 0
431	struct s_smc SMC ;
432	main()
433	{
434	char *p ;
435	char *v ;
436	char buf[100] ;
437	int toggle = 0 ;
438
439	while (gets(buf)) {
440	p = buf ;
441	while (p && ((p == ' ') \|\| (*p == '\t')))
442	p++ ;
443
444	while (p && ((p != ' ') && (*p != '\t')))
445	p++ ;
446
447	v = p ;
448	while (v && ((v == ' ') \|\| (*v == '\t')))
449	v++ ;
450	if ((v >= '0') && (v <= '9')) {
451	toggle = !toggle ;
452	if (toggle) {
453	u_long l ;
454	l = atol(v) ;
455	smt_parse_arg(&SMC,buf,0,(char _far *)&l) ;
456	}
457	else
458	smt_parse_arg(&SMC,buf,1,(char _far *)p) ;
459	}
460	else {
461	smt_parse_arg(&SMC,buf,1,(char _far *)p) ;
462	}
463	}
464	exit(0) ;
465	}
466	#endif
467