russian_stem.c

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

			return 0;
		case 1:
			{
				int			ret;

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

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

	{
		int			ret = r_adjective(z);

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

		(void) m;				/* try, line 111 */
		z->ket = z->c;			/* [, line 112 */
		among_var = find_among_b(z, a_2, 8);	/* substring, line 112 */
		if (!(among_var))
		{
			z->c = z->l - m;
			goto lab0;
		}
		z->bra = z->c;			/* ], line 112 */
		switch (among_var)
		{
			case 0:
				{
					z->c = z->l - m;
					goto lab0;
				}
			case 1:
				{
					int			m = z->l - z->c;

					(void) m;	/* or, line 117 */
					if (!(eq_s_b(z, 1, s_2)))
						goto lab2;
					goto lab1;
			lab2:
					z->c = z->l - m;
					if (!(eq_s_b(z, 1, s_3)))
					{
						z->c = z->l - m;
						goto lab0;
					}
				}
		lab1:
				{
					int			ret;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				ret = slice_del(z);		/* delete, line 190 */
				if (ret < 0)
					return ret;
			}
			z->ket = z->c;		/* [, line 191 */
			if (!(eq_s_b(z, 1, s_6)))
				return 0;
			z->bra = z->c;		/* ], line 191 */
			if (!(eq_s_b(z, 1, s_7)))
				return 0;
			{
				int			ret;

				ret = slice_del(z);		/* delete, line 191 */
				if (ret < 0)
					return ret;
			}
			break;
		case 2:
			if (!(eq_s_b(z, 1, s_8)))
				return 0;
			{
				int			ret;

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

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

extern int
russian_KOI8_R_stem(struct SN_env * z)
{
	{
		int			c = z->c;	/* do, line 203 */

		{
			int			ret = r_mark_regions(z);

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

	{
		int			m3;			/* setlimit, line 204 */
		int			m = z->l - z->c;

		(void) m;
		if (z->c < z->I[0])
			return 0;
		z->c = z->I[0];			/* tomark, line 204 */
		m3 = z->lb;
		z->lb = z->c;
		z->c = z->l - m;
		{
			int			m = z->l - z->c;

			(void) m;			/* do, line 205 */
			{
				int			m = z->l - z->c;

				(void) m;		/* or, line 206 */
				{
					int			ret = r_perfective_gerund(z);

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

					(void) m;	/* try, line 207 */
					{
						int			ret = r_reflexive(z);

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

					(void) m;	/* or, line 208 */
					{
						int			ret = r_adjectival(z);

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

						if (ret == 0)
							goto lab7;	/* call verb, line 208 */
						if (ret < 0)
							return ret;
					}
					goto lab5;
			lab7:
					z->c = z->l - m;
					{
						int			ret = r_noun(z);

						if (ret == 0)
							goto lab1;	/* call noun, line 208 */
						if (ret < 0)
							return ret;
					}
				}
		lab5:
				;
			}
	lab2:
	lab1:
			z->c = z->l - m;
		}
		{
			int			m = z->l - z->c;

			(void) m;			/* try, line 211 */
			z->ket = z->c;		/* [, line 211 */
			if (!(eq_s_b(z, 1, s_9)))
			{
				z->c = z->l - m;
				goto lab8;
			}
			z->bra = z->c;		/* ], line 211 */
			{
				int			ret;

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

			(void) m;			/* do, line 214 */
			{
				int			ret = r_derivational(z);

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

			(void) m;			/* do, line 215 */
			{
				int			ret = r_tidy_up(z);

				if (ret == 0)
					goto lab10; /* call tidy_up, line 215 */
				if (ret < 0)
					return ret;
			}
	lab10:
			z->c = z->l - m;
		}
		z->lb = m3;
	}
	z->c = z->lb;
	return 1;
}

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

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