[unix-history] / usr / src / cmd / struct / 1.recog.c

#include <stdio.h>
#include "1.incl.h"
#include "def.h"


recognize(type, ifflag)			/* if ifflag = 1, statement is if()type; otherwise is type */
int type, ifflag;				/* do whatever is needed for this statement */
	{
	int *arctype,   i,   sp;
	VERT num, num1, nest, loophead;
	extern long label();
	long *arclab;
	if (nlabs > 3) sp = nlabs; else sp = 3;
	arctype = challoc(sizeof(*arctype) * sp);  arclab = challoc(sizeof(*arclab) * sp);
	for( i=0; i < endbuf; i++)  {if (buffer[i] == '~')  buffer[i] = ' ';}
	loophead = nest = innerdo(label(0));
	if (DEFINED(nest))
		{
			/* this statement is last line of do loop */
		nest = ARC(nest,0);		/* nest is ITERVX of the innermost do ending here */
		}


	if (ifflag)
		{
		if (type == ungo)
			{
			arctype[0] = -2;
			arclab[0] = label(1);
			}
		else
			arctype[0] = 0;

		arctype[1] = (nest >= 0) ? nest : -2;
		arclab[1] = implicit;
		num1 = makenode(IFVX,TRUE,TRUE,label(0),2,arctype,arclab);
		PRED(num1) = pred;
		}

	arctype[0] = (nest >= 0) ? nest : -2;
	arclab[0] = implicit;

	switch(type)
		{
		case ungo:
			if (!ifflag)
				{
				connect(label(1),implicit);
				if (label(0) != implicit)  connect(label(1),label(0));
				}
			break;
		case RETVX:
		case STOPVX:
			if (type == RETVX)
				{
				if (retvert == UNDEFINED)
					retvert = makenode(type,FALSE,FALSE,implicit,0,arctype,arclab);
				num = retvert;
				}
			else
				{
				if (stopvert == UNDEFINED)
					stopvert = makenode(type,FALSE,FALSE,implicit,0,arctype,arclab);
				num = stopvert;
				}
			if (!ifflag)
				{
				fixvalue(implicit,num);
				clear(implicit);
				if (label(0) != implicit) fixvalue(label(0),num);
				}
			break;


		case contst:
			contin(label(0),loophead);
			break;

		case FMTVX:
			num = makenode(FMTVX,FALSE,TRUE,implicit,0,arctype,arclab);
			BEGCODE(num) = comchar + 1 - rtnbeg;
			if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
				faterr("program too long","","");
			ONDISK(num) = endline - endcom;
			if (label(0) != implicit)
				fixvalue(label(0),num);
			FMTLST = append(num,FMTLST);
			break;
		case STLNVX:
			if (DEFINED(stflag) && !ifflag && (label(0) == implicit))
				{
				++CODELINES(stflag);
				ONDISK(stflag) += endline - begline + 1;
				}
			else
				{
				num = makenode(STLNVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
				if (!ifflag)
					{
					stflag = num;
					BEGCODE(num) = comchar + 1 - rtnbeg;
					if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
						faterr("program too long","","");
					ONDISK(num) = endline - endcom;
					CODELINES(num) = 1;
					}
				else
					{
					BEGCODE(num) = stcode;
					ONDISK(num) = FALSE;
					CODELINES(num) = 1;
					}
				}
			break;

		case DOVX:
			if (arctype[0] != -2) 
				{
				error("illegal do range, ","","");
				fprintf(stderr," between lines %d and %d\n",begline, endline);
				exit(1);
				}
			arctype[1] = UNDEFINED;
			num1 = makenode(DOVX,TRUE,TRUE,label(0),2,arctype,arclab);
			if (++doptr >= maxdo)
				{
				faterr("in parsing:\n","do loops nested deeper than allowed","");
				}
			dostack[doptr] = label(1);
			doloc[doptr] = num1;			/* stack link to node after loop */
			INC(num1) = inc;
			num = makenode(ITERVX,TRUE,FALSE,implicit,1,arctype,arclab);
			ARC(num1,0) = num;
			FATH(num) = UNDEFINED;	/* number of DOVX can change so leave UNDEFINED until later */
			break;
		case arithif:
			if (label(1) == label(2) || label(1) == 0L)
				makeif(1,label(0),concat(pred," > 0"),label(3),label(2));
			else if (label(1) == label(3) || label(3) == 0L)
				makeif(1,label(0),concat(pred," == 0"),label(2),label(1));
			else if (label(2) == label(3) || label(2) == 0L)
				makeif(1,label(0),concat(pred," < 0"),label(1),label(3));
			else
				{
				makeif(1,label(0),concat(pred," < 0"),label(1),implicit);
				makeif(1,implicit,concat(pred," == 0"),label(2),label(3));
				}
			break;

		case IOVX:
			if (endlab)
				{
				arctype[1] = -2;
				arclab[1] = endlab->labelt;
				}
			else
				arctype[1] = UNDEFINED;
			if (errlab)
				{
				arctype[2] = -2;
				arclab[2] = errlab->labelt;
				}
			else
				arctype[2] = UNDEFINED;
			num = makenode(IOVX,!ifflag,!ifflag,label(0),3,arctype,arclab);
			PRERW(num) = prerw;
			POSTRW(num) = postrw;
			if (reflab)
				addref(reflab->labelt, &FMTREF(num));
			else
				FMTREF(num) = UNDEFINED;
			break;

		case COMPVX:
				if (intcase)
					{
					num = compcase(ifflag);
					break;
					}
		case ASGOVX:
			for (i = 0; i < nlabs - 1; i++)
				{
				arctype[i] = -2;
				arclab[i] = label(nlabs-i-1);
				}
			num = makenode(type,!ifflag,!ifflag,label(0),nlabs - 1, arctype, arclab);
			EXP(num) = exp;
			break;
		case ASVX:
			num = makenode(ASVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
			EXP(num) = exp;
			addref(label(1),&LABREF(num));
			break;
		case entry:
			num = makenode(STLNVX,FALSE,TRUE,label(0),1,arctype,arclab);
			BEGCODE(num) = comchar + 1 - rtnbeg;
			if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
				faterr("program too long","","");
			ONDISK(num) = endline - endcom;
			CODELINES(num) = 1;
			ENTLST = append(num,ENTLST);
			break;
		}
	if (ifflag && type != ungo)
		{
		ARC(num1,0) = num;
		}
	if (DEFINED(loophead))  nesteddo(label(0), loophead);
	if (ifflag || DEFINED(loophead) || type != STLNVX)  stflag = UNDEFINED;


	chfree(arctype,sizeof(*arctype) * sp);  chfree(arclab,sizeof(*arclab) * sp);
	if (debug)
		{
		fprintf(debfd,"line %d:  ", begline);
		if (ifflag) fprintf(debfd,"if()  ");
		switch(type)
			{case RETVX:	fprintf(debfd,"return");	break;
			case STOPVX:	fprintf(debfd,"stop");	break;
			case contst:	fprintf(debfd,"continue");	break;
			case ungo:	fprintf(debfd,"uncond. goto");	break;
			case COMPVX:	fprintf(debfd,"comp. goto");	break;
			case ASGOVX:	fprintf(debfd,"ass. goto, labs");	break;
			case ASVX:	fprintf(debfd,"label assignment");	break;
			case STLNVX:	fprintf(debfd,"simple statement");	break;
			case arithif:	fprintf(debfd,"arith if");	break;
			case DOVX:	fprintf(debfd,"do ");	break;
			case FMTVX:  fprintf(debfd,"format st");  break;
			case IOVX:  fprintf(debfd,"IOVX statement ");  break;
case entry:	fprintf(debfd,"entry statement ");  break;
			}
		fprintf(debfd,"\n%s\n", buffer);
		}
	}


makeif(first,labe,test,arc1,arc2)			/* construct IFVX with arcs to labels arc1,arc2 */
int first;
long labe, arc1,arc2;
char *test;
	{
	int num, arctype[2];
	long arclab[2];
	arctype[0] = arctype[1] = -2;
	arclab[0] = arc1;
	arclab[1] = arc2;
	num = makenode(IFVX,first,first,labe,2,arctype,arclab);
	PRED(num) = test;
	return(num);
	}


innerdo(labe)		/* return number of DOVX associated with labe, or UNDEFINED */
long labe;
	{
	if (DEFINED(doptr))
		{if (dostack[doptr] == labe)
			return(doloc[doptr--]);
		}
	return(UNDEFINED);
	}


contin(labe,nest)		/* handle continue statements */
long labe;
int nest;
	{
	VERT y;
	
	if (!DEFINED(nest))
		{		/* not nested */
		if (labe != implicit) connect(implicit,labe);	/* labe pts to next node */
		}
	else
		{		/* nested */
		y = ARC(nest,0);
		fixvalue(labe,y);			/* labe pts to ITERVX */
		fixvalue(implicit, y);		/* implicit links pt to ITERVX */
		clear(implicit);
		}
	}


nesteddo(labe,v)
			/* if multiple do's end on same label, add arc from inner DOVX
				to enclosing DOVX;
			add implicit link out of outermost DOVX with this label */
long labe;
int v;
	{
	
	while (DEFINED(doptr) && dostack[doptr] == labe)
		{
		ARC(v,1) = ARC(doloc[doptr],0);		/*set inner DOVX to point to outer ITERVX */
		v = doloc[doptr--];
		}
	addref(implicit, &ARC(v,1));
	}


compcase(ifflag)		/* turn computed goto into case statement */
LOGICAL ifflag;
	{
	int *arctype, i, num, d, arct;
	extern long label();
	long *arclab;
	char *str;
	arctype = challoc(sizeof(*arctype) * nlabs);
	arclab = challoc (sizeof(*arclab) * nlabs);

	d = distinct(linelabs->nxtlab,arctype,arclab,nlabs-1);
			/* puts distinct labels in arclab, count of each in arctype */
	arct = -2;
	for (i = 0; i < d; ++i)
		arctype[i] = makenode(ICASVX,FALSE,FALSE,implicit,1,&arct,&arclab[i]);
	num = makenode(SWCHVX,!ifflag,!ifflag,label(0),d,arctype,arclab);
	EXP(num) = exp;

	str = challoc(6*nlabs);	/* 5 digits + , or \0 per label */
	for (i = 0; i < d; ++i)		/* construct list of values for each label */
		EXP(arctype[i]) = stralloc(str,accum(str,linelabs->nxtlab,arclab[i]));
	chfree(str,6*nlabs);
	chfree(arctype,sizeof(*arctype) * nlabs);  chfree(arclab,sizeof(*arclab) * nlabs);
	return(num);
	}


accum(str,vlist,f)		/* build string of indices in compnode  corr. to label f */
char *str;  long f;  struct lablist *vlist;
	{
	int s,j;  struct lablist  *p;

	s = 0;
	j = 1;
	for (p = vlist; p ; p = p->nxtlab)		/* search for occurrences of f */
		{
		if (p->labelt ==f)
			{
			if (s)
				{
				str[s] = ',';
				++s;
				}
			sprintf(&str[s],"%d",j);
			while (str[s] != '\0') ++s;
			}
		++j;
		}
	return(s+1);
	}


distinct(vlist,count,dlist,size)		/* make dlist into list of distinct labels in vlist */
struct lablist *vlist;  long dlist[];		/*count[] gets count of each label;  d distinct labels */
int count[],size;
	{int d,i;
	d = 0;
	for(i = 0; i <= size; i++)  count[i] = 0;

	for (;vlist && vlist->labelt != 0L; vlist = vlist ->nxtlab)
		{
		for (i = 0; ;i++)
			{
			if (i == d)  dlist[d++] = vlist->labelt;
			if (dlist[i] == vlist->labelt)
				{
				++count[i];  break;
				}
			}
		}
	return(d);
	}
Commit	Line	Data
3097d999 BB	1	#include <stdio.h>
	2	#include "1.incl.h"
	3	#include "def.h"
	4
	5
	6	recognize(type, ifflag) /* if ifflag = 1, statement is if()type; otherwise is type */
	7	int type, ifflag; /* do whatever is needed for this statement */
	8	{
	9	int *arctype, i, sp;
	10	VERT num, num1, nest, loophead;
	11	extern long label();
	12	long *arclab;
	13	if (nlabs > 3) sp = nlabs; else sp = 3;
	14	arctype = challoc(sizeof(arctype) sp); arclab = challoc(sizeof(arclab) sp);
	15	for( i=0; i < endbuf; i++) {if (buffer[i] == '~') buffer[i] = ' ';}
	16	loophead = nest = innerdo(label(0));
	17	if (DEFINED(nest))
	18	{
	19	/* this statement is last line of do loop */
	20	nest = ARC(nest,0); /* nest is ITERVX of the innermost do ending here */
	21	}
	22
	23
	24	if (ifflag)
	25	{
	26	if (type == ungo)
	27	{
	28	arctype[0] = -2;
	29	arclab[0] = label(1);
	30	}
	31	else
	32	arctype[0] = 0;
	33
	34	arctype[1] = (nest >= 0) ? nest : -2;
	35	arclab[1] = implicit;
	36	num1 = makenode(IFVX,TRUE,TRUE,label(0),2,arctype,arclab);
	37	PRED(num1) = pred;
	38	}
	39
	40	arctype[0] = (nest >= 0) ? nest : -2;
	41	arclab[0] = implicit;
	42
	43	switch(type)
	44	{
	45	case ungo:
	46	if (!ifflag)
	47	{
	48	connect(label(1),implicit);
	49	if (label(0) != implicit) connect(label(1),label(0));
	50	}
	51	break;
	52	case RETVX:
	53	case STOPVX:
	54	if (type == RETVX)
	55	{
	56	if (retvert == UNDEFINED)
	57	retvert = makenode(type,FALSE,FALSE,implicit,0,arctype,arclab);
	58	num = retvert;
	59	}
	60	else
	61	{
	62	if (stopvert == UNDEFINED)
	63	stopvert = makenode(type,FALSE,FALSE,implicit,0,arctype,arclab);
	64	num = stopvert;
65	}
66	if (!ifflag)
67	{
68	fixvalue(implicit,num);
69	clear(implicit);
70	if (label(0) != implicit) fixvalue(label(0),num);
71	}
72	break;
73
74
75	case contst:
76	contin(label(0),loophead);
77	break;
78
79	case FMTVX:
80	num = makenode(FMTVX,FALSE,TRUE,implicit,0,arctype,arclab);
81	BEGCODE(num) = comchar + 1 - rtnbeg;
82	if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
83	faterr("program too long","","");
84	ONDISK(num) = endline - endcom;
85	if (label(0) != implicit)
86	fixvalue(label(0),num);
87	FMTLST = append(num,FMTLST);
88	break;
89	case STLNVX:
90	if (DEFINED(stflag) && !ifflag && (label(0) == implicit))
91	{
92	++CODELINES(stflag);
93	ONDISK(stflag) += endline - begline + 1;
94	}
95	else
96	{
97	num = makenode(STLNVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
98	if (!ifflag)
99	{
100	stflag = num;
101	BEGCODE(num) = comchar + 1 - rtnbeg;
102	if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
103	faterr("program too long","","");
104	ONDISK(num) = endline - endcom;
105	CODELINES(num) = 1;
106	}
107	else
108	{
109	BEGCODE(num) = stcode;
110	ONDISK(num) = FALSE;
111	CODELINES(num) = 1;
112	}
113	}
114	break;
115
116	case DOVX:
117	if (arctype[0] != -2)
118	{
119	error("illegal do range, ","","");
120	fprintf(stderr," between lines %d and %d\n",begline, endline);
121	exit(1);
122	}
123	arctype[1] = UNDEFINED;
124	num1 = makenode(DOVX,TRUE,TRUE,label(0),2,arctype,arclab);
125	if (++doptr >= maxdo)
126	{
127	faterr("in parsing:\n","do loops nested deeper than allowed","");
128	}
129	dostack[doptr] = label(1);
130	doloc[doptr] = num1; /* stack link to node after loop */
131	INC(num1) = inc;
132	num = makenode(ITERVX,TRUE,FALSE,implicit,1,arctype,arclab);
133	ARC(num1,0) = num;
134	FATH(num) = UNDEFINED; /* number of DOVX can change so leave UNDEFINED until later */
135	break;
136	case arithif:
137	if (label(1) == label(2) \|\| label(1) == 0L)
138	makeif(1,label(0),concat(pred," > 0"),label(3),label(2));
139	else if (label(1) == label(3) \|\| label(3) == 0L)
140	makeif(1,label(0),concat(pred," == 0"),label(2),label(1));
141	else if (label(2) == label(3) \|\| label(2) == 0L)
142	makeif(1,label(0),concat(pred," < 0"),label(1),label(3));
143	else
144	{
145	makeif(1,label(0),concat(pred," < 0"),label(1),implicit);
146	makeif(1,implicit,concat(pred," == 0"),label(2),label(3));
147	}
148	break;
149
150	case IOVX:
151	if (endlab)
152	{
153	arctype[1] = -2;
154	arclab[1] = endlab->labelt;
155	}
156	else
157	arctype[1] = UNDEFINED;
158	if (errlab)
159	{
160	arctype[2] = -2;
161	arclab[2] = errlab->labelt;
162	}
163	else
164	arctype[2] = UNDEFINED;
165	num = makenode(IOVX,!ifflag,!ifflag,label(0),3,arctype,arclab);
166	PRERW(num) = prerw;
167	POSTRW(num) = postrw;
168	if (reflab)
169	addref(reflab->labelt, &FMTREF(num));
170	else
171	FMTREF(num) = UNDEFINED;
172	break;
173
174	case COMPVX:
175	if (intcase)
176	{
177	num = compcase(ifflag);
178	break;
179	}
180	case ASGOVX:
181	for (i = 0; i < nlabs - 1; i++)
182	{
183	arctype[i] = -2;
184	arclab[i] = label(nlabs-i-1);
185	}
186	num = makenode(type,!ifflag,!ifflag,label(0),nlabs - 1, arctype, arclab);
187	EXP(num) = exp;
188	break;
189	case ASVX:
190	num = makenode(ASVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
191	EXP(num) = exp;
192	addref(label(1),&LABREF(num));
193	break;
194	case entry:
195	num = makenode(STLNVX,FALSE,TRUE,label(0),1,arctype,arclab);
196	BEGCODE(num) = comchar + 1 - rtnbeg;
197	if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
198	faterr("program too long","","");
199	ONDISK(num) = endline - endcom;
200	CODELINES(num) = 1;
201	ENTLST = append(num,ENTLST);
202	break;
203	}
204	if (ifflag && type != ungo)
205	{
206	ARC(num1,0) = num;
207	}
208	if (DEFINED(loophead)) nesteddo(label(0), loophead);
209	if (ifflag \|\| DEFINED(loophead) \|\| type != STLNVX) stflag = UNDEFINED;
210
211
212	chfree(arctype,sizeof(arctype) sp); chfree(arclab,sizeof(arclab) sp);
213	if (debug)
214	{
215	fprintf(debfd,"line %d: ", begline);
216	if (ifflag) fprintf(debfd,"if() ");
217	switch(type)
218	{case RETVX: fprintf(debfd,"return"); break;
219	case STOPVX: fprintf(debfd,"stop"); break;
220	case contst: fprintf(debfd,"continue"); break;
221	case ungo: fprintf(debfd,"uncond. goto"); break;
222	case COMPVX: fprintf(debfd,"comp. goto"); break;
223	case ASGOVX: fprintf(debfd,"ass. goto, labs"); break;
224	case ASVX: fprintf(debfd,"label assignment"); break;
225	case STLNVX: fprintf(debfd,"simple statement"); break;
226	case arithif: fprintf(debfd,"arith if"); break;
227	case DOVX: fprintf(debfd,"do "); break;
228	case FMTVX: fprintf(debfd,"format st"); break;
229	case IOVX: fprintf(debfd,"IOVX statement "); break;
230	case entry: fprintf(debfd,"entry statement "); break;
231	}
232	fprintf(debfd,"\n%s\n", buffer);
233	}
234	}
235
236
237
238	makeif(first,labe,test,arc1,arc2) /* construct IFVX with arcs to labels arc1,arc2 */
239	int first;
240	long labe, arc1,arc2;
241	char *test;
242	{
243	int num, arctype[2];
244	long arclab[2];
245	arctype[0] = arctype[1] = -2;
246	arclab[0] = arc1;
247	arclab[1] = arc2;
248	num = makenode(IFVX,first,first,labe,2,arctype,arclab);
249	PRED(num) = test;
250	return(num);
251	}
252
253
254	innerdo(labe) /* return number of DOVX associated with labe, or UNDEFINED */
255	long labe;
256	{
257	if (DEFINED(doptr))
258	{if (dostack[doptr] == labe)
259	return(doloc[doptr--]);
260	}
261	return(UNDEFINED);
262	}
263
264
265
266
267	contin(labe,nest) /* handle continue statements */
268	long labe;
269	int nest;
270	{
271	VERT y;
272
273	if (!DEFINED(nest))
274	{ /* not nested */
275	if (labe != implicit) connect(implicit,labe); /* labe pts to next node */
276	}
277	else
278	{ /* nested */
279	y = ARC(nest,0);
280	fixvalue(labe,y); /* labe pts to ITERVX */
281	fixvalue(implicit, y); /* implicit links pt to ITERVX */
282	clear(implicit);
283	}
284	}
285
286
287
288
289	nesteddo(labe,v)
290	/* if multiple do's end on same label, add arc from inner DOVX
291	to enclosing DOVX;
292	add implicit link out of outermost DOVX with this label */
293	long labe;
294	int v;
295	{
296
297	while (DEFINED(doptr) && dostack[doptr] == labe)
298	{
299	ARC(v,1) = ARC(doloc[doptr],0); /set inner DOVX to point to outer ITERVX /
300	v = doloc[doptr--];
301	}
302	addref(implicit, &ARC(v,1));
303	}
304
305
306
307	compcase(ifflag) /* turn computed goto into case statement */
308	LOGICAL ifflag;
309	{
310	int *arctype, i, num, d, arct;
311	extern long label();
312	long *arclab;
313	char *str;
314	arctype = challoc(sizeof(arctype) nlabs);
315	arclab = challoc (sizeof(arclab) nlabs);
316
317	d = distinct(linelabs->nxtlab,arctype,arclab,nlabs-1);
318	/* puts distinct labels in arclab, count of each in arctype */
319	arct = -2;
320	for (i = 0; i < d; ++i)
321	arctype[i] = makenode(ICASVX,FALSE,FALSE,implicit,1,&arct,&arclab[i]);
322	num = makenode(SWCHVX,!ifflag,!ifflag,label(0),d,arctype,arclab);
323	EXP(num) = exp;
324
325	str = challoc(6nlabs); / 5 digits + , or \0 per label */
326	for (i = 0; i < d; ++i) /* construct list of values for each label */
327	EXP(arctype[i]) = stralloc(str,accum(str,linelabs->nxtlab,arclab[i]));
328	chfree(str,6*nlabs);
329	chfree(arctype,sizeof(arctype) nlabs); chfree(arclab,sizeof(arclab) nlabs);
330	return(num);
331	}
332
333
334	accum(str,vlist,f) /* build string of indices in compnode corr. to label f */
335	char str; long f; struct lablist vlist;
336	{
337	int s,j; struct lablist *p;
338
339	s = 0;
340	j = 1;
341	for (p = vlist; p ; p = p->nxtlab) /* search for occurrences of f */
342	{
343	if (p->labelt ==f)
344	{
345	if (s)
346	{
347	str[s] = ',';
348	++s;
349	}
350	sprintf(&str[s],"%d",j);
351	while (str[s] != '\0') ++s;
352	}
353	++j;
354	}
355	return(s+1);
356	}
357
358
359	distinct(vlist,count,dlist,size) /* make dlist into list of distinct labels in vlist */
360	struct lablist vlist; long dlist[]; /count[] gets count of each label; d distinct labels */
361	int count[],size;
362	{int d,i;
363	d = 0;
364	for(i = 0; i <= size; i++) count[i] = 0;
365
366	for (;vlist && vlist->labelt != 0L; vlist = vlist ->nxtlab)
367	{
368	for (i = 0; ;i++)
369	{
370	if (i == d) dlist[d++] = vlist->labelt;
371	if (dlist[i] == vlist->labelt)
372	{
373	++count[i]; break;
374	}
375	}
376	}
377	return(d);
378	}
379
380