/*
 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
 * Released under the terms of the GNU GPL v2.0.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LKC_DIRECT_LINK
#include "lkc.h"

#define DEBUG_EXPR	0

struct expr *expr_alloc_symbol(struct symbol *sym)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = E_SYMBOL;
	e->left.sym = sym;
	return e;
}

struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.expr = ce;
	return e;
}

struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.expr = e1;
	e->right.expr = e2;
	return e;
}

struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.sym = s1;
	e->right.sym = s2;
	return e;
}

struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
{
	if (!e1)
		return e2;
	return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
}

struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
{
	if (!e1)
		return e2;
	return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
}

struct expr *expr_copy(struct expr *org)
{
	struct expr *e;

	if (!org)
		return NULL;

	e = malloc(sizeof(*org));
	memcpy(e, org, sizeof(*org));
	switch (org->type) {
	case E_SYMBOL:
		e->left = org->left;
		break;
	case E_NOT:
		e->left.expr = expr_copy(org->left.expr);
		break;
	case E_EQUAL:
	case E_UNEQUAL:
		e->left.sym = org->left.sym;
		e->right.sym = org->right.sym;
		break;
	case E_AND:
	case E_OR:
	case E_CHOICE:
		e->left.expr = expr_copy(org->left.expr);
		e->right.expr = expr_copy(org->right.expr);
		break;
	default:
		printf("can't copy type %d\n", e->type);
		free(e);
		e = NULL;
		break;
	}

	return e;
}

void expr_free(struct expr *e)
{
	if (!e)
		return;

	switch (e->type) {
	case E_SYMBOL:
		break;
	case E_NOT:
		expr_free(e->left.expr);
		return;
	case E_EQUAL:
	case E_UNEQUAL:
		break;
	case E_OR:
	case E_AND:
		expr_free(e->left.expr);
		expr_free(e->right.expr);
		break;
	default:
		printf("how to free type %d?\n", e->type);
		break;
	}
	free(e);
}

static int trans_count;

#define e1 (*ep1)
#define e2 (*ep2)

static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
{
	if (e1->type == type) {
		__expr_eliminate_eq(type, &e1->left.expr, &e2);
		__expr_eliminate_eq(type, &e1->right.expr, &e2);
		return;
	}
	if (e2->type == type) {
		__expr_eliminate_eq(type, &e1, &e2->left.expr);
		__expr_eliminate_eq(type, &e1, &e2->right.expr);
		return;
	}
	if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
	    e1->left.sym == e2->left.sym && (e1->left.sym->flags & (SYMBOL_YES|SYMBOL_NO)))
		return;
	if (!expr_eq(e1, e2))
		return;
	trans_count++;
	expr_free(e1); expr_free(e2);
	switch (type) {
	case E_OR:
		e1 = expr_alloc_symbol(&symbol_no);
		e2 = expr_alloc_symbol(&symbol_no);
		break;
	case E_AND:
		e1 = expr_alloc_symbol(&symbol_yes);
		e2 = expr_alloc_symbol(&symbol_yes);
		break;
	default:
		;
	}
}

void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
{
	if (!e1 || !e2)
		return;
	switch (e1->type) {
	case E_OR:
	case E_AND:
		__expr_eliminate_eq(e1->type, ep1, ep2);
	default:
		;
	}
	if (e1->type != e2->type) switch (e2->type) {
	case E_OR:
	case E_AND:
		__expr_eliminate_eq(e2->type, ep1, ep2);
	default:
		;
	}
	e1 = expr_eliminate_yn(e1);
	e2 = expr_eliminate_yn(e2);
}

#undef e1
#undef e2

int expr_eq(struct expr *e1, struct expr *e2)
{
	int res, old_count;

	if (e1->type != e2->type)
		return 0;
	switch (e1->type) {
	case E_EQUAL:
	case E_UNEQUAL:
		return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
	case E_SYMBOL:
		return e1->left.sym == e2->left.sym;
	case E_NOT:
		return expr_eq(e1->left.expr, e2->left.expr);
	case E_AND:
	case E_OR:
		e1 = expr_copy(e1);
		e2 = expr_copy(e2);
		old_count = trans_count;
		expr_eliminate_eq(&e1, &e2);
		res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
		       e1->left.sym == e2->left.sym);
		expr_free(e1);
		expr_free(e2);
		trans_count = old_count;
		return res;
	case E_CHOICE:
	case E_RANGE:
	case E_NONE:
		/* panic */;
	}

	if (DEBUG_EXPR) {
		expr_fprint(e1, stdout);
		printf(" = ");
		expr_fprint(e2, stdout);
		printf(" ?\n");
	}

	return 0;
}

