char *MYRTLEXP StrCase( char *str,msCaseTypes type )
{ int n;
if ( !str || *str == 0 ) return str;
switch( type ){
case mscLower: StrLwr( str ); break;
case mscUpper: StrUpr( str ); break;
case mscCapitalize: StrLwr( str );
str[0] = ToUpper(str[0]);
break;
case mscUpLower: for ( n = 0; str[n]; n++ )
if ( isLower(str[n]) ) return str;
return StrCase( str,mscLower );
case mscLoUpper: for ( n = 0; str[n]; n++ )
if ( isUpper(str[n]) ) return str;
return StrCase( str,mscUpper );
case mscInvert: for ( n = 0; str[n]; n++ )
if ( isUpper(str[n]) )
str[n] = ToLower(str[n]);
else
str[n] = ToUpper(str[n]);
break;
}
return str;
}
//----------------------------------------------------------------------------
int RegWrite(int argc, char* argv[])
{
if(argc<2)
{
dprintf("regw <addr> <val> \n");
dprintf("regw <addr> <mask> <value>\n");
dprintf("ex: regw b8001000 ffffffff \n");
return;
}
// int off = strtoul((const char*)(argv[0]), (char **)NULL, 16);
unsigned int addr,mask=0,val;
StrUpr( argv[0] );
addr= strtoul((const char*)(argv[0]), (char **)NULL, 16);
//regw iocmd 0x0001
if(argc==2)
{ val = strtoul((const char*)(argv[1]), (char **)NULL, 16);
}
//regw iocmd 0x0001 0x0001
else if(argc>=3)
{
mask = strtoul((const char*)(argv[1]), (char **)NULL, 16);
val = strtoul((const char*)(argv[2]), (char **)NULL, 16);
}
if(mask==0)
REG32(addr)=val ; //avoid DR issue.
else
REG32(addr)= (REG32(addr) & mask) | val ;
}
int chgEnvCase(const int keepCase, char var[], const char value[])
{
assert(var);
if(!keepCase && (env_matchVar(0, var) & 7) != 0)
/* no match --> upcase variable */
StrUpr(var);
return chgEnv(var, value);
}
static char *
UpperCase(const char *text)
{
while (isspace(*text))
text++;
char *temp = new char[strlen(text)+1];
strcpy(temp, text);
for (int n = strlen(temp); n > 0; n--)
if (isspace(temp[n-1]))
temp[--n] = 0;
StrUpr(temp);
return temp;
}
//---------------------------------------------------------------------------
int RunAutoTestCmd2(const char *cmdstr, COMMAND_TABLE *pTestCmdTable, int len )
{
int argc ;
char** argv ;
int i, retval ;
argc = GetArgc( (const char *)cmdstr );
argv = GetArgv( (const char *)cmdstr );
if( argc < 1 ) return 0;
StrUpr( argv[0] );
//----
if(!strcmp( argv[0], "~") || !strcmp( argv[0], "Q") ) //return 1 to go back up directory
return 1;
if( *(argv[0])=='#' )
return 0;
if( *(argv[0])=='/' && *(argv[0]+1)=='/' ) // meet "//" to do nothing
return 0;
/*
if(argv[1]) cmd_line.fr= strtoul((const char*)(argv[1]), (char **)NULL, 16);
else cmd_line.fr=0;
if(argv[2]) cmd_line.sc= strtoul((const char*)(argv[2]), (char **)NULL, 16);
*/
//execute function
//int len=sizeof(pTestCmdTable) / sizeof(COMMAND_TABLE);
for( i=0 ; i < len ; i++ )
{
if( ! strcmp( argv[0], pTestCmdTable[i].cmd ) )
{
if(pTestCmdTable[i].func)
retval = pTestCmdTable[i].func( argc - 1 , argv+1 );
memset(argv[0],0,sizeof(argv[0]));
break;
}
}
if(i==len) dprintf("Unknown command !\r\n");
return 0;
}
void RunMonitor(char *PROMOPT, COMMAND_TABLE *TestCmdTable, int len)
{
char buffer[ MAX_MONITOR_BUFFER +1 ];
int argc ;
char** argv ;
int i, retval ;
while(1)
{
//printf( "%s", TEST_PROMPT );
dprintf( "%s", PROMOPT );
memset( buffer, 0, MAX_MONITOR_BUFFER );
GetLine( buffer, MAX_MONITOR_BUFFER,1);
dprintf( "\n" );
argc = GetArgc( (const char *)buffer );
argv = GetArgv( (const char *)buffer );
if( argc < 1 ) continue ;
StrUpr( argv[0] );
if(!strcmp( argv[0], "..") || !strcmp( argv[0], "Q") )
return;
//for( i=0 ; i < (sizeof(TestCmdTable) / sizeof(COMMAND_TABLE)) ; i++ )
for( i=0 ; i < (len) ; i++ )
{
if( ! strcmp( argv[0], TestCmdTable[i].cmd ) )
{
if(TestCmdTable[i].func)
retval = TestCmdTable[i].func( argc - 1 , argv+1 );
//dprintf("End run code\n");
memset(argv[0],0,sizeof(argv[0]));
break;
}
}
//if(i==sizeof(TestCmdTable) / sizeof(COMMAND_TABLE)) printf("Unknown command !\r\n");
if(i==len) printf("Unknown command !\r\n");
}
}
//---------------------------------------------------------------------------
int CMD_Wait2(int argc, char* argv[])
{
if( argc < 1 )
{
dprintf("wait t msec.\n");
dprintf("wait r reg mask expval timeout \n");
return 0;
}
StrUpr( argv[0] );
if( ! strcmp( argv[0], "T" ) )
{
if(argc>=2)
{
int wait = strtoul((const char*)(argv[1]), (char **)NULL, 10);
delay_ms(wait);
}
}
else if( ! strcmp( argv[0], "R" ) )
{
if(argc>=4)
{
unsigned int regaddr = strtoul((const char*)(argv[1]), (char **)NULL, 10);
unsigned int mask = strtoul((const char*)(argv[2]), (char **)NULL, 10);
unsigned int expval = strtoul((const char*)(argv[3]), (char **)NULL, 10);
while(1)
{
if( (REG32(regaddr) & mask ) == expval)
break;
}
}
}
};
// Function processes command line parameters
int ProcessCommandLine (int argc, char* argv[], Config& settings,
char*& pInFile, char*& pOutFile, char*& pConfig)
{
int cmdCount = 0;
char* cmdRead;
while (cmdCount < argc-1)
{
// command line error
if (cmdCount < 0)
return cmdCount;
// next command to process!
cmdCount++;
cmdRead = argv[cmdCount];
// this is a command directive
if (cmdRead[0] == '-')
{
// upcase the command parameter
StrUpr (cmdRead);
cmdRead++;
// miscellaneous flags, "sort +1"
DecodeFlg ("BCL", settings.braceLoc, False);
DecodeFlg ("BNL", settings.braceLoc, True);
DecodeInt ("CC", settings.posOfCommentsWC);
DecodeInt ("F", settings.numOfLineFunc);
DecodeStr ("FI", pInFile);
DecodeStr ("FNC", pConfig);
DecodeStr ("FO", pOutFile);
DecodeInt ("I", settings.tabSpaceSize);
DecodeFlg ("LG", settings.deleteHighChars, 3);
DecodeInt ("NC", settings.posOfCommentsNC);
DecodeInt ("QB", settings.queueBuffer);
DecodeFlg ("S", settings.useTabs, False);
DecodeFlg ("T", settings.useTabs, True);
DecodeFlg ("TBCL", settings.topBraceLoc, False);
DecodeFlg ("TBNL", settings.topBraceLoc, True);
// "No" flags
DecodeFlg ("NA", settings.deleteHighChars, 0);
DecodeFlg ("NB", settings.backUp, False);
DecodeFlg ("NBBI", settings.braceIndent2, False);
DecodeFlg ("NBI", settings.braceIndent, False);
DecodeFlg ("NLCNC", settings.leaveCommentsNC, False);
DecodeFlg ("NO", settings.output, False);
DecodeFlg ("NQ", settings.quoteChars, False);
// "Yes" flags
DecodeFlg ("YA", settings.deleteHighChars, 1);
DecodeFlg ("YB", settings.backUp, True);
DecodeFlg ("YBBI", settings.braceIndent2, True);
DecodeFlg ("YBI", settings.braceIndent, True);
DecodeFlg ("YLCNC", settings.leaveCommentsNC, True);
DecodeFlg ("YO", settings.output, True);
DecodeFlg ("YQ", settings.quoteChars, True);
// ### display help ###
if( (strcmp ("?", cmdRead) == 0) ||
(strcmp ("H", cmdRead) == 0) )
{
verbose ("*** Displaying Brief Help ***\n");
PrintProgramHelp ();
return -1;
}
warning ("Unknown Command Directive %s \n", cmdRead);
PrintProgramHelp ();
return -1;
}
else if (pInFile == NULL)
pInFile = argv [cmdCount];
else if (pOutFile == NULL)
pOutFile = argv [cmdCount];
else
{
warning ("Command Line Error : Expected Command Directive, Not %s\n", argv[cmdCount]);
PrintProgramHelp ();
return -1;
}
}
if (settings.queueBuffer < 2)
settings.queueBuffer = 2;
return 0;
}
int cmd_set(char *param)
{ char *value;
char *promptBuf = 0, tempcmd[255];
int ret;
optC = promptUser = upCaseValue = optExecute = 0;
if(leadOptions(¶m, opt_set, 0) != E_None)
return 1;
switch(breakVarAssign(ctxtEnvironment, param, &value)) {
case 1: /* no equal sign */
#ifdef FEATURE_CMD_SET_PRINT
if( ( value = getEnv( param ) ) != NULL ) printf( "%s\n", value );
else {
error_env_var_not_found( param );
return( 1 );
}
return( 0 );
#else
error_syntax(0);
return 1;
#endif
case 0: /* displayed */
return 0;
#ifdef DEBUG
case 2: break;
default:
dprintf(("[SET: Invalid response from breakVarAssign()]\n"));
return 1;
#endif
}
if(promptUser) { /* -> Display the value, then read and assign */
assert(value);
fputs(value, stdout);
promptBuf = malloc(promptBuffer);
if(!promptBuf) {
error_out_of_memory();
return E_NoMem;
}
fgets(promptBuf, promptBuffer, stdin);
if(cbreak) {
free(promptBuf);
return E_CBreak;
}
value = strchr(promptBuf, '\0');
while(--value >= promptBuf && (*value == '\n' || *value == '\r'));
value[1] = '\0'; /* strip trailing newlines */
value = promptBuf;
}
if (optExecute) {
char *tempfile = tmpfn();
FILE *fhandle;
if (!tempfile) return (1);
sprintf (tempcmd, "%s>%s", value, tempfile);
parsecommandline (tempcmd, TRUE);
fhandle = fopen (tempfile, "r");
if (!fhandle) {
unlink (tempfile);
free (tempfile);
return (1);
}
fgets (tempcmd, 255, fhandle);
value = strchr(tempcmd, '\n');
if (value) *value = '\0';
value = tempcmd;
fclose (fhandle);
unlink (tempfile);
free (tempfile);
}
/* If the value is just blanks, it means to delete the value;
but otherwise even leading and trailing spaces must be kept */
if(is_empty(value))
value = 0;
if (upCaseValue) StrUpr(value); /* set value as upper case, eg for if testing */
ret = chgEnvCase(optC, param, value);
free(promptBuf);
return ret;
}
//---------------------------------------------------------------------------
//----------------------------------------------------------------------------
int RegRead(int argc, char* argv[])
{
if(argc<1)
{//dump all
dprintf("\n");
dprintf("regr addr \n");
return;
}
int addr,val;
unsigned int check=0,mask=0xffffffff,expval=0;
StrUpr( argv[0] );
addr= strtoul((const char*)(argv[0]), (char **)NULL, 16);
val=REG32(addr);
//regr iocmd
if(argc==1)
{ //dprintf("%x\n", val );
}
//regr iocmd 0001
else if(argc==2)
{
mask = strtoul((const char*)(argv[1]), (char **)NULL, 16);
}
//regr iocmd : 0x0001
else if( argc>=3 && *(argv[1])==':' )
{ check=1;
expval = strtoul((const char*)(argv[2]), (char **)NULL, 16);
}
//regr iocmd 0x0001 : 0x0001
else if(argc>=3 && *(argv[1]) != '\0')
{
mask = strtoul((const char*)(argv[1]), (char **)NULL, 16);
if(argc>=3 && *(argv[2]) == ':')
{ check=1;
expval = strtoul((const char*)(argv[3]), (char **)NULL, 16);
}
}
//verify
if(!check)
{
dprintf("Addr %08x, %s=%08x \n", addr, argv[0],val&mask );
}
else
{
if( (val&mask) !=expval)
{ dprintf("Fail, addr=%08x val=%x, expval=%x \n", addr, val, expval);
at2_errcnt++;
}
else
dprintf("Pass \n");
}
}
