english_stem.c

PostgreSQL 8.1.4的源码 适用于Linux下的开源数据库系统

					return ret;
			}
			break;
	}
	return 1;
}

static int
r_Step_4(struct SN_env * z)
{
	int			among_var;

	z->ket = z->c;				/* [, line 140 */
	among_var = find_among_b(z, a_7, 18);		/* substring, line 140 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 140 */
	{
		int			ret = r_R2(z);

		if (ret == 0)
			return 0;			/* call R2, line 140 */
		if (ret < 0)
			return ret;
	}
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 143 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			{
				int			m = z->l - z->c;

				(void) m;		/* or, line 144 */
				if (!(eq_s_b(z, 1, s_34)))
					goto lab1;
				goto lab0;
		lab1:
				z->c = z->l - m;
				if (!(eq_s_b(z, 1, s_35)))
					return 0;
			}
	lab0:
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 144 */
				if (ret < 0)
					return ret;
			}
			break;
	}
	return 1;
}

static int
r_Step_5(struct SN_env * z)
{
	int			among_var;

	z->ket = z->c;				/* [, line 149 */
	among_var = find_among_b(z, a_8, 2);		/* substring, line 149 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 149 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			{
				int			m = z->l - z->c;

				(void) m;		/* or, line 150 */
				{
					int			ret = r_R2(z);

					if (ret == 0)
						goto lab1;		/* call R2, line 150 */
					if (ret < 0)
						return ret;
				}
				goto lab0;
		lab1:
				z->c = z->l - m;
				{
					int			ret = r_R1(z);

					if (ret == 0)
						return 0;		/* call R1, line 150 */
					if (ret < 0)
						return ret;
				}
				{
					int			m = z->l - z->c;

					(void) m;	/* not, line 150 */
					{
						int			ret = r_shortv(z);

						if (ret == 0)
							goto lab2;	/* call shortv, line 150 */
						if (ret < 0)
							return ret;
					}
					return 0;
			lab2:
					z->c = z->l - m;
				}
			}
	lab0:
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 150 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			{
				int			ret = r_R2(z);

				if (ret == 0)
					return 0;	/* call R2, line 151 */
				if (ret < 0)
					return ret;
			}
			if (!(eq_s_b(z, 1, s_36)))
				return 0;
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 151 */
				if (ret < 0)
					return ret;
			}
			break;
	}
	return 1;
}

static int
r_exception2(struct SN_env * z)
{
	z->ket = z->c;				/* [, line 157 */
	if (!(find_among_b(z, a_9, 8)))
		return 0;				/* substring, line 157 */
	z->bra = z->c;				/* ], line 157 */
	if (z->c > z->lb)
		return 0;				/* atlimit, line 157 */
	return 1;
}

static int
r_exception1(struct SN_env * z)
{
	int			among_var;

	z->bra = z->c;				/* [, line 169 */
	among_var = find_among(z, a_10, 18);		/* substring, line 169 */
	if (!(among_var))
		return 0;
	z->ket = z->c;				/* ], line 169 */
	if (z->c < z->l)
		return 0;				/* atlimit, line 169 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			{
				int			ret;

				ret = slice_from_s(z, 3, s_37); /* <-, line 173 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			{
				int			ret;

				ret = slice_from_s(z, 3, s_38); /* <-, line 174 */
				if (ret < 0)
					return ret;
			}
			break;
		case 3:
			{
				int			ret;

				ret = slice_from_s(z, 3, s_39); /* <-, line 175 */
				if (ret < 0)
					return ret;
			}
			break;
		case 4:
			{
				int			ret;

				ret = slice_from_s(z, 3, s_40); /* <-, line 176 */
				if (ret < 0)
					return ret;
			}
			break;
		case 5:
			{
				int			ret;

				ret = slice_from_s(z, 3, s_41); /* <-, line 177 */
				if (ret < 0)
					return ret;
			}
			break;
		case 6:
			{
				int			ret;

				ret = slice_from_s(z, 3, s_42); /* <-, line 181 */
				if (ret < 0)
					return ret;
			}
			break;
		case 7:
			{
				int			ret;

				ret = slice_from_s(z, 5, s_43); /* <-, line 182 */
				if (ret < 0)
					return ret;
			}
			break;
		case 8:
			{
				int			ret;

				ret = slice_from_s(z, 4, s_44); /* <-, line 183 */
				if (ret < 0)
					return ret;
			}
			break;
		case 9:
			{
				int			ret;

				ret = slice_from_s(z, 5, s_45); /* <-, line 184 */
				if (ret < 0)
					return ret;
			}
			break;
		case 10:
			{
				int			ret;

				ret = slice_from_s(z, 4, s_46); /* <-, line 185 */
				if (ret < 0)
					return ret;
			}
			break;
		case 11:
			{
				int			ret;

				ret = slice_from_s(z, 5, s_47); /* <-, line 186 */
				if (ret < 0)
					return ret;
			}
			break;
	}
	return 1;
}

