[J-u-boot.git] / common / cmd_itest.c

/*
 * (C) Copyright 2003
 * Tait Electronics Limited, Christchurch, New Zealand
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

/*
 * This file provides a shell like 'test' function to return
 * true/false from an integer or string compare of two memory
 * locations or a location and a scalar/literal.
 * A few parts were lifted from bash 'test' command
 */

#include <common.h>
#include <config.h>
#include <command.h>

#define EQ	0
#define NE	1
#define LT	2
#define GT	3
#define LE	4
#define GE	5

struct op_tbl_s {
	char	*op;		/* operator string */
	int	opcode;		/* internal representation of opcode */
};

typedef struct op_tbl_s op_tbl_t;

static const op_tbl_t op_table [] = {
	{ "-lt", LT },
	{ "<"  , LT },
	{ "-gt", GT },
	{ ">"  , GT },
	{ "-eq", EQ },
	{ "==" , EQ },
	{ "-ne", NE },
	{ "!=" , NE },
	{ "<>" , NE },
	{ "-ge", GE },
	{ ">=" , GE },
	{ "-le", LE },
	{ "<=" , LE },
};

static long evalexp(char *s, int w)
{
	long l = 0;
	long *p;

	/* if the parameter starts with a * then assume is a pointer to the value we want */
	if (s[0] == '*') {
		p = (long *)simple_strtoul(&s[1], NULL, 16);
		switch (w) {
		case 1: return((long)(*(unsigned char *)p));
		case 2: return((long)(*(unsigned short *)p));
		case 4: return(*p);
		}
	} else {
		l = simple_strtoul(s, NULL, 16);
	}

	return (l & ((1 << (w * 8)) - 1));
}

static char * evalstr(char *s)
{
	/* if the parameter starts with a * then assume a string pointer else its a literal */
	if (s[0] == '*') {
		return (char *)simple_strtoul(&s[1], NULL, 16);
	} else {
		return s;
	}
}

static int stringcomp(char *s, char *t, int op)
{
	int p;
	char *l, *r;

	l = evalstr(s);
	r = evalstr(t);

	p = strcmp(l, r);
	switch (op) {
	case EQ: return (p == 0);
	case NE: return (p != 0);
	case LT: return (p < 0);
	case GT: return (p > 0);
	case LE: return (p <= 0);
	case GE: return (p >= 0);
	}
	return (0);
}

static int arithcomp (char *s, char *t, int op, int w)
{
	long l, r;

	l = evalexp (s, w);
	r = evalexp (t, w);

	switch (op) {
	case EQ: return (l == r);
	case NE: return (l != r);
	case LT: return (l < r);
	case GT: return (l > r);
	case LE: return (l <= r);
	case GE: return (l >= r);
	}
	return (0);
}

static int binary_test(char *op, char *arg1, char *arg2, int w)
{
	int len, i;
	const op_tbl_t *optp;

	len = strlen(op);

	for (optp = (op_tbl_t *)&op_table, i = 0;
	     i < ARRAY_SIZE(op_table);
	     optp++, i++) {

		if ((strncmp (op, optp->op, len) == 0) && (len == strlen (optp->op))) {
			if (w == 0) {
				return (stringcomp(arg1, arg2, optp->opcode));
			} else {
				return (arithcomp (arg1, arg2, optp->opcode, w));
			}
		}
	}

	printf("Unknown operator '%s'\n", op);
	return 0;	/* op code not found */
}

/* command line interface to the shell test */
static int do_itest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	int	value, w;

	/* Validate arguments */
	if ((argc != 4))
		return CMD_RET_USAGE;

	/* Check for a data width specification.
	 * Defaults to long (4) if no specification.
	 * Uses -2 as 'width' for .s (string) so as not to upset existing code
	 */
	switch (w = cmd_get_data_size(argv[0], 4)) {
	case 1:
	case 2:
	case 4:
		value = binary_test (argv[2], argv[1], argv[3], w);
		break;
	case -2:
		value = binary_test (argv[2], argv[1], argv[3], 0);
		break;
	case -1:
	default:
		puts("Invalid data width specifier\n");
		value = 0;
		break;
	}

	return !value;
}

U_BOOT_CMD(
	itest, 4, 0, do_itest,
	"return true/false on integer compare",
	"[.b, .w, .l, .s] [*]value1 <op> [*]value2"
);
Commit	Line	Data
2d1a537d WD	1	/*
	2	* (C) Copyright 2003
	3	* Tait Electronics Limited, Christchurch, New Zealand
	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
cd0a9de6	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2d1a537d WD	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	/*
	25	* This file provides a shell like 'test' function to return
	26	* true/false from an integer or string compare of two memory
	27	* locations or a location and a scalar/literal.
	28	* A few parts were lifted from bash 'test' command
	29	*/
	30
	31	#include <common.h>
	32	#include <config.h>
	33	#include <command.h>
	34
	35	#define EQ 0
	36	#define NE 1
	37	#define LT 2
	38	#define GT 3
	39	#define LE 4
	40	#define GE 5
	41
	42	struct op_tbl_s {
	43	char op; / operator string */
	44	int opcode; /* internal representation of opcode */
	45	};
	46
	47	typedef struct op_tbl_s op_tbl_t;
	48
