russian_stem.c

PostgreSQL7.4.6 for Linux

			if (z->c >= z->l)
				goto lab0;
			z->c++;
		}
		z->I[1] = z->c;			/* setmark p2, line 102 */
lab0:
		z->c = c;
	}
	return 1;
}

static int
r_R2(struct SN_env * z)
{
	if (!(z->I[1] <= z->c))
		return 0;
	return 1;
}

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

	z->ket = z->c;				/* [, line 111 */
	among_var = find_among_b(z, a_0, 9);		/* substring, line 111 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 111 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			{
				int			m = z->l - z->c;	/* or, line 115 */

				if (!(eq_s_b(z, 1, s_0)))
					goto lab1;
				goto lab0;
		lab1:
				z->c = z->l - m;
				if (!(eq_s_b(z, 1, s_1)))
					return 0;
			}
	lab0:
			slice_del(z);		/* delete, line 115 */
			break;
		case 2:
			slice_del(z);		/* delete, line 122 */
			break;
	}
	return 1;
}

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

	z->ket = z->c;				/* [, line 127 */
	among_var = find_among_b(z, a_1, 26);		/* substring, line 127 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 127 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			slice_del(z);		/* delete, line 136 */
			break;
	}
	return 1;
}

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

	if (!r_adjective(z))
		return 0;				/* call adjective, line 141 */
	{
		int			m = z->l - z->c;	/* try, line 148 */

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

					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:
				slice_del(z);	/* delete, line 154 */
				break;
			case 2:
				slice_del(z);	/* delete, line 161 */
				break;
		}
lab0:
		;
	}
	return 1;
}

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

	z->ket = z->c;				/* [, line 168 */
	among_var = find_among_b(z, a_3, 2);		/* substring, line 168 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 168 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			slice_del(z);		/* delete, line 171 */
			break;
	}
	return 1;
}

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

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

				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:
			slice_del(z);		/* delete, line 182 */
			break;
		case 2:
			slice_del(z);		/* delete, line 190 */
			break;
	}
	return 1;
}

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

	z->ket = z->c;				/* [, line 199 */
	among_var = find_among_b(z, a_5, 36);		/* substring, line 199 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 199 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			slice_del(z);		/* delete, line 206 */
			break;
	}
	return 1;
}

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

	z->ket = z->c;				/* [, line 215 */
	among_var = find_among_b(z, a_6, 2);		/* substring, line 215 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 215 */
	if (!r_R2(z))
		return 0;				/* call R2, line 215 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			slice_del(z);		/* delete, line 218 */
			break;
	}
	return 1;
}

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

	z->ket = z->c;				/* [, line 223 */
	among_var = find_among_b(z, a_7, 4);		/* substring, line 223 */
	if (!(among_var))
		return 0;
	z->bra = z->c;				/* ], line 223 */
	switch (among_var)
	{
		case 0:
			return 0;
		case 1:
			slice_del(z);		/* delete, line 227 */
			z->ket = z->c;		/* [, line 228 */
			if (!(eq_s_b(z, 1, s_6)))
				return 0;
			z->bra = z->c;		/* ], line 228 */
			if (!(eq_s_b(z, 1, s_7)))
				return 0;
			slice_del(z);		/* delete, line 228 */
			break;
		case 2:
			if (!(eq_s_b(z, 1, s_8)))
				return 0;
			slice_del(z);		/* delete, line 231 */
			break;
		case 3:
			slice_del(z);		/* delete, line 233 */
			break;
	}
	return 1;
}

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

		if (!r_mark_regions(z))
			goto lab0;			/* call mark_regions, line 240 */
lab0:
		z->c = c;
	}
	z->lb = z->c;
	z->c = z->l;				/* backwards, line 241 */

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

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

			{
				int			m = z->l - z->c;	/* or, line 243 */

				if (!r_perfective_gerund(z))
					goto lab3;	/* call perfective_gerund, line 243 */
				goto lab2;
		lab3:
				z->c = z->l - m;
				{
					int			m = z->l - z->c;		/* try, line 244 */

					if (!r_reflexive(z))
					{
						z->c = z->l - m;
						goto lab4;
					}			/* call reflexive, line 244 */
			lab4:
					;
				}
				{
					int			m = z->l - z->c;		/* or, line 245 */

					if (!r_adjectival(z))
						goto lab6;		/* call adjectival, line 245 */
					goto lab5;
			lab6:
					z->c = z->l - m;
					if (!r_verb(z))
						goto lab7;		/* call verb, line 245 */
					goto lab5;
			lab7:
					z->c = z->l - m;
					if (!r_noun(z))
						goto lab1;		/* call noun, line 245 */
				}
		lab5:
				;
			}
	lab2:
	lab1:
			z->c = z->l - m;
		}
		{
			int			m = z->l - z->c;		/* try, line 248 */

			z->ket = z->c;		/* [, line 248 */
			if (!(eq_s_b(z, 1, s_9)))
			{
				z->c = z->l - m;
				goto lab8;
			}
			z->bra = z->c;		/* ], line 248 */
			slice_del(z);		/* delete, line 248 */
	lab8:
			;
		}
		{
			int			m = z->l - z->c;		/* do, line 251 */

			if (!r_derivational(z))
				goto lab9;		/* call derivational, line 251 */
	lab9:
			z->c = z->l - m;
		}
		{
			int			m = z->l - z->c;		/* do, line 252 */

			if (!r_tidy_up(z))
				goto lab10;		/* call tidy_up, line 252 */
	lab10:
			z->c = z->l - m;
		}
		z->lb = m3;
	}
	z->c = z->lb;
	return 1;
}

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

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