struct expr *expr_eliminate_yn(struct expr *e)
{
	struct expr *tmp;

	if (e) switch (e->type) {
	case E_AND:
		e->left.expr = expr_eliminate_yn(e->left.expr);
		e->right.expr = expr_eliminate_yn(e->right.expr);
		if (e->left.expr->type == E_SYMBOL) {
			if (e->left.expr->left.sym == &symbol_no) {
				expr_free(e->left.expr);
				expr_free(e->right.expr);
				e->type = E_SYMBOL;
				e->left.sym = &symbol_no;
				e->right.expr = NULL;
				return e;
			} else if (e->left.expr->left.sym == &symbol_yes) {
				free(e->left.expr);
				tmp = e->right.expr;
				*e = *(e->right.expr);
				free(tmp);
				return e;
			}
		}
		if (e->right.expr->type == E_SYMBOL) {
			if (e->right.expr->left.sym == &symbol_no) {
				expr_free(e->left.expr);
				expr_free(e->right.expr);
				e->type = E_SYMBOL;
				e->left.sym = &symbol_no;
				e->right.expr = NULL;
				return e;
			} else if (e->right.expr->left.sym == &symbol_yes) {
				free(e->right.expr);
				tmp = e->left.expr;
				*e = *(e->left.expr);
				free(tmp);
				return e;
			}
		}
		break;
	case E_OR:
		e->left.expr = expr_eliminate_yn(e->left.expr);
		e->right.expr = expr_eliminate_yn(e->right.expr);
		if (e->left.expr->type == E_SYMBOL) {
			if (e->left.expr->left.sym == &symbol_no) {
				free(e->left.expr);
				tmp = e->right.expr;
				*e = *(e->right.expr);
				free(tmp);
				return e;
			} else if (e->left.expr->left.sym == &symbol_yes) {
				expr_free(e->left.expr);
				expr_free(e->right.expr);
				e->type = E_SYMBOL;
				e->left.sym = &symbol_yes;
				e->right.expr = NULL;
				return e;
			}
		}
		if (e->right.expr->type == E_SYMBOL) {
			if (e->right.expr->left.sym == &symbol_no) {
				free(e->right.expr);
				tmp = e->left.expr;
				*e = *(e->left.expr);
				free(tmp);
				return e;
			} else if (e->right.expr->left.sym == &symbol_yes) {
				expr_free(e->left.expr);
				expr_free(e->right.expr);
				e->type = E_SYMBOL;
				e->left.sym = &symbol_yes;
				e->right.expr = NULL;
				return e;
			}
		}
		break;
	default:
		;
	}
	return e;
}

/*
 * bool FOO!=n => FOO
 */
struct expr *expr_trans_bool(struct expr *e)
{
	if (!e)
		return NULL;
	switch (e->type) {
	case E_AND:
	case E_OR:
	case E_NOT:
		e->left.expr = expr_trans_bool(e->left.expr);
		e->right.expr = expr_trans_bool(e->right.expr);
		break;
	case E_UNEQUAL:
		// FOO!=n -> FOO
		if (e->left.sym->type == S_TRISTATE) {
			if (e->right.sym == &symbol_no) {
				e->type = E_SYMBOL;
				e->right.sym = NULL;
			}
		}
		break;
	default:
		;
	}
	return e;
}

/*
 * e1 || e2 -> ?
 */
struct expr *expr_join_or(struct expr *e1, struct expr *e2)
{
	struct expr *tmp;
	struct symbol *sym1, *sym2;