fc9903f3	49	static const op_tbl_t op_table [] = {
2d1a537d WD	50	{ "-lt", LT },
	51	{ "<" , LT },
	52	{ "-gt", GT },
	53	{ ">" , GT },
	54	{ "-eq", EQ },
	55	{ "==" , EQ },
	56	{ "-ne", NE },
	57	{ "!=" , NE },
	58	{ "<>" , NE },
	59	{ "-ge", GE },
	60	{ ">=" , GE },
	61	{ "-le", LE },
	62	{ "<=" , LE },
	63	};
	64
2d1a537d WD	65	static long evalexp(char *s, int w)
2d1a537d WD	66	{
f3651764 FM	67	long l = 0;
f3651764 FM	68	long *p;
2d1a537d WD	69
	70	/* if the parameter starts with a * then assume is a pointer to the value we want */
	71	if (s[0] == '*') {
	72	p = (long *)simple_strtoul(&s[1], NULL, 16);
f3651764 FM	73	switch (w) {
	74	case 1: return((long)((unsigned char )p));
	75	case 2: return((long)((unsigned short )p));
	76	case 4: return(*p);
	77	}
2d1a537d WD	78	} else {
	79	l = simple_strtoul(s, NULL, 16);
	80	}
	81
	82	return (l & ((1 << (w * 8)) - 1));
	83	}
	84
	85	static char * evalstr(char *s)
	86	{
	87	/* if the parameter starts with a * then assume a string pointer else its a literal */
	88	if (s[0] == '*') {
	89	return (char *)simple_strtoul(&s[1], NULL, 16);
	90	} else {
	91	return s;
	92	}
	93	}
	94
	95	static int stringcomp(char s, char t, int op)
	96	{
cc22b795	97	int p;
2d1a537d WD	98	char l, r;
	99
	100	l = evalstr(s);
	101	r = evalstr(t);
	102
cc22b795	103	p = strcmp(l, r);
2d1a537d WD	104	switch (op) {
	105	case EQ: return (p == 0);
	106	case NE: return (p != 0);
	107	case LT: return (p < 0);
	108	case GT: return (p > 0);
	109	case LE: return (p <= 0);
	110	case GE: return (p >= 0);
	111	}
	112	return (0);
	113	}
	114
	115	static int arithcomp (char s, char t, int op, int w)
	116	{
	117	long l, r;
	118
	119	l = evalexp (s, w);
	120	r = evalexp (t, w);
	121
	122	switch (op) {
	123	case EQ: return (l == r);
	124	case NE: return (l != r);
	125	case LT: return (l < r);
	126	case GT: return (l > r);
	127	case LE: return (l <= r);
	128	case GE: return (l >= r);
	129	}
	130	return (0);
	131	}
	132
088f1b19	133	static int binary_test(char op, char arg1, char *arg2, int w)
2d1a537d WD	134	{
2d1a537d WD	135	int len, i;
fc9903f3	136	const op_tbl_t *optp;
2d1a537d WD	137
	138	len = strlen(op);
	139
	140	for (optp = (op_tbl_t *)&op_table, i = 0;
fc9903f3	141	i < ARRAY_SIZE(op_table);
2d1a537d WD	142	optp++, i++) {
	143
	144	if ((strncmp (op, optp->op, len) == 0) && (len == strlen (optp->op))) {
	145	if (w == 0) {
	146	return (stringcomp(arg1, arg2, optp->opcode));
	147	} else {
	148	return (arithcomp (arg1, arg2, optp->opcode, w));
	149	}
	150	}
	151	}
	152
	153	printf("Unknown operator '%s'\n", op);
	154	return 0; /* op code not found */
	155	}
	156
	157	/* command line interface to the shell test */
088f1b19	158	static int do_itest(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
2d1a537d	159	{
cd0a9de6	160	int value, w;
2d1a537d	161
cd0a9de6	162	/* Validate arguments */
47e26b1b	163	if ((argc != 4))
4c12eeb8	164	return CMD_RET_USAGE;
2d1a537d WD	165
	166	/* Check for a data width specification.
	167	* Defaults to long (4) if no specification.
	168	* Uses -2 as 'width' for .s (string) so as not to upset existing code
	169	*/
	170	switch (w = cmd_get_data_size(argv[0], 4)) {
	171	case 1:
	172	case 2:
	173	case 4:
	174	value = binary_test (argv[2], argv[1], argv[3], w);
	175	break;
	176	case -2:
	177	value = binary_test (argv[2], argv[1], argv[3], 0);
	178	break;
	179	case -1:
	180	default:
	181	puts("Invalid data width specifier\n");
	182	value = 0;
	183	break;
	184	}
	185
	186	return !value;
	187	}
	188
	189	U_BOOT_CMD(
	190	itest, 4, 0, do_itest,
2fb2604d	191	"return true/false on integer compare",
a89c33db	192	"[.b, .w, .l, .s] []value1 <op> []value2"
2d1a537d	193	);