english_stem.c

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

{
	if (!(z->I[1] <= z->c))
		return 0;
	return 1;
}

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

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

		(void) m;				/* try, line 58 */
		z->ket = z->c;			/* [, line 59 */
		among_var = find_among_b(z, a_1, 3);	/* substring, line 59 */
		if (!(among_var))
		{
			z->c = z->l - m;
			goto lab0;
		}
		z->bra = z->c;			/* ], line 59 */
		switch (among_var)
		{
			case 0:
				{
					z->c = z->l - m;
					goto lab0;
				}
			case 1:
				{
					int			ret;

					ret = slice_del(z); /* delete, line 61 */
					if (ret < 0)
						return ret;
				}
				break;
		}
lab0:
		;
	}
	z->ket = z->c;				/* [, line 64 */
	among_var = find_among_b(z, a_2, 6);		/* substring, line 64 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 64 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			{
				int			ret;

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

				(void) m;		/* or, line 67 */
				if (z->c <= z->lb)
					goto lab2;
				z->c--;			/* next, line 67 */
				if (z->c > z->lb)
					goto lab2;	/* atlimit, line 67 */
				{
					int			ret;

					ret = slice_from_s(z, 2, s_6);		/* <-, line 67 */
					if (ret < 0)
						return ret;
				}
				goto lab1;
		lab2:
				z->c = z->l - m;
				{
					int			ret;

					ret = slice_from_s(z, 1, s_7);		/* <-, line 67 */
					if (ret < 0)
						return ret;
				}
			}
	lab1:
			break;
		case 3:
			if (z->c <= z->lb)
				return 0;
			z->c--;				/* next, line 68 */
			while (1)
			{					/* gopast, line 68 */
				if (!(in_grouping_b(z, g_v, 97, 121)))
					goto lab3;
				break;
		lab3:
				if (z->c <= z->lb)
					return 0;
				z->c--;			/* gopast, line 68 */
			}
			{
				int			ret;

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

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

	z->ket = z->c;				/* [, line 74 */
	among_var = find_among_b(z, a_4, 6);		/* substring, line 74 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 74 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			{
				int			ret = r_R1(z);

				if (ret == 0)
					return 0;	/* call R1, line 76 */
				if (ret < 0)
					return ret;
			}
			{
				int			ret;

				ret = slice_from_s(z, 2, s_8);	/* <-, line 76 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			{
				int			m_test = z->l - z->c;		/* test, line 79 */

				while (1)
				{				/* gopast, line 79 */
					if (!(in_grouping_b(z, g_v, 97, 121)))
						goto lab0;
					break;
			lab0:
					if (z->c <= z->lb)
						return 0;
					z->c--;		/* gopast, line 79 */
				}
				z->c = z->l - m_test;
			}
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 79 */
				if (ret < 0)
					return ret;
			}
			{
				int			m_test = z->l - z->c;		/* test, line 80 */

				among_var = find_among_b(z, a_3, 13);	/* substring, line 80 */
				if (!(among_var))
					return 0;
				z->c = z->l - m_test;
			}
			switch (among_var)
			{
				case 0:
					return 0;
				case 1:
					{
						int			ret;

						{
							int			c = z->c;

							ret = insert_s(z, z->c, z->c, 1, s_9);		/* <+, line 82 */
							z->c = c;
						}
						if (ret < 0)
							return ret;
					}
					break;
				case 2:
					z->ket = z->c;		/* [, line 85 */
					if (z->c <= z->lb)
						return 0;
					z->c--;		/* next, line 85 */
					z->bra = z->c;		/* ], line 85 */
					{
						int			ret;

						ret = slice_del(z);		/* delete, line 85 */
						if (ret < 0)
							return ret;
					}
					break;
				case 3:
					if (z->c != z->I[0])
						return 0;		/* atmark, line 86 */
					{
						int			m_test = z->l - z->c;		/* test, line 86 */

						{
							int			ret = r_shortv(z);

							if (ret == 0)
								return 0;		/* call shortv, line 86 */
							if (ret < 0)
								return ret;
						}
						z->c = z->l - m_test;
					}
					{
						int			ret;

						{
							int			c = z->c;

							ret = insert_s(z, z->c, z->c, 1, s_10);		/* <+, line 86 */
							z->c = c;
						}
						if (ret < 0)
							return ret;
					}
					break;
			}
			break;
	}
	return 1;
}

static int
r_Step_1c(struct SN_env * z)
{
	z->ket = z->c;				/* [, line 93 */
	{
		int			m = z->l - z->c;

		(void) m;				/* or, line 93 */
		if (!(eq_s_b(z, 1, s_11)))
			goto lab1;
		goto lab0;
lab1:
		z->c = z->l - m;
		if (!(eq_s_b(z, 1, s_12)))
			return 0;
	}
lab0:
	z->bra = z->c;				/* ], line 93 */
	if (!(out_grouping_b(z, g_v, 97, 121)))
		return 0;
	{
		int			m = z->l - z->c;

		(void) m;				/* not, line 94 */
		if (z->c > z->lb)
			goto lab2;			/* atlimit, line 94 */
		return 0;
lab2:
		z->c = z->l - m;
	}
	{
		int			ret;

		ret = slice_from_s(z, 1, s_13); /* <-, line 95 */
		if (ret < 0)
			return ret;
	}
	return 1;
}

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

	z->ket = z->c;				/* [, line 99 */
	among_var = find_among_b(z, a_5, 24);		/* substring, line 99 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 99 */
	{
		int			ret = r_R1(z);

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

				ret = slice_from_s(z, 4, s_14); /* <-, line 100 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			{
				int			ret;

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

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

				ret = slice_from_s(z, 4, s_17); /* <-, line 103 */
				if (ret < 0)
					return ret;
			}
			break;
		case 5:
			{
				int			ret;

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

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

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

				ret = slice_from_s(z, 2, s_21); /* <-, line 110 */
				if (ret < 0)
					return ret;
			}
			break;
		case 9:
			{
				int			ret;

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

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

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

				ret = slice_from_s(z, 3, s_25); /* <-, line 117 */
				if (ret < 0)
					return ret;
			}
			break;
		case 13:
			if (!(eq_s_b(z, 1, s_26)))
				return 0;
			{
				int			ret;

				ret = slice_from_s(z, 2, s_27); /* <-, line 118 */
				if (ret < 0)
					return ret;
			}
			break;
		case 14:
			{
				int			ret;

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

				ret = slice_from_s(z, 4, s_29); /* <-, line 120 */
				if (ret < 0)
					return ret;
			}
			break;
		case 16:
			if (!(in_grouping_b(z, g_valid_LI, 99, 116)))
				return 0;
			{
				int			ret;

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

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

	z->ket = z->c;				/* [, line 126 */
	among_var = find_among_b(z, a_6, 9);		/* substring, line 126 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 126 */
	{
		int			ret = r_R1(z);

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

				ret = slice_from_s(z, 4, s_30); /* <-, line 127 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			{
				int			ret;

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

				ret = slice_from_s(z, 2, s_32); /* <-, line 129 */
				if (ret < 0)
					return ret;
			}
			break;
		case 4:
			{
				int			ret;

				ret = slice_from_s(z, 2, s_33); /* <-, line 131 */
				if (ret < 0)
					return ret;
			}
			break;
		case 5:
			{
				int			ret;

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

				if (ret == 0)
					return 0;	/* call R2, line 135 */
				if (ret < 0)
					return ret;
			}
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 135 */
				if (ret < 0)