//--------------------------------
void SetvalueCommand(std::string in)
{
#ifdef TUNE_PARAMETERS
std::string arg1, arg2;
GetFirstArg(in, &arg1, &arg2);
if(arg1 == "k_saf")
{
param.at(0) = atof(arg2.c_str());
}
/*
else if(arg1 == "k_saf1")
{
param.at(1) = atof(arg2.c_str());
}
*/
else
{
std::cout << "error: wrong parameter name" << std ::endl
<< "resign" << std::endl;
param.clear();
}
InitEngine();
#else
UNUSED(in);
#endif
}
//--------------------------------
void PositionCommand(std::string in)
{
std::string arg1, arg2;
GetFirstArg(in, &arg1, &arg2);
if(arg1 == "fen")
{
std::string fenstring;
int beg = arg2.find_first_not_of(" \t");
fenstring = arg2.substr(beg, arg2.size());
if(!FenStringToEngine((char *)fenstring.c_str()))
{
std::cout << "Illegal position" << std::endl;
return;
}
}
else
InitEngine();
int moves = arg2.find("moves");
if(moves == -1)
return;
std::string mov_seq = arg2.substr(moves + 5, in.size());
int beg = mov_seq.find_first_not_of(" \t");
mov_seq = mov_seq.substr(beg, mov_seq.size());
ProcessMoveSequence(mov_seq);
}
//--------------------------------
void MemoryCommand(std::string in)
{
std::string arg1, arg2;
arg1 = in;
GetFirstArg(arg2, &arg1, &arg2);
int size_MB = atoi(arg1.c_str());
ReHash(size_MB);
}
//--------------------------------
void SetOptionCommand(std::string in)
{
std::string arg1, arg2;
GetFirstArg(in, &arg1, &arg2);
if(arg1 != "name")
return;
GetFirstArg(arg2, &arg1, &arg2);
if(arg1 == "Hash" || arg1 == "hash")
{
GetFirstArg(arg2, &arg1, &arg2);
if(arg1 != "value")
return;
GetFirstArg(arg2, &arg1, &arg2);
int size_MB = atoi(arg1.c_str());
ReHash(size_MB);
}
}
//--------------------------------
void ProcessMoveSequence(std::string in)
{
std::string arg1, arg2;
arg1 = in;
while(true)
{
GetFirstArg(arg1, &arg1, &arg2);
if(arg1.empty())
break;
if(!MakeMoveFinaly((char *)arg1.c_str()))
break;
arg1 = arg2;
}
}
//--------------------------------
void LevelCommand(std::string in)
{
if(busy)
return;
std::string arg1, arg2, arg3;
GetFirstArg(in, &arg1, &arg2);
GetFirstArg(arg2, &arg2, &arg3);
double base, mps, inc;
mps = atoi(arg1.c_str());
int colon = arg2.find(':');
if(colon != -1)
{
arg2.at(colon) = '.';
int size_of_seconds = arg2.size() - colon - 1;
base = atof(arg2.c_str());
if(base < 0)
base = -base;
if(size_of_seconds == 1)
base = 0.1*(base - (int)base) + (int)base;
int floorBase = (int)base;
base = (base - floorBase)*100/60 + floorBase;
}
else
base = atof(arg2.c_str());
inc = atof(arg3.c_str());
time_base = 60*1000000.*base;
time_inc = 1000000*inc;
moves_per_session = mps;
time_remains = time_base;
max_nodes_to_search = 0;
max_search_depth = max_ply;
}
//--------------------------------
bool CmdProcess(std::string in)
{
std::string firstWord, remains;
GetFirstArg(in, &firstWord, &remains);
unsigned i;
for(i = 0; i < sizeof(commands) / sizeof(cmdStruct); ++i)
{
if(firstWord == commands[i].command)
{
commands[i].foo(remains);
return true;
}
}
return false;
}
MemoryType* CreateCodeMachine ( char** SourceCode, Label* LabelTable, Command* CommandsTable, uint32_t ProgramSize )
{
ASSERT ( SourceCode );
ASSERT ( LabelTable );
ASSERT ( CommandsTable );
ASSERT ( ProgramSize );
MemoryType* MachineCode = ( MemoryType* ) calloc ( ProgramSize + SignatureSize, sizeof ( MemoryType ) );
ASSERT ( MachineCode );
MachineCode[0] = 'E';
MachineCode[1] = 'A';
MachineCode[2] = 'S';
MachineCode[3] = 'M';
MachineCode[4] = 'D';
MachineCode[5] = 'V';
MachineCode[6] = '1';
MachineCode[7] = '.';
MachineCode[8] = '1';
MachineCode[9] = ProgramSize;
uint32_t ProgramCounter = SignatureSize - 1;
uint32_t ProgramLine = 0;
while ( SourceCode[ProgramLine] != NULL )
{
uint32_t j = 0;
uint8_t ComSize = 0;
if ( GetLabelName ( SourceCode[ProgramLine] ) == NULL )
{
while ( IsSpace ( *( SourceCode[ProgramLine] + j ) ) == OK ) j++;
char Command[MaxLengthCommands] = {};
if ( sscanf ( SourceCode[ProgramLine] + j, "%[A-Z]", Command ) == 0 )
{
ProgramLine++;
continue;
}
MemoryType ReturnData = GetCommandCodeAndSize ( CommandsTable, Command, &ComSize );
ProgramCounter++;
MachineCode[ProgramCounter] = ReturnData;
while ( IsSpace ( *( SourceCode[ProgramLine] + j ) ) != OK &&
*( SourceCode[ProgramLine] + j ) != '\0' ) j++;
} else
{
ProgramLine++;
continue;
}
/**************************************************************************************************/
/**************************************************************************************************/
if ( ComSize != 1 && ( MachineCode[ProgramCounter] > JNZ ||
MachineCode[ProgramCounter] < CALL ) )
{
uint32_t NumReg = GetFirstArg ( SourceCode[ProgramLine], &j, RegArg );
if ( NumReg == Error )
{
printf ( " === Error first argument on line: %d ===", ProgramLine + 1 );
errno = EINVAL;
return NULL;
} else
{
ProgramCounter++;
MachineCode[ProgramCounter] = NumReg;
}
if ( ComSize == 2 )
{
ProgramLine++;
continue;
}
}
/**************************************************************************************************/
/**************************************************************************************************/
if ( ComSize == 3 )
{
uint32_t StartPos = j;
uint32_t SecArgReg = GetSecondArg ( SourceCode[ProgramLine], &j, RegArg );
j = StartPos;
uint32_t SecArgNum = GetSecondArg ( SourceCode[ProgramLine], &j, NumArg );
if ( SecArgReg == Error && SecArgNum == Error && errno != 0 )
{
printf ( " === Error second argument on line: %d ===", ProgramLine + 1 );
errno = EINVAL;
return NULL;
} else
{
if ( SecArgNum == Error && errno != 0 )
{
ProgramCounter++;
MachineCode[ProgramCounter] = SecArgReg;
errno = 0;
}
if ( SecArgReg == Error )
{
ProgramCounter++;
MachineCode[ProgramCounter] = SecArgNum;
MachineCode[ProgramCounter - 2]++;
}
}
}
/**************************************************************************************************/
/**************************************************************************************************/
if ( ComSize == 2 && MachineCode[ProgramCounter] <= JNZ &&
MachineCode[ProgramCounter] >= CALL )
{
uint64_t LabelName = GetFirstArg ( SourceCode[ProgramLine], &j, LblArg );
if ( LabelName == Error )
{
printf ( " === Error name of label on line: %d ===", ProgramLine + 1 );
errno = EINVAL;
return NULL;
}
uint32_t AddressLabel = GetAddressLabel ( LabelTable, ( char* )LabelName );
if ( AddressLabel == Error )
{
printf ( " === Not found label on line %d ===", ProgramLine + 1 );
errno = EINVAL;
return NULL;
} else
{
ProgramCounter++;
MachineCode[ProgramCounter] = AddressLabel;
}
}
ProgramLine++;
}
return MachineCode;
}
EFI_STATUS
SEnvCmdSA (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable,
IN EFI_LIST_ENTRY *Head,
IN EFI_GUID *Guid,
IN CHAR16 *CmdName,
IN UINT16 VHlpToken
)
/*++
Routine Description:
Code for shell "set" & "alias" command
Arguments:
ImageHandle - The image handle
SystemTable - The system table
Head - The variable list head
Guid - The guid
CmdName - The command name
VHlpToken - The help token
Returns:
--*/
{
EFI_LIST_ENTRY *Link;
VARIABLE_ID *Var;
VARIABLE_ID *Found;
CHAR16 *Name;
CHAR16 *Value;
UINTN SLen;
UINTN Len;
BOOLEAN Delete;
EFI_STATUS Status;
BOOLEAN Volatile;
UINTN Index;
SHELL_VAR_CHECK_CODE RetCode;
CHAR16 *Useful;
SHELL_VAR_CHECK_PACKAGE ChkPck;
SHELL_ARG_LIST *ArgItem;
EFI_SHELL_APP_INIT (ImageHandle, SystemTable);
Status = LibFilterNullArgs ();
if (EFI_ERROR (Status)) {
goto Quit;
}
ZeroMem (&ChkPck, sizeof (SHELL_VAR_CHECK_PACKAGE));
ArgItem = NULL;
RetCode = LibCheckVariables (SI, VarCheckList, &ChkPck, &Useful);
if (VarCheckOk != RetCode) {
switch (RetCode) {
case VarCheckConflict:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_FLAG_CONFLICT), HiiEnvHandle, CmdName, Useful);
break;
case VarCheckDuplicate:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_DUP_FLAG), HiiEnvHandle, CmdName, Useful);
break;
case VarCheckUnknown:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_UNKNOWN_FLAG), HiiEnvHandle, CmdName, Useful);
break;
default:
break;
}
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
//
// Initializing variable to aVOID level 4 warning
//
Name = NULL;
Value = NULL;
Delete = FALSE;
Status = EFI_SUCCESS;
Found = NULL;
Var = NULL;
Volatile = FALSE;
//
// Crack arguments
//
if (ChkPck.ValueCount > 2) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, CmdName);
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
if (LibCheckVarGetFlag (&ChkPck, L"-b") != NULL) {
EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF);
}
if (LibCheckVarGetFlag (&ChkPck, L"-?") != NULL) {
if (IS_OLD_SHELL) {
PrintToken (STRING_TOKEN (STR_NO_HELP), HiiEnvHandle);
goto Quit;
}
if (ChkPck.ValueCount > 0 ||
ChkPck.FlagCount > 2 ||
(2 == ChkPck.FlagCount && !LibCheckVarGetFlag (&ChkPck, L"-b"))
) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, CmdName);
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
PrintToken (VHlpToken, HiiEnvHandle);
Status = EFI_SUCCESS;
goto Quit;
}
if (LibCheckVarGetFlag (&ChkPck, L"-d") != NULL) {
if (ChkPck.ValueCount > 1) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, CmdName);
Status = EFI_INVALID_PARAMETER;
goto Quit;
} else if (ChkPck.ValueCount < 1) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_FEW), HiiEnvHandle, CmdName);
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
Delete = TRUE;
}
if (LibCheckVarGetFlag (&ChkPck, L"-v") != NULL) {
if (ChkPck.ValueCount < 2) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_FEW), HiiEnvHandle, CmdName);
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
Volatile = TRUE;
}
ArgItem = GetFirstArg (&ChkPck);
if (NULL != ArgItem) {
if (SEnvGetCmdDispath (ArgItem->VarStr) && (StriCmp (CmdName, L"alias") == 0)) {
PrintToken (STRING_TOKEN (STR_SHELLENV_VAR_INTERNAL_COMAMND), HiiEnvHandle, CmdName, ArgItem->VarStr);
Status = EFI_INVALID_PARAMETER;
goto Quit;
} else if (StrSubCmp (L"*", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"?", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"<", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L">", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"#", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L":", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"^", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"%", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"/", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"|", ArgItem->VarStr, 1) == TRUE ||
StrSubCmp (L"\"", ArgItem->VarStr, 1) == TRUE
) {
//
// we donot allow *,?,<,>,#,:,^,%,/,|," in alias or variable name
//
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_INVALID_ARG), HiiEnvHandle, CmdName, ArgItem->VarStr);
Status = EFI_INVALID_PARAMETER;
goto Quit;
} else {
Name = ArgItem->VarStr;
}
ArgItem = GetNextArg (ArgItem);
}
if (NULL != ArgItem) {
Value = ArgItem->VarStr;
}
if (Delete && Value) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, CmdName);
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
if (Name != NULL) {
for (Index = 0; mSpecVarTable[Index].CmdName != NULL; Index++) {
if (StriCmp (mSpecVarTable[Index].CmdName, CmdName) == 0 &&
StriCmp (mSpecVarTable[Index].VarName, Name) == 0 &&
mSpecVarTable[Index].SpecCheckFun != NULL
) {
Status = mSpecVarTable[Index].SpecCheckFun (Value, Delete, Volatile);
if (EFI_ERROR (Status)) {
goto Quit;
}
}
}
}
//
// Process
//
AcquireLock (&SEnvLock);
if (!Name) {
//
// dump the list
//
SEnvSortVarList (Head);
SLen = 0;
for (Link = Head->Flink; Link != Head; Link = Link->Flink) {
Var = CR (Link, VARIABLE_ID, Link, VARIABLE_SIGNATURE);
if (_IsReserved (Var->Name, CmdName)) {
continue;
}
Len = StrLen (Var->Name);
if (Len > SLen) {
SLen = Len;
}
}
for (Link = Head->Flink; Link != Head; Link = Link->Flink) {
//
// Break the execution?
//
if (GetExecutionBreak ()) {
goto Done;
}
Var = CR (Link, VARIABLE_ID, Link, VARIABLE_SIGNATURE);
if (_IsReserved (Var->Name, CmdName)) {
continue;
}
if (Var->Flags & VAR_ID_NON_VOL) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_DUMP_VAR_LIST),
HiiEnvHandle,
L' ',
SLen,
Var->Name,
Var->u.Str
);
} else {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_DUMP_VAR_LIST),
HiiEnvHandle,
L'*',
SLen,
Var->Name,
Var->u.Str
);
}
}
} else {
//
// Find the specified value
//
Found = SEnvFindVar (Head, Name);
if (Found && Delete) {
//
// Remove it from the store
//
Status = RT->SetVariable (Found->Name, Guid, 0, 0, NULL);
if (Status == EFI_NOT_FOUND) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_NOT_FOUND),
HiiEnvHandle,
CmdName,
Found->Name
);
}
} else if (Value) {
//
// Add it to the store
//
if (Found && ((Volatile && (Found->Flags & VAR_ID_NON_VOL)) || (!Volatile && !(Found->Flags & VAR_ID_NON_VOL)))) {
if (Found->Flags & VAR_ID_NON_VOL) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_ALREADY_EXISTS_NONVOLATILE),
HiiEnvHandle,
CmdName,
Found->Name
);
} else {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_ALREADY_EXISTS_VOLATILE),
HiiEnvHandle,
CmdName,
Found->Name
);
}
Found = NULL;
Status = EFI_ACCESS_DENIED;
} else {
Status = SEnvAddVar (
Head,
Guid,
Found ? Found->Name : Name,
(UINT8 *) Value,
StrSize (Value),
Volatile
);
}
} else {
if (Found) {
if (Found->Flags & VAR_ID_NON_VOL) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_DISPLAY_VAR),
HiiEnvHandle,
L' ',
Found->Name,
Found->u.Str
);
} else {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_DISPLAY_VAR),
HiiEnvHandle,
L'*',
Found->Name,
Found->u.Str
);
}
} else {
PrintToken (
STRING_TOKEN (STR_SHELLENV_VAR_NOT_FOUND),
HiiEnvHandle,
CmdName,
Name
);
}
Found = NULL;
}
//
// Remove the old in memory copy if there was one
//
if (Found && !EFI_ERROR (Status)) {
RemoveEntryList (&Found->Link);
FreePool (Found);
}
}
Done:
ReleaseLock (&SEnvLock);
Quit:
LibCheckVarFreeVarList (&ChkPck);
return Status;
}
EFI_STATUS
SEnvCmdEcho (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Shell command "echo".
Arguments:
ImageHandle - The image handle
SystemTable - The system table
Returns:
--*/
{
EFI_STATUS Status;
SHELL_VAR_CHECK_CODE RetCode;
CHAR16 *Useful;
SHELL_VAR_CHECK_PACKAGE ChkPck;
SHELL_ARG_LIST *Item;
BOOLEAN PageBreak;
EFI_SHELL_APP_INIT (ImageHandle, SystemTable);
if (!EFI_PROPER_VERSION (0, 99)) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_GNC_COMMAND_NOT_SUPPORT),
HiiEnvHandle,
L"echo",
EFI_VERSION_0_99
);
Status = EFI_UNSUPPORTED;
goto Done;
}
Status = EFI_SUCCESS;
PageBreak = FALSE;
ZeroMem (&ChkPck, sizeof (SHELL_VAR_CHECK_PACKAGE));
//
// No args: print status
// One arg, either -on or -off: set console echo flag
// Otherwise: echo all the args. Shell parser will expand any args or vars.
//
RetCode = LibCheckVariables (SI, EchoCheckList, &ChkPck, &Useful);
if (VarCheckOk != RetCode) {
switch (RetCode) {
case VarCheckDuplicate:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_DUP_FLAG), HiiEnvHandle, L"echo", Useful);
break;
case VarCheckUnknown:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_UNKNOWN_FLAG), HiiEnvHandle, L"echo", Useful);
break;
case VarCheckConflict:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_FLAG_CONFLICT), HiiEnvHandle, L"echo", Useful);
break;
default:
break;
}
Status = EFI_INVALID_PARAMETER;
goto Done;
}
if (LibCheckVarGetFlag (&ChkPck, L"-b") != NULL) {
EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF);
PageBreak = TRUE;
}
//
// Out put help.
//
if (LibCheckVarGetFlag (&ChkPck, L"-?") != NULL) {
if (IS_OLD_SHELL) {
PrintToken (STRING_TOKEN (STR_NO_HELP), HiiEnvHandle);
} else if (ChkPck.ValueCount > 0 ||
ChkPck.FlagCount > 2 ||
(2 == ChkPck.FlagCount && !LibCheckVarGetFlag (&ChkPck, L"-b"))
) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"echo");
Status = EFI_INVALID_PARAMETER;
} else {
PrintToken (STRING_TOKEN (STR_SHELLENV_ECHO_VERBOSE_HELP), HiiEnvHandle);
}
goto Done;
}
if (LibCheckVarGetFlag (&ChkPck, L"-on") != NULL) {
if (ChkPck.ValueCount != 0) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"echo");
Status = EFI_INVALID_PARAMETER;
goto Done;
} else {
SEnvBatchSetEcho (TRUE);
}
} else if (LibCheckVarGetFlag (&ChkPck, L"-off") != NULL) {
if (ChkPck.ValueCount != 0) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"echo");
Status = EFI_INVALID_PARAMETER;
goto Done;
} else {
SEnvBatchSetEcho (FALSE);
}
}
if ((ChkPck.FlagCount == 0 || (1 == ChkPck.FlagCount && PageBreak)) && ChkPck.ValueCount == 0) {
PrintToken (STRING_TOKEN (STR_SHELLENV_ECHO_ECHO_IS), HiiEnvHandle, (SEnvBatchGetEcho () ? L"on" : L"off"));
} else if (ChkPck.ValueCount > 0) {
Item = GetFirstArg (&ChkPck);
for (;;) {
Print (L"%s", Item->VarStr);
Item = GetNextArg (Item);
if (!Item) {
break;
}
Print (L" ");
}
Print (L"\n");
}
Done:
LibCheckVarFreeVarList (&ChkPck);
return Status;
}
EFI_STATUS
EFIAPI
InitializeAttrib (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Command entry point. Parses command line arguments and calls internal
function to perform actual action.
Arguments:
ImageHandle The image handle.
SystemTable The system table.
Returns:
EFI_SUCCESS - Command completed successfully
EFI_INVALID_PARAMETER - Command usage error
Other value - Unknown error
--*/
{
UINTN Index;
EFI_LIST_ENTRY FileList;
EFI_LIST_ENTRY *Link;
SHELL_FILE_ARG *Arg;
UINT64 Remove;
UINT64 Add;
EFI_STATUS Status;
SHELL_VAR_CHECK_CODE RetCode;
CHAR16 *Useful;
SHELL_ARG_LIST *Item;
SHELL_VAR_CHECK_PACKAGE ChkPck;
ZeroMem (&ChkPck, sizeof (SHELL_VAR_CHECK_PACKAGE));
//
// We are no being installed as an internal command driver, initialize
// as an nshell app and run
//
EFI_SHELL_APP_INIT (ImageHandle, SystemTable);
//
// Enable tab key which can pause the output
//
EnableOutputTabPause();
Status = LibFilterNullArgs ();
if (EFI_ERROR (Status)) {
return Status;
}
//
// Register our string package with HII and return the handle to it.
// If previously registered we will simply receive the handle
//
EFI_SHELL_STR_INIT (HiiHandle, STRING_ARRAY_NAME, EfiAttribGuid);
if (!EFI_PROPER_VERSION (0, 99)) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_GNC_COMMAND_NOT_SUPPORT),
HiiHandle,
L"attrib",
EFI_VERSION_0_99
);
Status = EFI_UNSUPPORTED;
goto Quit;
}
RetCode = LibCheckVariables (SI, AttribCheckList, &ChkPck, &Useful);
if (VarCheckOk != RetCode) {
switch (RetCode) {
case VarCheckConflict:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_FLAG_CONFLICT), HiiHandle, L"attrib", Useful);
break;
case VarCheckDuplicate:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_DUP_FLAG), HiiHandle, L"attrib", Useful);
break;
case VarCheckUnknown:
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_UNKNOWN_FLAG), HiiHandle, L"attrib", Useful);
break;
default:
break;
}
Status = EFI_INVALID_PARAMETER;
goto Quit;
}
//
// Out put help.
//
if (LibCheckVarGetFlag (&ChkPck, L"-b") != NULL) {
EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF);
}
if (LibCheckVarGetFlag (&ChkPck, L"-?") != NULL) {
if (IS_OLD_SHELL) {
PrintToken (STRING_TOKEN (STR_NO_HELP), HiiHandle);
goto Quit;
}
if (ChkPck.ValueCount > 0 ||
ChkPck.FlagCount > 2 ||
(2 == ChkPck.FlagCount && !LibCheckVarGetFlag (&ChkPck, L"-b"))
) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiHandle, L"attrib");
Status = EFI_INVALID_PARAMETER;
} else {
PrintToken (STRING_TOKEN (STR_ATTRIB_VERBOSE_HELP), HiiHandle);
Status = EFI_SUCCESS;
}
goto Quit;
}
//
// Local Variable Initializations
//
InitializeListHead (&FileList);
Link = NULL;
Arg = NULL;
Remove = 0;
Add = 0;
//
// Parse command line arguments
//
Item = GetFirstFlag (&ChkPck);
for (Index = 0; Index < ChkPck.FlagCount; Index += 1) {
if (Item->FlagStr[0] == '-') {
//
// Attributes to remove
//
Status = AttribSet (&Item->FlagStr[1], &Remove);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_INVALID_ARG), HiiHandle, L"attrib", Item->FlagStr);
goto Done;
}
} else if (Item->FlagStr[0] == '+') {
//
// Attributes to Add
//
Status = AttribSet (&Item->FlagStr[1], &Add);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_INVALID_ARG), HiiHandle, L"attrib", Item->FlagStr);
goto Done;
}
} else {
//
// we should never get here
//
ASSERT (FALSE);
}
Item = GetNextArg (Item);
}
Item = GetFirstArg (&ChkPck);
for (Index = 0; Index < ChkPck.ValueCount; Index += 1) {
Status = ShellFileMetaArg (Item->VarStr, &FileList);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_ATTRIB_CANNOT_OPEN), HiiHandle, L"attrib", Item->VarStr, Status);
goto Done;
}
Item = GetNextArg (Item);
}
//
// if no file is specified, get the whole directory
//
if (IsListEmpty (&FileList)) {
Status = ShellFileMetaArg (L"*", &FileList);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_ATTRIB_CANNOT_OPEN_DIR), HiiHandle, L"attrib", Status);
goto Done;
}
}
ShellDelDupFileArg (&FileList);
//
// Attrib each file
//
for (Link = FileList.Flink; Link != &FileList; Link = Link->Flink) {
//
// Break the execution?
//
if (GetExecutionBreak ()) {
goto Done;
}
Arg = CR (Link, SHELL_FILE_ARG, Link, SHELL_FILE_ARG_SIGNATURE);
Status = AttribFile (Arg, Remove, Add);
}
Done:
ShellFreeFileList (&FileList);
Quit:
LibCheckVarFreeVarList (&ChkPck);
LibUnInitializeStrings ();
return Status;
}
//--------------------------------
void UciGoCommand(std::string in)
{
pondering_in_process = false;
std::string arg1, arg2;
arg1 = in;
while(true)
{
GetFirstArg(arg1, &arg1, &arg2);
if(arg1.empty())
break;
if(arg1 == "infinite")
{
infinite_analyze = true;
break;
}
else if(arg1 == "wtime" || arg1 == "btime")
{
char clr = arg1[0];
GetFirstArg(arg2, &arg1, &arg2);
if((clr == 'w' && wtm) || (clr == 'b' && !wtm))
{
time_base = 1000.*atof(arg1.c_str());
time_remains = time_base;
max_nodes_to_search = 0;
max_search_depth = max_ply;
time_command_sent = true; // crutch: engine must know that time changed by GUI
}
arg1 = arg2;
}
else if(arg1 == "winc" || arg1 == "binc")
{
char clr = arg1[0];
GetFirstArg(arg2, &arg1, &arg2);
if((clr == 'w' && wtm) || (clr == 'b' && !wtm))
time_inc = 1000.*atof(arg1.c_str());
arg1 = arg2;
}
else if(arg1 == "movestogo")
{
GetFirstArg(arg2, &arg1, &arg2);
moves_per_session = atoi(arg1.c_str());
arg1 = arg2;
}
else if(arg1 == "movetime")
{
GetFirstArg(arg2, &arg1, &arg2);
time_base = 0;
moves_per_session = 1;
time_inc = 1000.*atof(arg1.c_str());
max_nodes_to_search = 0;
max_search_depth = max_ply;
time_remains = 0;
arg1 = arg2;
}
else if(arg1 == "depth")
{
GetFirstArg(arg2, &arg1, &arg2);
max_search_depth = atoi(arg1.c_str());
time_base = INFINITY;
time_remains = time_base;
max_nodes_to_search = 0;
arg1 = arg2;
}
else if(arg1 == "nodes")
{
GetFirstArg(arg2, &arg1, &arg2);
time_base = INFINITY;
time_remains = time_base;
max_nodes_to_search = atoi(arg1.c_str());
max_search_depth = max_ply;
arg1 = arg2;
}
else if(arg1 == "ponder")
{
pondering_in_process = true;
arg1 = arg2;
}
}//while(true
}
