/*
 * JTAG Core library
 * Copyright (c) 2008 - 2024 Viveris Technologies
 *
 * JTAG Core library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * JTAG Core library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with JTAG Core library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

/**
* @file   script.c
* @brief  Script engine.
* @author Jean-François DEL NERO <Jean-Francois.DELNERO@viveris.fr>
*/

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

#include <stdint.h>

#define MAX_PATH 256

#include "drivers/drv_loader.h"
#include "jtag_core/jtag_core_internal.h"
#include "script.h"
#include "jtag_core/jtag_core.h"
#include "jtag_core/version.h"

#include "bsdl_parser/bsdl_loader.h"
#include "os_interface/os_interface.h"

#include "env.h"

#ifndef _script_cmd_func_
typedef int (* CMD_FUNC)( script_ctx * ctx, char * line);
#define _script_cmd_func_
#endif

typedef struct cmd_list_
{
	char * command;
	CMD_FUNC func;
}cmd_list;

typedef struct label_list_
{
	char * label;
	unsigned int file_offset;
}label_list;

extern cmd_list script_commands_list[];

static int dummy_script_printf(void * ctx, int MSGTYPE, char * string, ... )
{
	return 0;
}

static int is_end_line(char c)
{
	if( c == 0 || c == '#' || c == '\r' || c == '\n' )
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

static int is_space(char c)
{
	if( c == ' ' || c == '\t' )
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

static int is_label(char * command)
{
	int i;

	i = 0;
	while(command[i])
	{
		i++;
	}

	if(i>1)
	{
		if(command[i - 1] == ':')
			return 1;
	}

	return 0;
}

static int is_variable(char * command)
{
	if(strlen(command)>1)
	{
		if(command[0] == '$' && command[1] && ( command[1] != ' ' || command[1] != '\t' ))
			return 1;
		else
			return 0;
	}

	return 0;
}

static int get_next_word(char * line, int offset)
{
	while( !is_end_line(line[offset]) && ( line[offset] == ' ' || line[offset] == '\t' ) )
	{
		offset++;
	}

	return offset;
}

static int copy_param(char * dest, char * line, int offs)
{
	int i,insidequote;

	i = 0;
	insidequote = 0;
	while( !is_end_line(line[offs]) && ( insidequote || !is_space(line[offs]) ) && (i < (DEFAULT_BUFLEN - 1)) )
	{
		if(line[offs] != '"')
		{
			if(dest)
				dest[i] = line[offs];

			i++;
		}
		else
		{
			if(insidequote)
				insidequote = 0;
			else
				insidequote = 1;
		}

		offs++;
	}

	if(dest)
		dest[i] = 0;

	return offs;
}

static int get_param_offset(char * line, int param)
{
	int param_cnt, offs;

	offs = 0;
	offs = get_next_word(line, offs);

	if( param )
	{
		param_cnt = 0;
		do
		{
			offs = copy_param(NULL, line, offs);

			offs = get_next_word( line, offs );

			if(line[offs] == 0 || line[offs] == '#' || line[offs] == '\r' || line[offs] == '\n')
				return -1;

			param_cnt++;
		}while( param_cnt < param );
	}

	return offs;
}

static int get_param( script_ctx * ctx, char * line, int param_offset,char * param)
{
	int offs;
	char var_str[DEFAULT_BUFLEN];

	offs = get_param_offset(line, param_offset);

	if(offs>=0)
	{
		if(line[offs] != '$')
		{
			offs = copy_param(param, line, offs);
		}
		else
		{
			copy_param(var_str, line, offs);

			if(!strcmp(var_str,"$LASTDATA"))
			{
				sprintf(param,"0x"LONGHEXSTR,ctx->last_data_value);
				return 1;
			}

			if(!strcmp(var_str,"$LASTFLAGS"))
			{
				sprintf(param,"0x%X",ctx->last_flags);
				return 1;
			}

			if(!strcmp(var_str,"$LASTERROR"))
			{
				sprintf(param,"%d",ctx->last_error_code);
				return 1;
			}

			if( !getEnvVarDat( (envvar_entry *)ctx->env, (char*)&var_str[1], param, DEFAULT_BUFLEN) )
			{
				copy_param(param, line, offs);
			}
		}

		return 1;
	}

	return -1;
}

static int get_param_str( script_ctx * ctx, char * line, int param_offset,char * param)
{
	int offs;

	offs = get_param_offset(line, param_offset);

	if(offs>=0)
	{
		offs = copy_param(param, line, offs);

		return 1;
	}

	return -1;
}

env_var_value strbin_to_val( char * str )
{
	int l;
	env_var_value val;
	env_var_value mask;

	val = 0;

	// -> end of the string
	l = 0;
	while(str[l])
	{
		l++;
	}

	// -> find the lowest bit
	while(l)
	{
		if( str[l] == '1' || str[l] == '0' )
		{
			break;
		}
		l--;
	};

	mask = 0x1;
	// convert
	while(l >= 0)
	{
		if( str[l] != '1' && str[l] != '0' )
		{
			break;
		}

		if( str[l] == '1')
		{
			val |= mask;
		}

		mask <<= 1;

		l--;
	}

	return val;
}

static env_var_value str_to_int(char * str)
{
	env_var_value value;

	value = 0;

	if(str)
	{
		if( strlen(str) > 2 )
		{
			if( str[0]=='0' )
			{
				switch( str[1] )
				{
					// hex
					case 'x':
					case 'X':
						value = (env_var_value)STRTOVALUE(str, NULL, 0);
					break;

					// binary
					case 'b':
					case 'B':
						value = strbin_to_val(str);
					break;

					// decimal
					default:
						value = atoi(str);
					break;
				}
			}
			else
			{
				value = atoi(str);
			}
		}
		else
		{
			value = atoi(str);
		}
	}

	return value;
}

static env_var_value get_script_variable( script_ctx * ctx, char * varname)
{
	env_var_value value;

	if(!strcmp(varname,"$LASTDATA"))
	{
		return ctx->last_data_value;
	}

	if(!strcmp(varname,"$LASTFLAGS"))
	{
		return ctx->last_flags;
	}

	if(!strcmp(varname,"$LASTERROR"))
	{
		return (env_var_value)(ctx->last_error_code);
	}

	if(varname[0] == '$')
		value = getEnvVarValue( (envvar_entry *)ctx->env, (char*)&varname[1]);
	else
		value = str_to_int((char*)varname);

	return value;
}

static void set_script_variable( script_ctx * ctx, char * varname, env_var_value value)
{
	char tmp_str[64];

	if(!strcmp(varname,"$LASTDATA"))
	{
		ctx->last_data_value = value;

		return;
	}

	if(!strcmp(varname,"$LASTFLAGS"))
	{
		ctx->last_flags = value;

		return;
	}

	if(!strcmp(varname,"$LASTERROR"))
	{
		ctx->last_error_code = value;

		return;
	}

	if(varname[0] == '$' && varname[1])
	{
		sprintf(tmp_str,"0x"LONGHEXSTR,value);
		setEnvVarDat( (envvar_entry *)ctx->env, (char*)&varname[1], tmp_str );

		return;
	}
}

script_ctx * init_script(void * app_ctx, unsigned int flags, void * env)
{
	script_ctx * ctx;

	ctx = malloc(sizeof(script_ctx));
	if(ctx)
	{
		memset(ctx,0,sizeof(script_ctx));

		ctx->env = env;

		setOutputFunc_script( ctx, dummy_script_printf );

		ctx->app_ctx = (void*)app_ctx;
		ctx->cur_label_index = 0;

		ctx->cmdlist = (void*)script_commands_list;

		ctx->script_file = NULL;
	}

	return ctx;
}

static int extract_cmd( script_ctx * ctx, char * line, char * command)
{
	int offs,i;

	i = 0;
	offs = 0;

	offs = get_next_word(line, offs);

	if( !is_end_line(line[offs]) )
	{
		while( !is_end_line(line[offs]) && !is_space(line[offs]) && i < (DEFAULT_BUFLEN - 1) )
		{
			command[i] = line[offs];
			offs++;
			i++;
		}

		command[i] = 0;

		return i;
	}

	return 0;
}

static int exec_cmd( script_ctx * ctx, char * command,char * line)
{
	int i;
	cmd_list * cmdlist;

	cmdlist = (cmd_list*)ctx->cmdlist;

	i = 0;
	while(cmdlist[i].func)
	{
		if( !strcmp(cmdlist[i].command,command) )
		{
			return cmdlist[i].func(ctx,line);
		}

		i++;
	}

	return JTAG_CORE_CMD_NOT_FOUND;
}

static int add_label( script_ctx * ctx, char * label )
{
	int i,j;
	char tmp_label[MAX_LABEL_SIZE];

	if(ctx->cur_label_index < MAX_LABEL)
	{
		i = 0;
		while(i<(MAX_LABEL_SIZE - 1) && label[i] && label[i] != ':')
		{
			tmp_label[i] = label[i];
			i++;
		}
		tmp_label[i] = 0;

		i = 0;
		while(i<ctx->cur_label_index)
		{
			if( !strcmp( tmp_label, ctx->labels[i].label_name ) )
			{
				break;
			}
			i++;
		}

		j = i;

		i = 0;
		while(i<(MAX_LABEL_SIZE - 1) && label[i])
		{
			ctx->labels[j].label_name[i] = tmp_label[i];
			i++;
		}

		ctx->labels[j].label_name[i] = 0;
		ctx->labels[j].offset = ctx->cur_script_offset;

		if(ctx->cur_label_index == j)
		{
			ctx->cur_label_index++;
		}
	}
	return 0;
}

static int goto_label( script_ctx * ctx, char * label )
{
	int i;
	char tmp_label[MAX_LABEL_SIZE];

	i = 0;
	while(i<(MAX_LABEL_SIZE - 1) && label[i] && label[i] != ':')
	{
		tmp_label[i] = label[i];
		i++;
	}
	tmp_label[i] = 0;

	i = 0;
	while(i<ctx->cur_label_index)
	{
		if( !strcmp( tmp_label, ctx->labels[i].label_name ) )
		{
			break;
		}
		i++;
	}

	if( i != ctx->cur_label_index)
	{
		ctx->cur_script_offset = ctx->labels[i].offset;

		if(ctx->script_file)
			fseek(ctx->script_file,ctx->cur_script_offset,SEEK_SET);

		return JTAG_CORE_NO_ERROR;
	}
	else
	{
		ctx->script_printf( ctx, MSG_ERROR, "Label %s not found\n", tmp_label );

		return JTAG_CORE_NOT_FOUND;
	}
}

///////////////////////////////////////////////////////////////////////////////

static int alu_operations( script_ctx * ctx, char * line)
{
	int i;
	int valid;
	env_var_value data_value;
	env_var_value value_1,value_2;

	char params_str[5][DEFAULT_BUFLEN];

	for(i=0;i<5;i++)
	{
		params_str[i][0] = 0;
	}

	valid = 0;
	for(i=0;i<5;i++)
	{
		get_param_str( ctx, line, i, (char*)&params_str[i] );
		if(strlen((char*)&params_str[i]))
			valid++;
	}

	data_value = 0;
	if( ( (valid == 3) || (valid == 5) ) && params_str[1][0] == '=' && params_str[0][0] == '$')
	{
		value_1 = get_script_variable( ctx, params_str[2]);

		if(valid == 5)
		{
			value_2 = get_script_variable( ctx, params_str[4]);

			if(!strcmp(params_str[3],"+"))
				data_value = value_1 + value_2;

			if(!strcmp(params_str[3],"-"))
				data_value = value_1 - value_2;

			if(!strcmp(params_str[3],"*"))
				data_value = value_1 * value_2;

			if(!strcmp(params_str[3],"/") && value_2)
				data_value = value_1 / value_2;

			if(!strcmp(params_str[3],"&"))
				data_value = value_1 & value_2;

			if(!strcmp(params_str[3],"^"))
				data_value = value_1 ^ value_2;

			if(!strcmp(params_str[3],"|"))
				data_value = value_1 | value_2;

			if(!strcmp(params_str[3],">>"))
				data_value = value_1 >> value_2;

			if(!strcmp(params_str[3],"<<"))
				data_value = value_1 << value_2;
		}
		else
		{
			data_value = value_1;
		}

		if(data_value)
			ctx->last_flags = 1;
		else
			ctx->last_flags = 0;

		set_script_variable( ctx, (char*)&params_str[0], data_value);

		return JTAG_CORE_NO_ERROR;
	}

	return JTAG_CORE_BAD_PARAMETER;
}

void setOutputFunc_script( script_ctx * ctx, SCRIPT_PRINTF_FUNC ext_printf )
{
	ctx->script_printf = ext_printf;

	return;
}

int execute_line_script( script_ctx * ctx, char * line )
{
	char command[DEFAULT_BUFLEN];

	command[0] = 0;

	if( extract_cmd(ctx, line, command) )
	{
		if(strlen(command))
		{
			if(!is_label(command))
			{
				if(!ctx->dry_run)
				{
					if(!is_variable(command))
					{
						ctx->last_error_code = exec_cmd(ctx,command,line);

						if( ctx->last_error_code == JTAG_CORE_CMD_NOT_FOUND )
						{
							ctx->script_printf( ctx, MSG_ERROR, "Command not found ! : %s\n", line );

							return ctx->last_error_code;
						}
					}
					else
					{
						ctx->last_error_code = alu_operations(ctx,line);
					}
				}
				else
					ctx->last_error_code = JTAG_CORE_NO_ERROR;
			}
			else
			{
				add_label(ctx,command);

				ctx->last_error_code = JTAG_CORE_NO_ERROR;
			}

			return ctx->last_error_code;
		}
	}

	ctx->last_error_code = JTAG_CORE_BAD_CMD;

	return ctx->last_error_code;
}

int execute_file_script( script_ctx * ctx, char * filename )
{
	int err;
	char line[DEFAULT_BUFLEN];

	err = JTAG_CORE_INTERNAL_ERROR;

	ctx->script_file = fopen(filename,"r");
	if(ctx->script_file)
	{
		strncpy(ctx->script_file_path,filename,DEFAULT_BUFLEN - 1);
		ctx->script_file_path[DEFAULT_BUFLEN-1] = 0;

		// Dry run -> populate the labels...
		ctx->dry_run++;
		do
		{
			if(!fgets(line,sizeof(line),ctx->script_file))
				break;

			ctx->cur_script_offset = ftell(ctx->script_file);

			if(feof(ctx->script_file))
				break;

			execute_line_script(ctx, line);
		}while(1);

		fseek(ctx->script_file,0,SEEK_SET);
		ctx->cur_script_offset = ftell(ctx->script_file);

		ctx->dry_run--;
		if(!ctx->dry_run)
		{
			if(strlen(ctx->pre_command))
			{
				err = execute_line_script(ctx, ctx->pre_command);
				if(err != JTAG_CORE_NO_ERROR)
				{
					fclose(ctx->script_file);
					return err;
				}
			}

			do
			{
				if(!fgets(line,sizeof(line),ctx->script_file))
					break;

				ctx->cur_script_offset = ftell(ctx->script_file);

				if(feof(ctx->script_file))
					break;

				err = execute_line_script(ctx, line);
			}while(1);
		}

		fclose(ctx->script_file);

		err = JTAG_CORE_NO_ERROR;
	}
	else
	{
		ctx->script_printf( ctx, MSG_ERROR, "Can't open %s !", filename );
		ctx->script_file_path[0] = 0;

		err = JTAG_CORE_ACCESS_ERROR;
	}

	return err;
}

int execute_ram_script( script_ctx * ctx, unsigned char * script_buffer, int buffersize )
{
	int err = 0;
	int buffer_offset,line_offset;
	char line[DEFAULT_BUFLEN];
	int cont;

	ctx->dry_run++;
	cont = 1;

	while( cont )
	{
		buffer_offset = 0;
		line_offset = 0;
		ctx->cur_script_offset = 0;

		do
		{
			memset(line,0,DEFAULT_BUFLEN);
			line_offset = 0;
			while( (buffer_offset < buffersize) && script_buffer[buffer_offset] && script_buffer[buffer_offset]!='\n' && script_buffer[buffer_offset]!='\r' && (line_offset < DEFAULT_BUFLEN - 1))
			{
				line[line_offset++] = script_buffer[buffer_offset++];
			}

			while( (buffer_offset < buffersize) && script_buffer[buffer_offset] && (script_buffer[buffer_offset]=='\n' || script_buffer[buffer_offset]=='\r') )
			{
				buffer_offset++;
			}

			ctx->cur_script_offset = buffer_offset;

			execute_line_script(ctx, line);

			buffer_offset = ctx->cur_script_offset;

			if( (buffer_offset >= buffersize) || !script_buffer[buffer_offset])
				break;

		}while(buffer_offset < buffersize);

		if( !ctx->dry_run || (ctx->dry_run > 1) )
		{
			cont = 0;
		}
		else
		{
			ctx->dry_run = 0;

			if(strlen(ctx->pre_command))
				execute_line_script(ctx, ctx->pre_command);
		}
	}

	return err;
}

script_ctx * deinit_script(script_ctx * ctx)
{
	if(ctx)
	{
		free(ctx);
	}

	ctx = NULL;

	return ctx;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////// Generic commands/operations /////////////////////////////
///////////////////////////////////////////////////////////////////////////////

static int cmd_goto( script_ctx * ctx, char * line)
{
	int i;
	char label_str[DEFAULT_BUFLEN];

	i = get_param( ctx, line, 1, label_str );

	if(i>=0)
	{
		return goto_label( ctx, label_str );
	}

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_if( script_ctx * ctx, char * line)
{
	//"if" command example :
	// if $VARIABLE > 0x2222 then goto label

	int i;
	int eval;
	int ret;
	int valid;
	char params_str[5][DEFAULT_BUFLEN];
	env_var_value value_1,value_2,tmp_val;
	int op_offset;

	ret = JTAG_CORE_BAD_PARAMETER;

	eval = 0;

	for(i=0;i<5;i++)
	{
		params_str[i][0] = 0;
	}

	valid = 0;
	for(i=0;i<5;i++)
	{
		get_param( ctx, line, i, (char*)&params_str[i] );
		if(strlen((char*)&params_str[i]))
			valid++;
	}

	i = 0;
	while( i < 5 && strcmp((char*)&params_str[i],"then") )
	{
		i++;
	}

	if( i < 5 )
	{
		if( i == 2)
		{
			value_1 = get_script_variable( ctx, params_str[1]);

			if(value_1)
				eval = 1;

			ret = JTAG_CORE_NO_ERROR;
		}

		if ( i == 4 )
		{
			value_1 = get_script_variable( ctx, params_str[1]);
			value_2 = get_script_variable( ctx, params_str[3]);

			if(!strcmp((char*)&params_str[2],">=") && ( (signed_env_var_value)value_1 >= (signed_env_var_value)value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"<=") && ( (signed_env_var_value)value_1 <= (signed_env_var_value)value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],">") && ( (signed_env_var_value)value_1 > (signed_env_var_value)value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"<") && ( (signed_env_var_value)value_1 < (signed_env_var_value)value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"==") && ( value_1 == value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"!=") && ( value_1 != value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"&") && ( value_1 & value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"^") && ( value_1 ^ value_2 ) )
				eval = 1;

			if(!strcmp((char*)&params_str[2],"|") && ( value_1 | value_2 ) )
				eval = 1;

			tmp_val = value_1 >> value_2;
			if(!strcmp((char*)&params_str[2],">>") && tmp_val )
				eval = 1;

			tmp_val = value_1 << value_2;
			if(!strcmp((char*)&params_str[2],"<<") && tmp_val )
				eval = 1;

			ret = JTAG_CORE_NO_ERROR;
		}

		if( eval )
		{
			op_offset = get_param_offset(line, i + 1);

			if(op_offset >= 0)
			{
				ret = execute_line_script( ctx, (char*)&line[op_offset] );
			}
		}

		return ret;
	}

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_return( script_ctx * ctx, char * line )
{
	if(ctx->script_file)
	{
		fseek(ctx->script_file,0,SEEK_END);
	}

	return JTAG_CORE_NO_ERROR;
}

static int cmd_system( script_ctx * ctx, char * line )
{
	int offs;
	int ret;

	offs = get_param_offset(line, 1);

	if(offs>=0)
	{
		ret = system(&line[offs]);

		if( ret != 1 )
			return JTAG_CORE_NO_ERROR;
		else
			return JTAG_CORE_NOT_FOUND;
	}

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_print_env_var( script_ctx * ctx, char * line )
{
	int i;
	char varname[DEFAULT_BUFLEN];
	char varvalue[DEFAULT_BUFLEN];
	char * ptr;

	i = get_param( ctx, line, 1, varname );

	if(i>=0)
	{
		ptr = getEnvVarDat( (envvar_entry *)ctx->env, (char*)&varname, (char*)&varvalue, sizeof(varvalue) );
		if(ptr)
		{
			ctx->script_printf( ctx, MSG_INFO_1, "%s = %s", varname, varvalue );

			return JTAG_CORE_NO_ERROR;
		}

		return JTAG_CORE_NOT_FOUND;
	}
	else
	{
		return JTAG_CORE_BAD_PARAMETER;
	}
}

static int cmd_version( script_ctx * ctx, char * line)
{
	ctx->script_printf( ctx, MSG_INFO_0, "Lib version : %s, Date : "__DATE__" "__TIME__"\n", LIB_JTAG_CORE_VERSION );

	return JTAG_CORE_NO_ERROR;
}

static int cmd_print( script_ctx * ctx, char * line)
{
	int i,j,s;
	char tmp_str[DEFAULT_BUFLEN];
	char str[DEFAULT_BUFLEN*2];
	char * ptr;

	str[0] = '\0';

	j = 1;
	do
	{
		ptr = NULL;

		i = get_param_offset(line, j);
		s = 0;

		if(i>=0)
		{
			tmp_str[0] = '\0';
			get_param( ctx, line, j, (char *)&tmp_str );
			s = strlen(tmp_str);
			if(s)
			{
				if(tmp_str[0] != '$')
				{
					genos_strndstcat((char*)str,tmp_str,sizeof(str));
					genos_strndstcat((char*)str," ",sizeof(str));
					str[sizeof(str) - 1] = '\0';
				}
				else
				{
					ptr = getEnvVarDat( (envvar_entry *)ctx->env, &tmp_str[1], NULL, 0);
					if( ptr )
					{
						genos_strndstcat((char*)str,ptr,sizeof(str));
						genos_strndstcat((char*)str," ",sizeof(str));
					}
					else
					{
						genos_strndstcat((char*)str,tmp_str,sizeof(str));
						genos_strndstcat((char*)str," ",sizeof(str));
					}
					str[sizeof(str) - 1] = '\0';
				}
			}
		}

		j++;
	}while(s);

	ctx->script_printf( ctx, MSG_NONE, "%s\n", str );

	return JTAG_CORE_NO_ERROR;
}

static int cmd_pause( script_ctx * ctx, char * line)
{
	int i;
	char delay_str[DEFAULT_BUFLEN];

	i = get_param( ctx, line, 1, delay_str );

	if(i>=0)
	{
		genos_pause(str_to_int(delay_str));

		return JTAG_CORE_NO_ERROR;
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_help( script_ctx * ctx, char * line)
{
	int i;

	cmd_list * cmdlist;

	cmdlist = (cmd_list*)ctx->cmdlist;

	ctx->script_printf( ctx, MSG_INFO_0, "Supported Commands :\n\n" );

	i = 0;
	while(cmdlist[i].func)
	{
		ctx->script_printf( ctx, MSG_NONE, "%s\n", cmdlist[i].command );
		i++;
	}

	return JTAG_CORE_NO_ERROR;
}

static int cmd_call( script_ctx * ctx, char * line )
{
	int offs;
	char path[DEFAULT_BUFLEN];
	char function[DEFAULT_BUFLEN];
	script_ctx * new_ctx;
	int ret;
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	path[0] = '\0';
	get_param( ctx, line, 1, (char*)&path );

	offs = get_param_offset(line, 1);

	if(offs>=0)
	{

		ret = JTAG_CORE_INTERNAL_ERROR;

		new_ctx = init_script((void*)jc,0x00000000,(void*)jc->envvar);
		if(new_ctx)
		{
			new_ctx->script_printf = ctx->script_printf;

			function[0] = '\0';
			get_param( ctx, line, 2, (char*)&function );

			if(!strcmp(path,"."))
			{
				if(strlen(function))
				{
					snprintf(new_ctx->pre_command,sizeof(new_ctx->pre_command),"goto %s",function);

					ret = execute_file_script( new_ctx, (char*)&ctx->script_file_path );

					new_ctx->pre_command[0] = 0;

					if( ret == JTAG_CORE_ACCESS_ERROR )
					{
						ctx->script_printf( ctx, MSG_ERROR, "call : script not found ! : %s\n", path );
					}
				}
			}
			else
			{
				if(strlen(function))
				{
					snprintf(new_ctx->pre_command,sizeof(new_ctx->pre_command),"goto %s",function);

					ret = execute_file_script( new_ctx, (char*)&path );

					new_ctx->pre_command[0] = 0;

					if( ret == JTAG_CORE_ACCESS_ERROR )
					{
						ctx->script_printf( ctx, MSG_ERROR, "call : script/function not found ! : %s %s\n", path,function );
					}
				}
				else
				{
					ret = execute_file_script( new_ctx, (char*)&path );

					if( ret == JTAG_CORE_ACCESS_ERROR )
					{
						ctx->script_printf( ctx, MSG_ERROR, "call : script not found ! : %s\n", path );
					}
				}
			}

			deinit_script(new_ctx);
		}

		ctx->last_error_code = ret;

		return ret;
	}

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_env_var( script_ctx * ctx, char * line )
{
	int i,j,ret;
	char varname[DEFAULT_BUFLEN];
	char varvalue[DEFAULT_BUFLEN];

	ret = JTAG_CORE_BAD_PARAMETER;

	i = get_param( ctx, line, 1, varname );
	j = get_param( ctx, line, 2, varvalue );

	if(i>=0 && j>=0)
	{
		if( setEnvVarDat( (envvar_entry *)ctx->env, (char*)&varname, (char*)&varvalue ) >= 0 )
		{
			ret = JTAG_CORE_NO_ERROR;
		}
		else
			ret = JTAG_CORE_MEM_ERROR;
	}

	return ret;
}

static int cmd_rand( script_ctx * ctx, char * line)
{
	int i;
	uint32_t seed;

	char rand_seed[DEFAULT_BUFLEN];

	seed = ctx->rand_seed;

	i = get_param( ctx, line, 1, rand_seed );
	if(i>=0)
	{
		seed = str_to_int((char*)rand_seed);
	}

	/* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
	seed ^= seed << 13;
	seed ^= seed >> 17;
	seed ^= seed << 5;

	ctx->rand_seed = seed;

	ctx->last_data_value = seed;

	return JTAG_CORE_NO_ERROR;
}

int is_valid_hex_quartet(char c)
{
	if( (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') )
		return 1;
	else
		return 0;
}

int is_valid_hex_byte(char *str)
{
	if( is_valid_hex_quartet(str[0]) && is_valid_hex_quartet(str[1]) )
		return 1;
	else
		return 0;
}

char * arrayresize(char * array, int size, unsigned char c)
{
	int cursize;
	char * ptr;

	if( size < 0 )
		return array;

	if(array)
	{
		if( array[0] == '0' && (array[1] == 'x' || array[1] == 'X') )
		{
			ptr = (array + 2);
		}
		else
		{
			ptr = (array);
		}
	}
	else
	{
		array = malloc(DEFAULT_BUFLEN + 1);
		if(array)
		{
			size = DEFAULT_BUFLEN / 2;
			memset(array,0,DEFAULT_BUFLEN + 1);
		}

		ptr = array;
	}

	if(ptr)
	{
		cursize = 0;
		while(is_valid_hex_byte(&ptr[cursize*2]))
		{
			cursize++;
		}

		ptr[cursize*2] = '\0';

		if( cursize < size  )
		{
			while( cursize < size )
			{
				sprintf(&ptr[(cursize*2) + 0],"%.2X",c);
				ptr[(cursize*2) + 2] = '\0';
				cursize++;
			}
		}
	}

	return array;
}


static int cmd_initarray( script_ctx * ctx, char * line)
{
	//initarray  $VARIABLE_1_TEST $BYTES $VALUE

	int i,j,ret;
	char varname[DEFAULT_BUFLEN];
	char varsize[DEFAULT_BUFLEN];
	char varvalue[DEFAULT_BUFLEN];
	char * ptr;
	int size;

	ret = JTAG_CORE_BAD_PARAMETER;

	strcpy(varvalue,"0");
	varname[0] = '\0';

	i = get_param_str( ctx, line, 1, varname );
	j = get_param( ctx, line, 2, varsize );
	get_param( ctx, line, 3, varvalue );

	if(i>=0 && j>=0)
	{
		size = str_to_int(varsize);

		if(size >= 0 && strlen(varname) )
		{
			ptr = getEnvVarDat( (envvar_entry *)ctx->env,(char*)&varname, NULL, 0);
			if(ptr)
			{
				arrayresize(ptr, size, (unsigned char)(str_to_int((char*)&varvalue)&0xFF));
			}
			else
			{
				ptr = malloc( DEFAULT_BUFLEN );
				if(ptr)
				{
					memset(ptr,0x00, DEFAULT_BUFLEN);
					arrayresize(ptr, size, (unsigned char)(str_to_int((char*)&varvalue)&0xFF));
				}
			}

			if(ptr)
				setEnvVarDat( (envvar_entry *)ctx->env, (char*)&varname[1], ptr );
		}
		ret = JTAG_CORE_NO_ERROR;
	}

	return ret;

}


///////////////////////////////////////////////////////////////////////////////
/////////////////////// JTAG commands/operations //////////////////////////////
///////////////////////////////////////////////////////////////////////////////

static int cmd_autoinit( script_ctx * ctx, char * line)
{
	jtag_core * jc;
	int number_of_devices, dev_nb;
	int loaded_bsdl;
	char szExecPath[MAX_PATH + 1];
	char scanfolder[MAX_PATH + 1];
	char filename[MAX_PATH + 1];
	char entityname[DEFAULT_BUFLEN];
	char file[MAX_PATH + 1];

	filefoundinfo fileinfo;
	void* h_file_find;

	unsigned long chip_id,chip_id_mask;

	jc = (jtag_core *)ctx->app_ctx;
	loaded_bsdl = 0;

	// BSDL Auto load : check which bsdl file match with the device
	// And load it.

	jtagcore_scan_and_init_chain(jc);

	number_of_devices = jtagcore_get_number_of_devices(jc);

	ctx->script_printf( ctx, MSG_INFO_0, "%d device(s) found\n", number_of_devices );

	// Get the bsdl_files folder path

	genos_getcurrentdirectory(szExecPath,MAX_PATH);

	strncpy(scanfolder, szExecPath, sizeof(scanfolder) );
	genos_strndstcat(scanfolder, DIR_SEPARATOR"bsdl_files"DIR_SEPARATOR,  sizeof(scanfolder) - 1 );
	scanfolder[sizeof(scanfolder) - 1] = '\0';

	h_file_find = genos_find_first_file( scanfolder, "*.*", &fileinfo );

	// Scan and check files in the folder.
	if (h_file_find)
	{
		do
		{
			strcpy(filename,szExecPath);
			genos_strndstcat(filename,DIR_SEPARATOR"bsdl_files"DIR_SEPARATOR,sizeof(filename));
			genos_strndstcat(filename,fileinfo.filename,sizeof(filename));
			filename[sizeof(filename) - 1] = '\0';

			if ( ! fileinfo.isdirectory )
			{
				chip_id_mask = 0xFFFFFFFF;
				chip_id = jtagcore_get_bsdl_id(jc, filename, &chip_id_mask);
				if( chip_id )
				{
					for(dev_nb=0;dev_nb < number_of_devices;dev_nb++)
					{
						if( ( chip_id & chip_id_mask ) == ( jtagcore_get_dev_id(jc, dev_nb) & chip_id_mask ) )
						{
							if(jtagcore_get_number_of_pins(jc, dev_nb) > 0)
							{
								// Device already loaded !
								ctx->script_printf( ctx, MSG_WARNING, "Device %d BSDL already loaded ! ID conflit ?\n", dev_nb );
							}

							// The BSDL ID match with the device.
							if(jtagcore_loadbsdlfile(jc, filename, dev_nb) == JTAG_CORE_NO_ERROR)
							{
								entityname[0] = 0;
								jtagcore_get_dev_name(jc, dev_nb, entityname, file);

								ctx->script_printf( ctx, MSG_INFO_0, "Device %d (%.8X - %s) - BSDL Loaded : %s\n", dev_nb, chip_id, entityname, file );
							}
							else
							{
								ctx->script_printf( ctx, MSG_ERROR, "ERROR while loading %s !\n", filename );
							}
						}
					}
				}
			}
		}while(genos_find_next_file( h_file_find, scanfolder, "*.*", &fileinfo ));

		genos_find_close( h_file_find );

		loaded_bsdl = 0;
		// Count the loaded bsdl
		for(dev_nb=0;dev_nb < number_of_devices;dev_nb++)
		{
			if(jtagcore_get_number_of_pins(jc, dev_nb) > 0)
			{
				loaded_bsdl++;
			}
			else
			{
				ctx->script_printf( ctx, MSG_WARNING, "Device %d (%.8X) - NO BSDL Loaded !\n", dev_nb, jtagcore_get_dev_id(jc, dev_nb ) );
			}
		}
	}
	else
	{
		ctx->script_printf( ctx, MSG_ERROR, "Can't access the bsdl sub folder ! : %s\n", filename );
		return JTAG_CORE_ACCESS_ERROR;
	}

	return loaded_bsdl;
}

static int cmd_init_and_scan( script_ctx * ctx, char * line)
{
	jtag_core * jc;
	int ret;

	jc = (jtag_core *)ctx->app_ctx;

	ret = jtagcore_scan_and_init_chain(jc);

	if( ret == JTAG_CORE_NO_ERROR )
	{
		ctx->script_printf( ctx, MSG_INFO_0, "JTAG Scan done\n" );

		return JTAG_CORE_NO_ERROR;
	}
	else
	{
		ctx->script_printf( ctx, MSG_INFO_0, "JTAG Scan return code : %d\n", ret );
	}

	return ret;
}

static int cmd_print_nb_dev( script_ctx * ctx, char * line)
{
	jtag_core * jc;
	int i;

	jc = (jtag_core *)ctx->app_ctx;

	i = jtagcore_get_number_of_devices(jc);

	ctx->script_printf( ctx, MSG_INFO_0, "%d device(s) found in chain\n", i );

	ctx->last_data_value = i;

	return JTAG_CORE_NO_ERROR;
}

static void bsdl_id_str(unsigned long id, char * str)
{
	int i;

	str[0] = 0;

	for (i = 0; i < 32; i++)
	{
		if ((0x80000000 >> i)&id)
		{
			strcat(str, "1");
		}
		else
		{
			strcat(str, "0");
		}
		if (i == 3) strcat(str, " ");
		if (i == 19) strcat(str, " ");
		if (i == 30) strcat(str, " ");
	}

	str[i] = 0;
}

static char * get_id_str( script_ctx * ctx, int numberofdevice)
{
	// compare passed device ID to the one returned from the ID command
	jtag_core * jc;
	int i;
	unsigned int idcode = 0;
	char * stringbuffer;
	char tempstr[DEFAULT_BUFLEN];

	jc = (jtag_core *)ctx->app_ctx;

	stringbuffer = NULL;

	if( numberofdevice < 0 || numberofdevice > 256)
		return NULL;

	stringbuffer = malloc(256 * numberofdevice);
	if (stringbuffer)
	{
		memset(stringbuffer, 0, 256 * numberofdevice);

		// and read the IDCODES
		for (i = 0; i < numberofdevice; i++)
		{
			idcode = jtagcore_get_dev_id(jc, i);
			sprintf(tempstr, "Device %d : 0x%.8X - ", i, idcode);

			bsdl_id_str(idcode, &tempstr[strlen(tempstr)]);

			strcat(stringbuffer, tempstr);
			strcat(stringbuffer, "\n");
		}
	}

	return stringbuffer;
}

static int cmd_print_devs_list( script_ctx * ctx, char * line)
{
	jtag_core * jc;
	int i;
	char *ptr;

	jc = (jtag_core *)ctx->app_ctx;

	i = jtagcore_get_number_of_devices(jc);
	if(i>0)
	{
		ptr = get_id_str(ctx,i);
		if(ptr)
		{
			ctx->script_printf( ctx, MSG_INFO_0, "%s\n", ptr );
			free(ptr);
		}
	}

	return JTAG_CORE_NOT_FOUND;
}

static int cmd_print_probes_list( script_ctx * ctx, char * line)
{
	jtag_core * jc;
	int i,j;
	char probe_list[64];
	int nb_of_drivers,nb_of_probes;

	jc = (jtag_core *)ctx->app_ctx;

	nb_of_drivers = jtagcore_get_number_of_probes_drv(jc);
	j = 0;
	while (j < nb_of_drivers)
	{
		nb_of_probes = jtagcore_get_number_of_probes(jc, j);
		i = 0;
		while( i < nb_of_probes )
		{
			jtagcore_get_probe_name(jc, PROBE_ID(j,i), probe_list);
			ctx->script_printf( ctx, MSG_INFO_0, "ID 0x%.8X : %s\n", PROBE_ID(j,i), probe_list );
			i++;
		}
		j++;
	}

	return JTAG_CORE_NO_ERROR;
}

static int cmd_open_probe( script_ctx * ctx, char * line)
{
	int ret;
	char probe_id[64];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	if(get_param( ctx, line, 1, probe_id )>0)
	{
		ret = jtagcore_select_and_open_probe(jc, strtoul(probe_id, NULL, 16));
		if(ret != JTAG_CORE_NO_ERROR)
		{
			ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", ret );
			return ret;
		}
		else
		{
			ctx->script_printf( ctx, MSG_INFO_0, "Probe Ok !\n" );
			return JTAG_CORE_NO_ERROR;
		}
	}
	else
	{
		ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

		return JTAG_CORE_BAD_PARAMETER;
	}
}

static int cmd_load_bsdl( script_ctx * ctx, char * line)
{
	int i,j;
	char dev_index[DEFAULT_BUFLEN];
	char filename[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, filename );
	j = get_param( ctx, line, 2, dev_index );

	if(i>=0 && j>=0)
	{
		if (jtagcore_loadbsdlfile(jc, filename, str_to_int(dev_index)) >= 0)
		{
			ctx->script_printf( ctx, MSG_INFO_0, "BSDL %s loaded and parsed !\n", filename );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "File open & parsing error (%s)!\n", filename );
			return JTAG_CORE_ACCESS_ERROR;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_scan_mode( script_ctx * ctx, char * line)
{
	int i,j;
	char dev_index[DEFAULT_BUFLEN];
	char scan_mode[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, scan_mode );

	if(i>=0 && j>=0)
	{
		if( !strcmp(scan_mode,"EXTEST") )
		{
			jtagcore_set_scan_mode(jc, str_to_int(dev_index),JTAG_CORE_EXTEST_SCANMODE);
			ctx->script_printf( ctx, MSG_INFO_0, "EXTEST mode\n" );
		}
		else
		{
			if( !strcmp(scan_mode,"SAMPLE") )
			{
				jtagcore_set_scan_mode(jc, str_to_int(dev_index),JTAG_CORE_SAMPLE_SCANMODE);

				ctx->script_printf( ctx, MSG_INFO_0, "SAMPLE mode\n" );
			}
			else
			{
				ctx->script_printf( ctx, MSG_ERROR, "%s : unknown mode !\n", scan_mode );
				return JTAG_CORE_BAD_PARAMETER;
			}
		}

		return JTAG_CORE_NO_ERROR;
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_push_and_pop( script_ctx * ctx, char * line)
{
	int ret;
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	ret = jtagcore_push_and_pop_chain(jc, JTAG_CORE_WRITE_READ);

	if(ret != JTAG_CORE_NO_ERROR)
	{
		ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", ret );
		return ret;
	}
	else
	{
		ctx->script_printf( ctx, MSG_INFO_0, "JTAG chain updated\n" );
	}

	return JTAG_CORE_NO_ERROR;
}

static int cmd_set_pin_mode( script_ctx * ctx, char * line)
{
	int i,j,k,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char mode[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, mode );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_set_pin_state(jc, str_to_int(dev_index), id, JTAG_CORE_OE, str_to_int(mode));

			ctx->script_printf( ctx, MSG_INFO_0, "Pin %s mode set to %d\n", pinname, str_to_int(mode) );

			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_pin_state( script_ctx * ctx, char * line)
{
	int i,j,k,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char state[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, state );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_set_pin_state(jc, str_to_int(dev_index), id, JTAG_CORE_OUTPUT, str_to_int(state));

			ctx->script_printf( ctx, MSG_INFO_0, "Pin %s set to %d\n", pinname, str_to_int(state) );

			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_get_pin_state( script_ctx * ctx, char * line)
{
	int i,j,k,ret,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char mode[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, mode );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			ret = jtagcore_get_pin_state(jc, str_to_int(dev_index), id, JTAG_CORE_INPUT);

			ctx->script_printf( ctx, MSG_INFO_0, "Pin %s state : %d\n", pinname, ret );

			ctx->last_data_value = ret;

			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

/////////////////////////////////////////////////////////////////////////////////////////
// I2C Commands
/////////////////////////////////////////////////////////////////////////////////////////

static int cmd_set_i2c_sda_pin( script_ctx * ctx, char * line)
{
	int i,j,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );

	if(i>=0 && j>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_i2c_set_sda_pin(jc, str_to_int(dev_index), id);
			ctx->script_printf( ctx, MSG_INFO_0, "SDA set to Pin %s\n", pinname );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_i2c_scl_pin( script_ctx * ctx, char * line)
{
	int i,j,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );

	if(i>=0 && j>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_i2c_set_scl_pin(jc, str_to_int(dev_index), id);
			ctx->script_printf( ctx, MSG_INFO_0, "SCL set to Pin %s\n", pinname );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_do_i2c_wr( script_ctx * ctx, char * line)
{
	// jtag_set_do_i2c_wr E8 EAACCDD4455
	int i, j;
	int i2cadr, size, ret;
	char adresse[DEFAULT_BUFLEN];
	char data[DEFAULT_BUFLEN];
	unsigned char tmp_buffer2[DEFAULT_BUFLEN];
	char tmp_buffer3[16];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, adresse );
	j = get_param( ctx, line, 2, data );

	if(i>=0 && j>=0)
	{
		i2cadr = strtoul(adresse,0,16);
		size  = strlen(data);
		size = size / 2;
		for(i = 0; i<size; i++)
		{
			tmp_buffer3[0] = data[i*2];
			tmp_buffer3[1] = data[i*2 + 1];
			tmp_buffer3[2] = 0;

			tmp_buffer2[i] = (char)strtoul(tmp_buffer3,0,16);
		}

		ret = jtagcore_i2c_write_read(jc, i2cadr, 0, size, tmp_buffer2, 0, 0);

		if ( ret <= 0)
		{
			if(ret == 0)
			{
				ctx->script_printf( ctx, MSG_WARNING, "Device Ack not detected ! 0x%.2X\n", i2cadr );
			}
			else
			{
				ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", ret );
			}

			return ret;
		}
		else
		{
			for(i=0;i<size;i++)
			{
				sprintf(&data[i*3]," %.2X",tmp_buffer2[i]);
			}
			ctx->script_printf( ctx, MSG_INFO_0, "WR I2C 0x%.2X :%s\n", i2cadr, data );

			return JTAG_CORE_NO_ERROR;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_do_i2c_rd( script_ctx * ctx, char * line)
{
	// jtag_set_do_i2c_rd 0xE8 8
	int i,j,i2cadr,size;
	char adresse[DEFAULT_BUFLEN];
	char sizebuf[DEFAULT_BUFLEN];
	char tmp_buffer[DEFAULT_BUFLEN];
	char tmp_buffer2[DEFAULT_BUFLEN];
	char tmp_buffer3[16];
	int ret;
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, adresse );
	j = get_param( ctx, line, 2, sizebuf );

	if(i>=0 && j>=0)
	{
		i2cadr = strtoul(adresse,0,16);
		size  = str_to_int(sizebuf);

		ret = jtagcore_i2c_write_read(jc, i2cadr, 0, 0, (unsigned char*)tmp_buffer2, size, (unsigned char*)tmp_buffer2);

		if ( ret <= 0)
		{
			if(ret == 0)
			{
				ctx->script_printf( ctx, MSG_WARNING, "Device Ack not detected ! 0x%.2X\n", i2cadr );
			}
			else
			{
				ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", ret );
			}

			return ret;
		}
		else
		{
			memset(tmp_buffer, 0, sizeof(tmp_buffer));
			for (i = 0; i<size && i < sizeof(tmp_buffer2); i++)
			{
				sprintf(tmp_buffer3, " %.2X", tmp_buffer2[i]);
				strcat(tmp_buffer, tmp_buffer3);
			}
			ctx->script_printf( ctx, MSG_INFO_0, "RD I2C 0x%.2X :%s\n", i2cadr, tmp_buffer );

			return JTAG_CORE_NO_ERROR;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

/////////////////////////////////////////////////////////////////////////////////////////
// MDIO Commands
/////////////////////////////////////////////////////////////////////////////////////////

static int cmd_set_mdio_mdc_pin( script_ctx * ctx, char * line)
{
	int i,j,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );

	if(i>=0 && j>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_mdio_set_mdc_pin(jc, str_to_int(dev_index), id);
			ctx->script_printf( ctx, MSG_INFO_0, "MDC set to Pin %s\n", pinname );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n",  pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_mdio_mdio_pin( script_ctx * ctx, char * line)
{
	int i,j,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );

	if(i>=0 && j>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_mdio_set_mdio_pin(jc, str_to_int(dev_index), id);
			ctx->script_printf( ctx, MSG_INFO_0, "MDIO set to Pin %s\n", pinname );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_do_mdio_wr( script_ctx * ctx, char * line)
{
	// jtag_mdio_wr 01 04 EAAC
	int i,j,k,mdioadr,regadr,datatowrite;
	char address[DEFAULT_BUFLEN];
	char reg[DEFAULT_BUFLEN];
	char data[DEFAULT_BUFLEN];
	int ret;
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, address );
	j = get_param( ctx, line, 2, reg );
	k = get_param( ctx, line, 3, data );

	if(i>=0 && j>=0 && k>=0)
	{
		mdioadr = strtoul(address,0,16);
		regadr = strtoul(reg,0,16);
		datatowrite = strtoul(data, 0, 16);

		ret = jtagcore_mdio_write(jc, mdioadr, regadr, datatowrite);
		if( ret < 0 )
		{
			ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", ret );
			return ret;
		}

		ctx->script_printf( ctx, MSG_INFO_0, "WR MDIO 0x%.2X : [0x%.2X] = 0x%.4X\n", mdioadr ,regadr, datatowrite );

		return JTAG_CORE_NO_ERROR;
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_do_mdio_rd( script_ctx * ctx, char * line)
{
	// jtag_mdio_rd 01 04
	int i,j,mdioadr,regadr,dataread;
	char address[DEFAULT_BUFLEN];
	char reg[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, address );
	j = get_param( ctx, line, 2, reg );

	if(i>=0 && j>=0)
	{
		mdioadr = strtoul(address,0,16);
		regadr = strtoul(reg,0,16);

		dataread = jtagcore_mdio_read(jc, mdioadr, regadr);
		if( dataread < 0 )
		{
			ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", dataread );
			return dataread;
		}

		ctx->last_data_value = dataread;

		ctx->script_printf( ctx, MSG_INFO_0, "RD MDIO 0x%.2X : [0x%.2X] = 0x%.4X\n", mdioadr ,regadr, dataread );

		return JTAG_CORE_NO_ERROR;
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

/////////////////////////////////////////////////////////////////////////////////////////
// SPI Commands
/////////////////////////////////////////////////////////////////////////////////////////
static int cmd_set_spi_cs_pin( script_ctx * ctx, char * line)
{
	int i,j,k,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char polarity[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, polarity );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_spi_set_cs_pin(jc, str_to_int(dev_index), id, str_to_int(polarity));
			ctx->script_printf( ctx, MSG_INFO_0, "CS set to Pin %s with polarity %d\n", pinname, str_to_int(polarity) );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_spi_clk_pin( script_ctx * ctx, char * line)
{
	int i,j,k,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char polarity[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, polarity );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_spi_set_clk_pin(jc, str_to_int(dev_index), id, str_to_int(polarity));
			ctx->script_printf( ctx, MSG_INFO_0, "CLK set to Pin %s with polarity %d\n", pinname, str_to_int(polarity) );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_spi_mosi_pin( script_ctx * ctx, char * line)
{
	int i,j,k,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char phase[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, phase );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_spi_set_mosi_pin(jc, str_to_int(dev_index), id, str_to_int(phase));
			ctx->script_printf( ctx, MSG_INFO_0, "MOSI set to Pin %s with polarity %d\n", pinname, str_to_int(phase) );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Bad/Missing parameter(s) ! : %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_set_spi_miso_pin( script_ctx * ctx, char * line)
{
	int i,j,k,id;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	char phase[DEFAULT_BUFLEN];
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	j = get_param( ctx, line, 2, pinname );
	k = get_param( ctx, line, 3, phase );

	if(i>=0 && j>=0 && k>=0)
	{
		id = jtagcore_get_pin_id(jc, str_to_int(dev_index), pinname);

		if(id>=0)
		{
			jtagcore_spi_set_miso_pin(jc, str_to_int(dev_index), id, str_to_int(phase));
			ctx->script_printf( ctx, MSG_INFO_0, "MISO set to Pin %s with polarity %d\n", pinname, str_to_int(phase) );
			return JTAG_CORE_NO_ERROR;
		}
		else
		{
			ctx->script_printf( ctx, MSG_ERROR, "Pin %s not found\n", pinname );
			return JTAG_CORE_NOT_FOUND;
		}
	}

	ctx->script_printf( ctx, MSG_ERROR, "Parameters error: %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_spi_rd_wr( script_ctx * ctx, char * line)
{
	int i,j,k,size;
	char data_out_txt[DEFAULT_BUFLEN];
	unsigned char data_out[DEFAULT_BUFLEN];
	unsigned char data_in[DEFAULT_BUFLEN];
	char lsbfirst[DEFAULT_BUFLEN];
	char tmp_buffer[3];
	int ret;
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	// jtag_spi_rd_wr 00123344 1  (DATA LSBFirst)
	i = get_param( ctx, line, 1, data_out_txt );
	j = get_param( ctx, line, 2, lsbfirst );

	if(i>=0)
	{
		if(j>=0)
		{
			jtagcore_spi_set_bitorder(jc, str_to_int(lsbfirst));
		}

		size  = strlen(data_out_txt);
		size = size / 2;
		for(k = 0; k<size; k++)
		{
			tmp_buffer[0] = data_out_txt[k*2];
			tmp_buffer[1] = data_out_txt[k*2 + 1];
			tmp_buffer[2] = 0;
			data_out[k] = (unsigned char)strtoul(tmp_buffer,0,16);
		}

		ret = jtagcore_spi_write_read(jc, size,data_out,data_in, 0);
		if( ret < 0 )
		{
			ctx->script_printf( ctx, MSG_ERROR, "Code %d !\n", ret );
			return ret;
		}

		ctx->script_printf( ctx, MSG_INFO_0, "SPI TX:" );
		for(k = 0; k<size; k++)
		{
			ctx->script_printf( ctx, MSG_NONE, " %.2X", data_out[k] );
		}
		ctx->script_printf( ctx, MSG_NONE, "\n" );

		ctx->script_printf( ctx, MSG_INFO_0, "SPI RX:" );
		for(k = 0; k<size; k++)
		{
			ctx->script_printf( ctx, MSG_NONE, " %.2X", data_in[k] );
		}
		ctx->script_printf( ctx, MSG_NONE, "\n" );

		return JTAG_CORE_NOT_FOUND;
	}

	ctx->script_printf( ctx, MSG_ERROR, "Parameters error: %s\n", line );

	return JTAG_CORE_BAD_PARAMETER;
}

static int cmd_get_pins_list( script_ctx * ctx, char * line)
{
	int i,j,nb_of_pins;
	char dev_index[DEFAULT_BUFLEN];
	char pinname[DEFAULT_BUFLEN];
	int type;
	jtag_core * jc;

	jc = (jtag_core *)ctx->app_ctx;

	i = get_param( ctx, line, 1, dev_index );
	if(i>=0)
	{
		nb_of_pins = jtagcore_get_number_of_pins(jc,str_to_int(dev_index));
		if(nb_of_pins>=0)
		{
			ctx->script_printf( ctx, MSG_INFO_0, "Device %d : %d pin(s)\n", str_to_int(dev_index), nb_of_pins );
			for(j = 0;j < nb_of_pins;j++)
			{
				if(jtagcore_get_pin_properties(jc, str_to_int(dev_index), j, pinname, sizeof(pinname), &type) == JTAG_CORE_NO_ERROR)
				{
					ctx->script_printf( ctx, MSG_NONE, "%s : ", pinname );
					if(type & JTAG_CORE_PIN_IS_INPUT)
					{
						ctx->script_printf( ctx, MSG_NONE, " in  " );
					}
					else
					{
						ctx->script_printf( ctx, MSG_NONE, "     " );
					}

					if(type & JTAG_CORE_PIN_IS_OUTPUT)
					{
						ctx->script_printf( ctx, MSG_NONE, " out " );
					}
					else
					{
						ctx->script_printf( ctx, MSG_NONE, "     " );
					}

					if(type & JTAG_CORE_PIN_IS_TRISTATES)
					{
						ctx->script_printf( ctx, MSG_NONE, " tris" );
					}
					else
					{
						ctx->script_printf( ctx, MSG_NONE, "     ");
					}

					ctx->script_printf( ctx, MSG_NONE, "\n");

				}
			}
		}

		return JTAG_CORE_NO_ERROR;
	}

	return JTAG_CORE_BAD_PARAMETER;
}

cmd_list script_commands_list[] =
{
	{"print",                   cmd_print},
	{"help",                    cmd_help},
	{"?",                       cmd_help},
	{"version",                 cmd_version},
	{"pause",                   cmd_pause},
	{"set",                     cmd_set_env_var},
	{"print_env_var",           cmd_print_env_var},
	{"call",                    cmd_call},
	{"system",                  cmd_system},

	{"if",                      cmd_if},
	{"goto",                    cmd_goto},
	{"return",                  cmd_return},

	{"rand",                    cmd_rand},

	{"init_array",              cmd_initarray},

	{"jtag_get_probes_list",    cmd_print_probes_list},
	{"jtag_open_probe",         cmd_open_probe},
	{"jtag_autoinit",           cmd_autoinit},

	{"jtag_init_scan",          cmd_init_and_scan},
	{"jtag_get_nb_of_devices",  cmd_print_nb_dev},
	{"jtag_get_devices_list",   cmd_print_devs_list},
	{"jtag_load_bsdl",          cmd_load_bsdl},
	{"jtag_set_mode",           cmd_set_scan_mode},

	{"jtag_push_pop",           cmd_push_and_pop},

	{"jtag_get_pins_list",      cmd_get_pins_list},

	{"jtag_set_pin_dir",        cmd_set_pin_mode},
	{"jtag_set_pin_state",      cmd_set_pin_state},
	{"jtag_get_pin_state",      cmd_get_pin_state},

	{"jtag_set_i2c_scl_pin",    cmd_set_i2c_scl_pin},
	{"jtag_set_i2c_sda_pin",    cmd_set_i2c_sda_pin},
	{"jtag_i2c_rd",             cmd_do_i2c_rd},
	{"jtag_i2c_wr",             cmd_do_i2c_wr},

	{"jtag_set_mdio_mdc_pin",   cmd_set_mdio_mdc_pin},
	{"jtag_set_mdio_mdio_pin",  cmd_set_mdio_mdio_pin},
	{"jtag_mdio_rd",            cmd_do_mdio_rd},
	{"jtag_mdio_wr",            cmd_do_mdio_wr},

	{"jtag_set_spi_cs_pin",     cmd_set_spi_cs_pin},
	{"jtag_set_spi_mosi_pin",   cmd_set_spi_mosi_pin},
	{"jtag_set_spi_miso_pin",   cmd_set_spi_miso_pin},
	{"jtag_set_spi_clk_pin",    cmd_set_spi_clk_pin},
	{"jtag_spi_rd_wr",          cmd_spi_rd_wr},

	{0 , 0}
};

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

script_ctx * jtagcore_initScript(jtag_core * jc)
{
	return init_script((void*)jc,0x00000000,(void*)jc->envvar);
}

void jtagcore_setScriptOutputFunc( script_ctx * ctx, SCRIPT_PRINTF_FUNC ext_printf )
{
	setOutputFunc_script(ctx, ext_printf);
}

int jtagcore_execScriptLine( script_ctx * ctx, char * line )
{
	if(!ctx)
		return JTAG_CORE_INTERNAL_ERROR;

	return execute_line_script( ctx, line );
}

int jtagcore_execScriptFile( script_ctx * ctx, char * script_path )
{
	if(!ctx)
		return JTAG_CORE_INTERNAL_ERROR;

	return execute_file_script( ctx, script_path );
}

int jtagcore_execScriptRam( script_ctx * ctx, unsigned char * script_buffer, int buffersize )
{
	if(!ctx)
		return JTAG_CORE_INTERNAL_ERROR;

	return execute_ram_script( ctx, script_buffer, buffersize );
}

script_ctx * jtagcore_deinitScript(script_ctx * ctx)
{
	if(!ctx)
		return NULL;

	return deinit_script(ctx);
}

int jtagcore_savePinsStateScript( jtag_core * jc, int device, char * script_path )
{
	FILE * f;
	int number_of_pins;
	int pin_type;
	int i,state;
	char pin_name[DEFAULT_BUFLEN];

	f = fopen(script_path,"w");
	if(f)
	{
		if(jc)
		{
			number_of_pins = jtagcore_get_number_of_pins( jc, device );

			if(number_of_pins>0)
			{
				for(i=0;i<number_of_pins;i++)
				{
					pin_type = 0;

					jtagcore_get_pin_properties( jc, device, i, (char*)&pin_name, sizeof(pin_name), &pin_type);

					if (pin_type)
					{
						fprintf(f,"print ----------------------------\n");

						// output enable
						if (pin_type & JTAG_CORE_PIN_IS_TRISTATES)
						{
							state = jtagcore_get_pin_state(jc, device, i, JTAG_CORE_OE);
							fprintf(f,"print Pin %s direction : %d\n",pin_name,state);
							fprintf(f,"jtag_set_pin_dir   %d %s %d\n",device,pin_name,state);
						}

						// output data
						if (pin_type & JTAG_CORE_PIN_IS_OUTPUT)
						{
							state = jtagcore_get_pin_state(jc, device, i, JTAG_CORE_OUTPUT);
							fprintf(f,"print Pin %s state : %d\n",pin_name,state);
							fprintf(f,"jtag_set_pin_state %d %s %d\n",device,pin_name,state);
						}

						// input data
						if (pin_type & JTAG_CORE_PIN_IS_INPUT)
						{
							state = jtagcore_get_pin_state(jc, device, i, JTAG_CORE_INPUT);
							fprintf(f,"print Input pin %s state : %d\n",pin_name,state);
						}
						fprintf(f,"\n");
					}
				}

				fprintf(f,"jtag_push_pop\n");
				fprintf(f,"\n");
			}
		}

		fclose(f);
	}
	return 0;
}