[thirdparty/u-boot.git] / cmd / test.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2000-2009
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 */

#include <common.h>
#include <command.h>
#include <fs.h>
#include <log.h>

#define OP_INVALID	0
#define OP_NOT		1
#define OP_OR		2
#define OP_AND		3
#define OP_STR_EMPTY	4
#define OP_STR_NEMPTY	5
#define OP_STR_EQ	6
#define OP_STR_NEQ	7
#define OP_STR_LT	8
#define OP_STR_GT	9
#define OP_INT_EQ	10
#define OP_INT_NEQ	11
#define OP_INT_LT	12
#define OP_INT_LE	13
#define OP_INT_GT	14
#define OP_INT_GE	15
#define OP_FILE_EXISTS	16

const struct {
	int arg;
	const char *str;
	int op;
	int adv;
} op_adv[] = {
	{1, "=", OP_STR_EQ, 3},
	{1, "!=", OP_STR_NEQ, 3},
	{1, "<", OP_STR_LT, 3},
	{1, ">", OP_STR_GT, 3},
	{1, "-eq", OP_INT_EQ, 3},
	{1, "-ne", OP_INT_NEQ, 3},
	{1, "-lt", OP_INT_LT, 3},
	{1, "-le", OP_INT_LE, 3},
	{1, "-gt", OP_INT_GT, 3},
	{1, "-ge", OP_INT_GE, 3},
	{0, "!", OP_NOT, 1},
	{0, "-o", OP_OR, 1},
	{0, "-a", OP_AND, 1},
	{0, "-z", OP_STR_EMPTY, 2},
	{0, "-n", OP_STR_NEMPTY, 2},
	{0, "-e", OP_FILE_EXISTS, 4},
};

static int do_test(struct cmd_tbl *cmdtp, int flag, int argc,
		   char *const argv[])
{
	char * const *ap;
	int i, op, left, adv, expr, last_expr, last_unop, last_binop;

	/* args? */
	if (argc < 3)
		return 1;

#ifdef DEBUG
	{
		debug("test(%d):", argc);
		left = 1;
		while (argv[left])
			debug(" '%s'", argv[left++]);
	}
#endif

	left = argc - 1;
	ap = argv + 1;
	expr = 0;
	last_unop = OP_INVALID;
	last_binop = OP_INVALID;
	last_expr = -1;
	while (left > 0) {
		for (i = 0; i < ARRAY_SIZE(op_adv); i++) {
			if (left <= op_adv[i].arg)
				continue;
			if (!strcmp(ap[op_adv[i].arg], op_adv[i].str)) {
				op = op_adv[i].op;
				adv = op_adv[i].adv;
				break;
			}
		}
		if (i == ARRAY_SIZE(op_adv)) {
			expr = 1;
			break;
		}
		if (left < adv) {
			expr = 1;
			break;
		}

		switch (op) {
		case OP_STR_EMPTY:
			expr = strlen(ap[1]) == 0 ? 1 : 0;
			break;
		case OP_STR_NEMPTY:
			expr = strlen(ap[1]) == 0 ? 0 : 1;
			break;
		case OP_STR_EQ:
			expr = strcmp(ap[0], ap[2]) == 0;
			break;
		case OP_STR_NEQ:
			expr = strcmp(ap[0], ap[2]) != 0;
			break;
		case OP_STR_LT:
			expr = strcmp(ap[0], ap[2]) < 0;
			break;
		case OP_STR_GT:
			expr = strcmp(ap[0], ap[2]) > 0;
			break;
		case OP_INT_EQ:
			expr = simple_strtol(ap[0], NULL, 0) ==
					simple_strtol(ap[2], NULL, 0);
			break;
		case OP_INT_NEQ:
			expr = simple_strtol(ap[0], NULL, 0) !=
					simple_strtol(ap[2], NULL, 0);
			break;
		case OP_INT_LT:
			expr = simple_strtol(ap[0], NULL, 0) <
					simple_strtol(ap[2], NULL, 0);
			break;
		case OP_INT_LE:
			expr = simple_strtol(ap[0], NULL, 0) <=
					simple_strtol(ap[2], NULL, 0);
			break;
		case OP_INT_GT:
			expr = simple_strtol(ap[0], NULL, 0) >
					simple_strtol(ap[2], NULL, 0);
			break;
		case OP_INT_GE:
			expr = simple_strtol(ap[0], NULL, 0) >=
					simple_strtol(ap[2], NULL, 0);
			break;
		case OP_FILE_EXISTS:
			expr = file_exists(ap[1], ap[2], ap[3], FS_TYPE_ANY);
			break;
		}

		switch (op) {
		case OP_OR:
			last_expr = expr;
			last_binop = OP_OR;
			break;
		case OP_AND:
			last_expr = expr;
			last_binop = OP_AND;
			break;
		case OP_NOT:
			if (last_unop == OP_NOT)
				last_unop = OP_INVALID;
			else
				last_unop = OP_NOT;
			break;
		default:
			if (last_unop == OP_NOT) {
				expr = !expr;
				last_unop = OP_INVALID;
			}

			if (last_binop == OP_OR)
				expr = last_expr || expr;
			else if (last_binop == OP_AND)
				expr = last_expr && expr;
			last_binop = OP_INVALID;

			break;
		}

		ap += adv; left -= adv;
	}

	expr = !expr;

	debug (": returns %d\n", expr);

	return expr;
}