	if (expr_eq(e1, e2))
		return expr_copy(e1);
	if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
		return NULL;
	if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
		return NULL;
	if (e1->type == E_NOT) {
		tmp = e1->left.expr;
		if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
			return NULL;
		sym1 = tmp->left.sym;
	} else
		sym1 = e1->left.sym;
	if (e2->type == E_NOT) {
		if (e2->left.expr->type != E_SYMBOL)
			return NULL;
		sym2 = e2->left.expr->left.sym;
	} else
		sym2 = e2->left.sym;
	if (sym1 != sym2)
		return NULL;
	if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
		return NULL;
	if (sym1->type == S_TRISTATE) {
		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) ||
		     (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) {
			// (a='y') || (a='m') -> (a!='n')
			return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_no);
		}
		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
		    ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) ||
		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) {
			// (a='y') || (a='n') -> (a!='m')
			return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_mod);
		}
		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
		    ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) ||
		     (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) {
			// (a='m') || (a='n') -> (a!='y')
			return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_yes);
		}
	}
	if (sym1->type == S_BOOLEAN && sym1 == sym2) {
		if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
		    (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
			return expr_alloc_symbol(&symbol_yes);
	}

	if (DEBUG_EXPR) {
		printf("optimize (");
		expr_fprint(e1, stdout);
		printf(") || (");
		expr_fprint(e2, stdout);
		printf(")?\n");
	}
	return NULL;
}

struct expr *expr_join_and(struct expr *e1, struct expr *e2)
{
	struct expr *tmp;
	struct symbol *sym1, *sym2;

	if (expr_eq(e1, e2))
		return expr_copy(e1);
	if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
		return NULL;
	if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
		return NULL;
	if (e1->type == E_NOT) {
		tmp = e1->left.expr;
		if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
			return NULL;
		sym1 = tmp->left.sym;
	} else
		sym1 = e1->left.sym;
	if (e2->type == E_NOT) {
		if (e2->left.expr->type != E_SYMBOL)
			return NULL;
		sym2 = e2->left.expr->left.sym;
	} else
		sym2 = e2->left.sym;
	if (sym1 != sym2)
		return NULL;
	if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
		return NULL;

	if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
	    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
		// (a) && (a='y') -> (a='y')
		return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);

	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
		// (a) && (a!='n') -> (a)
		return expr_alloc_symbol(sym1);

	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) ||
	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod))
		// (a) && (a!='m') -> (a='y')
		return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);

	if (sym1->type == S_TRISTATE) {
		if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) {
			// (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
			sym2 = e1->right.sym;
			if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
				return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2)
							     : expr_alloc_symbol(&symbol_no);
		}
		if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
			// (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b'
			sym2 = e2->right.sym;
			if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST))
				return sym2 != e1->right.sym ? expr<style>pre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight { background: #ffffff; }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="c">#</span>
<span class="c"># Copyright (C) 2011 OpenWrt.org</span>
<span class="c">#</span>
<span class="c"># This is free software, licensed under the GNU General Public License v2.</span>
<span class="c"># See /LICENSE for more information.</span>
<span class="c">#</span>

<span class="nv">LIB_MENU</span><span class="o">:=</span>Libraries

<span class="cp">define KernelPackage/lib-crc-ccitt</span>
  SUBMENU:<span class="o">=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>CRC-CCITT support
  KCONFIG:<span class="o">=</span>CONFIG_CRC_CCITT
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/crc-ccitt.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,crc-ccitt<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-crc-ccitt/description</span>
 Kernel module <span class="k">for</span> CRC-CCITT support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-crc-ccitt</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-crc-itu-t</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>CRC ITU-T V.41 support
  KCONFIG:<span class="o">=</span>CONFIG_CRC_ITU_T
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/crc-itu-t.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,crc-itu-t<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-crc-itu-t/description</span>
 Kernel module <span class="k">for</span> CRC ITU-T V.41 support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-crc-itu-t</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-crc7</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>CRC7 support
  KCONFIG:<span class="o">=</span>CONFIG_CRC7
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/crc7.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,crc7<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-crc7/description</span>
 Kernel module <span class="k">for</span> CRC7 support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-crc7</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-crc8</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>CRC8 support
  KCONFIG:<span class="o">=</span>CONFIG_CRC8
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/crc8.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,crc8<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-crc8/description</span>
 Kernel module <span class="k">for</span> CRC8 support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-crc8</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-crc16</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>CRC16 support
  KCONFIG:<span class="o">=</span>CONFIG_CRC16
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/crc16.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoLoad,20,crc16,1<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-crc16/description</span>
 Kernel module <span class="k">for</span> CRC16 support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-crc16</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-crc32c</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>CRC32 support
  KCONFIG:<span class="o">=</span>CONFIG_LIBCRC32C
  DEPENDS:<span class="o">=</span>+kmod-crypto-crc32c
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/libcrc32c.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,libcrc32c<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-crc32c/description</span>
 Kernel module <span class="k">for</span> CRC32 support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-crc32c</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-lzo</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>LZO support
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
	CONFIG_LZO_COMPRESS <span class="se">\</span>
	CONFIG_LZO_DECOMPRESS
  FILES:<span class="o">=</span> <span class="se">\</span>
	<span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/lzo/lzo_compress.ko <span class="se">\</span>
	<span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/lzo/lzo_decompress.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,lzo_compress lzo_decompress<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-lzo/description</span>
 Kernel module <span class="k">for</span> LZO compression/decompression support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-lzo</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-lz4</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>LZ4 support
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
	CONFIG_LZ4_COMPRESS <span class="se">\</span>
	CONFIG_LZ4_DECOMPRESS
  FILES:<span class="o">=</span> <span class="se">\</span>
	<span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/lz4/lz4_compress.ko <span class="se">\</span>
	<span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/lz4/lz4_decompress.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,lz4_compress lz4_decompress<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-lz4/description</span>
 Kernel module <span class="k">for</span> LZ4 compression/decompression support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-lz4</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-raid6</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>RAID6 algorithm support
  HIDDEN:<span class="o">=</span><span class="m">1</span>
  KCONFIG:<span class="o">=</span>CONFIG_RAID6_PQ
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/raid6/raid6_pq.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,raid6_pq<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-raid6/description</span>
 Kernel module <span class="k">for</span> RAID6 algorithms
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-raid6</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-xor</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>XOR blocks algorithm support
  HIDDEN:<span class="o">=</span><span class="m">1</span>
  KCONFIG:<span class="o">=</span>CONFIG_XOR_BLOCKS
<span class="cp">ifneq ($(wildcard $(LINUX_DIR)/arch/arm/lib/xor-neon.ko),)</span>
  FILES:<span class="o">=</span> <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/crypto/xor.ko <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/arch/arm/lib/xor-neon.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,xor-neon xor<span class="k">)</span>