static int
r_postlude(struct SN_env * z)
{
	if (!(z->B[0]))
		return 0;				/* Boolean test Y_found, line 202 */
	while (1)
	{							/* repeat, line 202 */
		int			c = z->c;

		while (1)
		{						/* goto, line 202 */
			int			c = z->c;

			z->bra = z->c;		/* [, line 202 */
			if (!(eq_s(z, 1, s_48)))
				goto lab1;
			z->ket = z->c;		/* ], line 202 */
			z->c = c;
			break;
	lab1:
			z->c = c;
			if (z->c >= z->l)
				goto lab0;
			z->c++;				/* goto, line 202 */
		}
		{
			int			ret;

			ret = slice_from_s(z, 1, s_49);		/* <-, line 202 */
			if (ret < 0)
				return ret;
		}
		continue;
lab0:
		z->c = c;
		break;
	}
	return 1;
}

extern int
english_ISO_8859_1_stem(struct SN_env * z)
{
	{
		int			c = z->c;	/* or, line 206 */

		{
			int			ret = r_exception1(z);

			if (ret == 0)
				goto lab1;		/* call exception1, line 206 */
			if (ret < 0)
				return ret;
		}
		goto lab0;
lab1:
		z->c = c;
		{
			int			c = z->c;		/* not, line 207 */

			{
				int			c = z->c + 3;

				if (0 > c || c > z->l)
					goto lab3;
				z->c = c;		/* hop, line 207 */
			}
			goto lab2;
	lab3:
			z->c = c;
		}
		goto lab0;
lab2:
		z->c = c;
		{
			int			c = z->c;		/* do, line 208 */

			{
				int			ret = r_prelude(z);

				if (ret == 0)
					goto lab4;	/* call prelude, line 208 */
				if (ret < 0)
					return ret;
			}
	lab4:
			z->c = c;
		}
		{
			int			c = z->c;		/* do, line 209 */

			{
				int			ret = r_mark_regions(z);

				if (ret == 0)
					goto lab5;	/* call mark_regions, line 209 */
				if (ret < 0)
					return ret;
			}
	lab5:
			z->c = c;
		}
		z->lb = z->c;
		z->c = z->l;			/* backwards, line 210 */

		{
			int			m = z->l - z->c;

			(void) m;			/* do, line 212 */
			{
				int			ret = r_Step_1a(z);

				if (ret == 0)
					goto lab6;	/* call Step_1a, line 212 */
				if (ret < 0)
					return ret;
			}
	lab6:
			z->c = z->l - m;
		}
		{
			int			m = z->l - z->c;

			(void) m;			/* or, line 214 */
			{
				int			ret = r_exception2(z);

				if (ret == 0)
					goto lab8;	/* call exception2, line 214 */
				if (ret < 0)
					return ret;
			}
			goto lab7;
	lab8:
			z->c = z->l - m;
			{
				int			m = z->l - z->c;

				(void) m;		/* do, line 216 */
				{
					int			ret = r_Step_1b(z);

					if (ret == 0)
						goto lab9;		/* call Step_1b, line 216 */
					if (ret < 0)
						return ret;
				}
		lab9:
				z->c = z->l - m;
			}
			{
				int			m = z->l - z->c;

				(void) m;		/* do, line 217 */
				{
					int			ret = r_Step_1c(z);

					if (ret == 0)
						goto lab10;		/* call Step_1c, line 217 */
					if (ret < 0)
						return ret;
				}
		lab10:
				z->c = z->l - m;
			}
			{
				int			m = z->l - z->c;

				(void) m;		/* do, line 219 */
				{
					int			ret = r_Step_2(z);

					if (ret == 0)
						goto lab11;		/* call Step_2, line 219 */
					if (ret < 0)
						return ret;
				}
		lab11:
				z->c = z->l - m;
			}
			{
				int			m = z->l - z->c;

				(void) m;		/* do, line 220 */
				{
					int			ret = r_Step_3(z);

					if (ret == 0)
						goto lab12;		/* call Step_3, line 220 */
					if (ret < 0)
						return ret;
				}
		lab12:
				z->c = z->l - m;
			}
			{
				int			m = z->l - z->c;

				(void) m;		/* do, line 221 */
				{
					int			ret = r_Step_4(z);

					if (ret == 0)
						goto lab13;		/* call Step_4, line 221 */
					if (ret < 0)
						return ret;
				}
		lab13:
				z->c = z->l - m;
			}
			{
				int			m = z->l - z->c;

				(void) m;		/* do, line 223 */
				{
					int			ret = r_Step_5(z);

					if (ret == 0)
						goto lab14;		/* call Step_5, line 223 */
					if (ret < 0)
						return ret;
				}
		lab14:
				z->c = z->l - m;
			}
		}
lab7:
		z->c = z->lb;
		{
			int			c = z->c;		/* do, line 226 */

			{
				int			ret = r_postlude(z);

				if (ret == 0)
					goto lab15; /* call postlude, line 226 */
				if (ret < 0)
					return ret;
			}
	lab15:
			z->c = c;
		}
	}
lab0:
	return 1;
}

extern struct SN_env *
english_ISO_8859_1_create_env(void)
{
	return SN_create_env(0, 2, 1);
}

extern void
english_ISO_8859_1_close_env(struct SN_env * z)
{
	SN_close_env(z);
}