#undef true
#undef false

U_BOOT_CMD(
	test,	CONFIG_SYS_MAXARGS,	1,	do_test,
	"minimal test like /bin/sh",
	"[args..]"
);

static int do_false(struct cmd_tbl *cmdtp, int flag, int argc,
		    char *const argv[])
{
	return 1;
}

U_BOOT_CMD(
	false,	CONFIG_SYS_MAXARGS,	1,	do_false,
	"do nothing, unsuccessfully",
	NULL
);

static int do_true(struct cmd_tbl *cmdtp, int flag, int argc,
		   char *const argv[])
{
	return 0;
}

U_BOOT_CMD(
	true,	CONFIG_SYS_MAXARGS,	1,	do_true,
	"do nothing, successfully",
	NULL
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
6b8f5ad1 PT	2	/*
	3	* Copyright 2000-2009
	4	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6b8f5ad1 PT	5	*/
	6
	7	#include <common.h>
	8	#include <command.h>
e5e897c0	9	#include <fs.h>
f7ae49fc	10	#include <log.h>
6b8f5ad1	11
490ba833	12	#define OP_INVALID 0
d9b651ce	13	#define OP_NOT 1
490ba833 SW	14	#define OP_OR 2
	15	#define OP_AND 3
	16	#define OP_STR_EMPTY 4
	17	#define OP_STR_NEMPTY 5
	18	#define OP_STR_EQ 6
	19	#define OP_STR_NEQ 7
	20	#define OP_STR_LT 8
	21	#define OP_STR_GT 9
	22	#define OP_INT_EQ 10
	23	#define OP_INT_NEQ 11
	24	#define OP_INT_LT 12
	25	#define OP_INT_LE 13
	26	#define OP_INT_GT 14
	27	#define OP_INT_GE 15
e5e897c0	28	#define OP_FILE_EXISTS 16
490ba833 SW	29
	30	const struct {
	31	int arg;
	32	const char *str;
	33	int op;
	34	int adv;
	35	} op_adv[] = {
490ba833 SW	36	{1, "=", OP_STR_EQ, 3},
	37	{1, "!=", OP_STR_NEQ, 3},
	38	{1, "<", OP_STR_LT, 3},
	39	{1, ">", OP_STR_GT, 3},
	40	{1, "-eq", OP_INT_EQ, 3},
	41	{1, "-ne", OP_INT_NEQ, 3},
	42	{1, "-lt", OP_INT_LT, 3},
	43	{1, "-le", OP_INT_LE, 3},
	44	{1, "-gt", OP_INT_GT, 3},
	45	{1, "-ge", OP_INT_GE, 3},
d9b651ce	46	{0, "!", OP_NOT, 1},
4c80f29e SW	47	{0, "-o", OP_OR, 1},
	48	{0, "-a", OP_AND, 1},
	49	{0, "-z", OP_STR_EMPTY, 2},
	50	{0, "-n", OP_STR_NEMPTY, 2},
e5e897c0	51	{0, "-e", OP_FILE_EXISTS, 4},
490ba833 SW	52	};
490ba833 SW	53
09140113 SG	54	static int do_test(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	55	char *const argv[])
6b8f5ad1	56	{
54841ab5	57	char * const *ap;
d9b651ce	58	int i, op, left, adv, expr, last_expr, last_unop, last_binop;
6b8f5ad1 PT	59
	60	/* args? */
	61	if (argc < 3)
	62	return 1;
	63
b0fe6abd	64	#ifdef DEBUG
6b8f5ad1	65	{
b0fe6abd	66	debug("test(%d):", argc);
6b8f5ad1 PT	67	left = 1;
6b8f5ad1 PT	68	while (argv[left])
b0fe6abd	69	debug(" '%s'", argv[left++]);
6b8f5ad1 PT	70	}
	71	#endif
	72
d9b651ce SW	73	left = argc - 1;
d9b651ce SW	74	ap = argv + 1;
2453de99	75	expr = 0;
d9b651ce SW	76	last_unop = OP_INVALID;
d9b651ce SW	77	last_binop = OP_INVALID;
6b8f5ad1 PT	78	last_expr = -1;
6b8f5ad1 PT	79	while (left > 0) {
490ba833 SW	80	for (i = 0; i < ARRAY_SIZE(op_adv); i++) {
	81	if (left <= op_adv[i].arg)
	82	continue;
	83	if (!strcmp(ap[op_adv[i].arg], op_adv[i].str)) {
	84	op = op_adv[i].op;
	85	adv = op_adv[i].adv;
	86	break;
	87	}
	88	}
	89	if (i == ARRAY_SIZE(op_adv)) {
6b8f5ad1 PT	90	expr = 1;
	91	break;
	92	}
490ba833 SW	93	if (left < adv) {
	94	expr = 1;
	95	break;
6b8f5ad1 PT	96	}
6b8f5ad1 PT	97
490ba833 SW	98	switch (op) {
	99	case OP_STR_EMPTY:
	100	expr = strlen(ap[1]) == 0 ? 1 : 0;
	101	break;
	102	case OP_STR_NEMPTY:
	103	expr = strlen(ap[1]) == 0 ? 0 : 1;
	104	break;
	105	case OP_STR_EQ:
	106	expr = strcmp(ap[0], ap[2]) == 0;
	107	break;
	108	case OP_STR_NEQ:
	109	expr = strcmp(ap[0], ap[2]) != 0;
	110	break;
	111	case OP_STR_LT:
	112	expr = strcmp(ap[0], ap[2]) < 0;
	113	break;
	114	case OP_STR_GT:
	115	expr = strcmp(ap[0], ap[2]) > 0;
	116	break;
	117	case OP_INT_EQ:
100e75bb KR	118	expr = simple_strtol(ap[0], NULL, 0) ==
100e75bb KR	119	simple_strtol(ap[2], NULL, 0);
490ba833 SW	120	break;
490ba833 SW	121	case OP_INT_NEQ:
100e75bb KR	122	expr = simple_strtol(ap[0], NULL, 0) !=
100e75bb KR	123	simple_strtol(ap[2], NULL, 0);
490ba833 SW	124	break;
490ba833 SW	125	case OP_INT_LT:
100e75bb KR	126	expr = simple_strtol(ap[0], NULL, 0) <
100e75bb KR	127	simple_strtol(ap[2], NULL, 0);
490ba833 SW	128	break;
490ba833 SW	129	case OP_INT_LE:
100e75bb KR	130	expr = simple_strtol(ap[0], NULL, 0) <=
100e75bb KR	131	simple_strtol(ap[2], NULL, 0);
490ba833 SW	132	break;
490ba833 SW	133	case OP_INT_GT:
100e75bb KR	134	expr = simple_strtol(ap[0], NULL, 0) >
100e75bb KR	135	simple_strtol(ap[2], NULL, 0);
490ba833 SW	136	break;
490ba833 SW	137	case OP_INT_GE:
100e75bb KR	138	expr = simple_strtol(ap[0], NULL, 0) >=
100e75bb KR	139	simple_strtol(ap[2], NULL, 0);
490ba833	140	break;
e5e897c0 SW	141	case OP_FILE_EXISTS:
	142	expr = file_exists(ap[1], ap[2], ap[3], FS_TYPE_ANY);
	143	break;
6b8f5ad1 PT	144	}
6b8f5ad1 PT	145
490ba833 SW	146	switch (op) {
	147	case OP_OR:
	148	last_expr = expr;
d9b651ce	149	last_binop = OP_OR;
490ba833 SW	150	break;
	151	case OP_AND:
	152	last_expr = expr;
d9b651ce SW	153	last_binop = OP_AND;
	154	break;
	155	case OP_NOT:
	156	if (last_unop == OP_NOT)
	157	last_unop = OP_INVALID;
	158	else
	159	last_unop = OP_NOT;
490ba833 SW	160	break;
490ba833 SW	161	default:
d9b651ce SW	162	if (last_unop == OP_NOT) {
	163	expr = !expr;
	164	last_unop = OP_INVALID;
	165	}
	166
	167	if (last_binop == OP_OR)
6b8f5ad1	168	expr = last_expr \|\| expr;
d9b651ce	169	else if (last_binop == OP_AND)
6b8f5ad1	170	expr = last_expr && expr;
d9b651ce SW	171	last_binop = OP_INVALID;
d9b651ce SW	172
490ba833	173	break;
6b8f5ad1 PT	174	}
	175
	176	ap += adv; left -= adv;
	177	}
	178
6b8f5ad1 PT	179	expr = !expr;
	180
	181	debug (": returns %d\n", expr);
	182
	183	return expr;
	184	}
	185
09c32807 HS	186	#undef true
	187	#undef false
	188
6b8f5ad1 PT	189	U_BOOT_CMD(
	190	test, CONFIG_SYS_MAXARGS, 1, do_test,
	191	"minimal test like /bin/sh",
	192	"[args..]"
	193	);
396fd173	194
09140113 SG	195	static int do_false(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	196	char *const argv[])
396fd173 PT	197	{
	198	return 1;
	199	}
	200
	201	U_BOOT_CMD(
	202	false, CONFIG_SYS_MAXARGS, 1, do_false,
	203	"do nothing, unsuccessfully",
	204	NULL
	205	);
	206
09140113 SG	207	static int do_true(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	208	char *const argv[])
396fd173 PT	209	{
	210	return 0;
	211	}
	212
	213	U_BOOT_CMD(
	214	true, CONFIG_SYS_MAXARGS, 1, do_true,
	215	"do nothing, successfully",
	216	NULL
	217	);