<span class="cp">else</span>
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/crypto/xor.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,xor<span class="k">)</span>
<span class="cp">endif</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-xor/description</span>
 Kernel module <span class="k">for</span> XOR blocks algorithms
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-xor</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-textsearch</span>
<span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Textsearch support
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
    <span class="nv">CONFIG_TEXTSEARCH</span><span class="o">=</span>y <span class="se">\</span>
    CONFIG_TEXTSEARCH_KMP <span class="se">\</span>
    CONFIG_TEXTSEARCH_BM <span class="se">\</span>
    CONFIG_TEXTSEARCH_FSM
  FILES:<span class="o">=</span> <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/ts_kmp.ko <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/ts_bm.ko <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/ts_fsm.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,ts_kmp ts_bm ts_fsm<span class="k">)</span>
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-textsearch</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-zlib</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Zlib support
  KCONFIG:<span class="o">=</span> <span class="se">\</span>
    CONFIG_ZLIB_DEFLATE <span class="se">\</span>
    CONFIG_ZLIB_INFLATE
  FILES:<span class="o">=</span> <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/zlib_deflate/zlib_deflate.ko <span class="se">\</span>
    <span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/zlib_inflate/zlib_inflate.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,zlib_deflate zlib_inflate<span class="k">)</span>
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-zlib</span><span class="k">))</span>


<span class="cp">define KernelPackage/lib-cordic</span>
  <span class="nv">SUBMENU</span><span class="o">:=</span><span class="k">$(</span>LIB_MENU<span class="k">)</span>
  TITLE:<span class="o">=</span>Cordic <span class="k">function</span> support
  KCONFIG:<span class="o">=</span>CONFIG_CORDIC
  FILES:<span class="o">=</span><span class="k">$(</span>LINUX_DIR<span class="k">)</span>/lib/cordic.ko
  AUTOLOAD:<span class="o">=</span><span class="k">$(</span>call AutoProbe,cordic<span class="k">)</span>
<span class="cp">endef</span>

<span class="cp">define KernelPackage/lib-cordic/description</span>
 Kernel module <span class="k">for</span> Cordic <span class="k">function</span> support
<span class="cp">endef</span>

<span class="k">$(</span><span class="nv">eval</span> <span class="k">$(</span><span class="nv">call</span> <span class="nv">KernelPackage</span>,<span class="nv">lib-cordic</span><span class="k">))</span>
</pre></div>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.25.1</a>) at 2026-02-23 03:19:48 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>