void ExecuteCommand(nodeT **t,char command,int key) { /* printf("\nExcuteCommand Hit here\n");*/ double i; int h; int count; switch (toupper(command)) { case 'I': InsertNode(t, key);break; case 'D': printf("\n");DeleteNode(t, key);printf("\n"); break; case 'F': printf("\n");FindNode(*t,key);printf("\n"); break; case 'O': printf("\n");ListInOrder(*t); printf("\n");break; case 'P': printf("\n");PreOrderWalk(*t);printf("\n"); break; case 'A': printf("\n");PostOrderWalk(*t);printf("\n"); break; case 'L': printf("\n");NodeLevelOrder(*t);printf("\n"); break; case 'S': printf("\n");i=add(*t);printf("Sum of tree is:%f\n",i); break; case 'N': printf("\n");printf("Min:");Min(*t); printf("\n");break; case 'X': printf("\n");printf("Max:");Max(*t); printf("\n");break; case 'T': printf("\n");h=height(*t); printf("Height:%d\n",h);break; case 'C': printf("\n");count=Count(*t); printf("Number of inputs is:%d\n",count);break; case 'H': printf("\n");HelpCommand(); printf("\n");break; case 'Q': free_all(*t);exit(0); default: printf("Illegal command\n"); break; } }
int main() { treeT *t = NULL; char command = '\0'; int key= 0; int quit = 0; int flag = 1; printf("\nPlease enter a command and a number.If no number is needed enter 1.Here is a help command:\n"); HelpCommand(); /****create tree and call excute command***/ while(1) { printf("*"); fscanf(stdin,"%c %d",&command,&key); if( key == '\0' || command == '\0') { fscanf(stdin,"%c %d",&command,&key); } ExecuteCommand(&t,command,key); printf("\nCOMMAND = %c, KEY=%d\n",command,key); key =command = '\0'; } return(0); }
int main () { stackADT operandStack; string line; char ch; printf("RPN kalkulator -- symulacja (napisz H aby otrzymać pomoc)\n"); operandStack=NewStack(); while (TRUE) { printf("> "); line=GetLine(); ch=toupper(line[0]); switch (ch) { case 'Q': exit(0); case 'H': HelpCommand(); break; case 'C': ClearStack(operandStack); break; case 'D': DisplayStack(operandStack); break; default: if (isdigit(ch)) Push(operandStack, StringToReal(line)); else ApplyOperator(ch, operandStack); break; } } }
static void AutoComplete(p_shell_context_t context) { int32_t len; int32_t minLen; uint8_t i = 0; const shell_command_context_t *tmpCommand = NULL; const char *namePtr; const char *cmdName; minLen = 0; namePtr = NULL; if (!StrLen(context->line)) { return; } context->printf_data_func("\r\n"); /* Empty tab, list all commands */ if (context->line[0] == '\0') { HelpCommand(context, 0, NULL); return; } /* Do auto complete */ for (i = 0; i < g_RegisteredCommands.numberOfCommandInList; i++) { tmpCommand = g_RegisteredCommands.CommandList[i]; cmdName = tmpCommand->pcCommand; if (StrCompare(context->line, cmdName, StrLen(context->line)) == 0) { if (minLen == 0) { namePtr = cmdName; minLen = StrLen(namePtr); /* Show possible matches */ context->printf_data_func("%s\r\n", cmdName); continue; } len = StrCompare(namePtr, cmdName, StrLen(namePtr)); if (len < 0) { len = len * (-1); } if (len < minLen) { minLen = len; } } } /* Auto complete string */ if (namePtr) { StrCopy(context->line, namePtr, minLen); } context->printf_data_func("%s%s", context->prompt, context->line); return; }
static void ExecuteCommand(bufferADT buffer, string line) { int i; switch (toupper(line[0])) { case 'I': for (i = 1; line[i] != '\0'; i++) { InsertCharacter(buffer, line[i]); } break; case 'D': DeleteCharacter(buffer); break; case 'F': MoveCursorForward(buffer); break; case 'B': MoveCursorBackward(buffer); break; case 'J': MoveCursorToStart(buffer); break; case 'E': MoveCursorToEnd(buffer); break; case 'H': HelpCommand(); break; case 'Q': exit(0); default: printf("Illegal command\n"); break; } }
//int _tmain(/*int argc, TCHAR* argv[], TCHAR* envp[]*/) int main () { int nRetCode = 0; HRESULT hr; CSettings *pSettings = NULL; CPrompt *pPrompt = NULL; CShellCommandsLinkedList CommandsList(Console); CShellCommandExit ExitCommand; CommandsList.AddCommand(&ExitCommand); CShellCommandVersion VersionCommand; CommandsList.AddCommand(&VersionCommand); CShellCommandHelp HelpCommand(CommandsList); CommandsList.AddCommand(&HelpCommand); CShellCommandDir DirCommand(Tree); CommandsList.AddCommand(&DirCommand); CShellCommandChangeKey ChangeKeyCommand(Tree); CommandsList.AddCommand(&ChangeKeyCommand); CShellCommandValue ValueCommand(Tree); CommandsList.AddCommand(&ValueCommand); CShellCommandOwner OwnerCommand(Tree); CommandsList.AddCommand(&OwnerCommand); CShellCommandDACL DACLCommand(Tree); CommandsList.AddCommand(&DACLCommand); CShellCommandSACL SACLCommand(Tree); CommandsList.AddCommand(&SACLCommand); CShellCommandConnect ConnectCommand(Tree); CommandsList.AddCommand(&ConnectCommand); CShellCommandNewKey NewKeyCommand(Tree); CommandsList.AddCommand(&NewKeyCommand); CShellCommandDeleteKey DeleteKeyCommand(Tree); CommandsList.AddCommand(&DeleteKeyCommand); CShellCommandSetValue SetValueCommand(Tree); CommandsList.AddCommand(&SetValueCommand); CShellCommandDeleteValue DeleteValueCommand(Tree); CommandsList.AddCommand(&DeleteValueCommand); CArgumentParser Parser; pSettings = new (std::nothrow) CSettings(); if (!pSettings) { _ftprintf(stderr,_T("Cannot initialize settings. Out of memory.\n")); goto Abort; } hr = pSettings->Load(SETTINGS_REGISTRY_KEY); if (FAILED(hr)) { _ftprintf(stderr,_T("Cannot load settings. Error is 0x%X.\n"),(unsigned int)hr); goto Abort; } pPrompt = new (std::nothrow) CPrompt(Tree,hr); if (!pPrompt) { _ftprintf(stderr,_T("Cannot initialize prompt. Out of memory.\n")); goto Abort; } if (FAILED(hr)) { _ftprintf(stderr,_T("Cannot initialize prompt. Error is 0x%X.\n"),(unsigned int)hr); goto Abort; } // input buffer size in chars #define INPUT_BUFFER_SIZE 1024 //#define INPUT_BUFFER_SIZE 128 //#define INPUT_BUFFER_SIZE 10 TCHAR *pchCommand; pchCommand = Console.Init(INPUT_BUFFER_SIZE,10); if (pchCommand == NULL) { _ftprintf(stderr,_T("Cannot initialize console.\n")); nRetCode = 1; goto Exit; } Console.SetReplaceCompletionCallback(CompletionCallback); WORD wOldConsoleAttribute; if (!Console.GetTextAttribute(wOldConsoleAttribute)) goto Abort; Console.SetTitle(_T("Registry Explorer")); Console.SetTextAttribute(pSettings->GetNormalTextAttributes()); VERIFY(SetConsoleCtrlHandler((PHANDLER_ROUTINE)HandlerRoutine,TRUE)); if (!Console.Write(HELLO_MSG //(_L(__TIMESTAMP__)) )) goto Abort; //Tree.SetDesiredOpenKeyAccess(KEY_READ); hr = pPrompt->SetPrompt(pSettings->GetPrompt()); if (FAILED(hr)) { _ftprintf(stderr,_T("Cannot initialize prompt. Error is 0x%X.\n"),(unsigned int)hr); goto Abort; } GetCommand: // prompt // TODO: make prompt user-customizable Console.EnableWrite(); pPrompt->ShowPrompt(Console); Console.FlushInputBuffer(); blnCommandExecutionInProgress = FALSE; // Set command line color Console.SetTextAttribute(pSettings->GetCommandTextAttributes()); if (!Console.ReadLine()) goto Abort; // Set normal color Console.SetTextAttribute(pSettings->GetNormalTextAttributes()); Console.BeginScrollingOperation(); blnCommandExecutionInProgress = TRUE; // Parse command line (1st step - convert to multi sz) Parser.SetArgumentList(pchCommand); int nCommandReturnValue; switch(CommandsList.Execute(Parser,nCommandReturnValue)) { case -1: // not recognized command { Parser.ResetArgumentIteration(); TCHAR *pchCommandItself = Parser.GetNextArgument(); size_t cmdlen = _tcslen(pchCommandItself); if ((!cmdlen)|| (pchCommandItself[cmdlen-1] != _T('\\'))|| (Parser.GetNextArgument())|| (!Tree.ChangeCurrentKey(pchCommandItself))) { Console.Write(_T("Unknown command \"")); Console.Write(pchCommandItself); Console.Write(_T("\"\n")); } } case -2: // empty line goto GetCommand; case 0: // exit command nRetCode = 0; Console.SetTextAttribute(wOldConsoleAttribute); goto Exit; default: Console.Write(_T("\n")); goto GetCommand; } Abort: _ftprintf(stderr,_T("Abnormal program termination.\nPlease report bugs to ") EMAIL _T("\n")); nRetCode = 1; Exit: if (pSettings) delete pSettings; if (pPrompt) delete pPrompt; return nRetCode; }
VOID Monitor( IN ULONG CallerSource, IN PFW_EXCEPTION_FRAME Frame ) /*++ Routine Description: This is the main dispatch routine to the various commands that can be typed at the monitor prompt. Arguments: For Alpha/Jensen: CallerSource 0 if exception (or bugcheck, on Alpha/Jensen) 3 if called from boot menu Frame the machine / exception state. Return Value: None. --*/ { CHAR Buffer[2][128]; ULONG ParityDiag[3]; PULONG ParDiag; ULONG BufferIndex; PCHAR Argv[10]; PCHAR Tmp; CHAR String[128]; BOOLEAN CommandValid; GETSTRING_ACTION Action; #ifdef ALPHA_FW_KDHOOKS // // If this is a breakpoint exception which is recognized, process it. // Otherwise, continue into the Monitor. // if ((Frame->ExceptionType == FW_EXC_BPT) && (FwKdProcessBreakpoint(Frame) == TRUE)) { // // This does not return. // FwRfe(Frame); } #endif FwPrint(MON_MONITOR_MSG); FwPrint(MON_PRESS_H_MSG); // // Initialize command line to null. // Argv[0] = (PCHAR)NULL; if (CallerSource !=3) { // // Display Cause of exception. // if ((Frame->ExceptionType >= FW_EXC_FIRST) && (Frame->ExceptionType <= FW_EXC_LAST) ) { FwPrint(ExceptionNameTable[(Frame->ExceptionType & 0xf)]);} else { FwPrint("** !! Unknown Exception"); } FwPrint(MON_EXCEPTION_MSG); FwPrint("PC = 0x%016Lx, VA = 0x%016Lx\r\n", Frame->ExceptionFaultingInstructionAddress, Frame->ExceptionVa); // // If an exception happened before the ARC console was opened, // a call to JzGetString will not work since JzGetString calls // ArcRead. So, close the console (nothing bad will happen if these // are not already opened) and reopen it. // FwClose(ARC_CONSOLE_INPUT); FwClose(ARC_CONSOLE_OUTPUT); #ifdef ALPHA_FW_KDHOOKS // // If we are built with the kernel debugger stubs, and have come // here because of an exception, we want to enter the debugger. // Frame->ExceptionType = FW_EXC_BPT; DbgBreakPoint(); #endif FwOpenConsole(); } // // Initialize Static variables. // DefaultAddress = KSEG0_BASE; DataSize = MON_QUAD; BufferIndex = 0; // // loop forever getting commands and dispatching them // while(TRUE) { // // print prompt // FwPrint(">"); // // read a command. // do { Action = JzGetString(Buffer[BufferIndex], 128, NULL, FwRow+1, FwColumn+1, FALSE); } while ((Action != GetStringSuccess) && (Action != GetStringEscape)); FwPrint(FW_CRLF_MSG); // // convert string to lower case. // for (Tmp=Buffer[BufferIndex];*Tmp;*Tmp++) { *Tmp=tolower(*Tmp); } // // if escape was pressed, simulate a quit command. // if (Action == GetStringEscape) { Argc = 1; Argv[0] = "q"; // // separate command line into tokens delimited by spaces // load up Argv with pointers to arguments and put count in Argc // } else if (*Buffer[BufferIndex] != '\0') { Tmp = Buffer[BufferIndex]; Argc = 0; // // Skip leading blanks // while ( *Tmp == ' ') { Tmp++; } while ( *Tmp ) { Argv[Argc++] = Tmp; while ( *Tmp ) { if (*Tmp == ' ') { *Tmp++ = '\0'; while ( *Tmp == ' ') { Tmp++; } break; } Tmp++; } } // // Increment index so that next command is read into the other // buffer. And we preserve the previous one. // BufferIndex = (BufferIndex+1) & 0x1; } else { // // repeat the last command already in Argv Argc // } // // if first argument is not null, then dispatch to routines. // if (Argv[0] != (PCHAR) NULL) { CurrentArg = 1; CurrentCommand = GetCommand(Argv[0]); switch(CurrentCommand) { case DumpByte: case DumpWord: case DumpLongword: case DumpQuad: DataSizeShift = (CurrentCommand - Dump -1); DataSize = 1 << DataSizeShift; DataSizeMask = DataSize-1; case Dump: CommandValid = DumpCommand(Argv,Frame); break; case EnterByte: case EnterWord: case EnterLongword: case EnterQuad: DataSizeShift = (CurrentCommand - Enter -1); DataSize = 1 << DataSizeShift; DataSizeMask = DataSize-1; case Enter: CommandValid = EnterCommand(Argv,Frame); break; case Help: case Help2: HelpCommand(); break; case DepositByte: case DepositWord: case DepositLongword: case DepositQuad: DataSizeShift = (CurrentCommand - Deposit -1); DataSize = 1 << DataSizeShift; DataSizeMask = DataSize-1; case Deposit: CommandValid = DepositCommand(Argv,Frame); break; case ExamineByte: case ExamineWord: case ExamineLongword: case ExamineQuad: DataSizeShift = (CurrentCommand - Examine -1); DataSize = 1 << DataSizeShift; DataSizeMask = DataSize-1; case Examine: CommandValid = ExamineCommand(Argv,Frame); break; case IOReadByte: case IOReadWord: case IOReadLongword: DataSizeShift = (CurrentCommand - IORead -1); DataSize = 1 << DataSizeShift; DataSizeMask = DataSize-1; case IORead: CommandValid = IOReadCommand(Argv, Frame); break; #if 0 case IOWriteByte: case IOWriteWord: case IOWriteLongword: DataSizeShift = (CurrentCommand - IOWrite -1); DataSize = 1 << DataSizeShift; DataSizeMask = DataSize-1; case IOWrite: CommandValid = IOWriteCommand(Argv, Frame); break; #endif case Register: case IntegerRegisterDump: case FloatingRegisterDump: CommandValid = RegisterCommand(Argv, Frame); break; case Zero: CommandValid = ZeroCommand(Argv,Frame); break; case Fill: CommandValid = FillCommand(Argv,Frame); break; #if 0 case AvailableDevices: CommandValid = FwDumpLookupTable(); break; #endif case Quit: if (CallerSource == 3) { return; } else { // // We came because of an exception. // The only way to exit is reseting the system. // FwPrint(MON_NO_RETURN_MSG); FwPrint(MON_RESET_MACHINE_MSG); do { Action = JzGetString(Buffer[BufferIndex], 128, NULL, FwRow+1, FwColumn+1, FALSE); } while ((Action != GetStringSuccess) && (Action != GetStringEscape)); FwPrint(FW_CRLF_MSG); Buffer[BufferIndex][0]=tolower(Buffer[BufferIndex][0]); if (strcmp(Buffer[BufferIndex],"y") == 0) { ResetSystem(); } break; } case invalidcommand: FwPrint(MON_UNRECOGNIZED_COMMAND_MSG); // // Clear the argument so that re-do last command // doesn't repeat the erroneous command. // CommandValid = FALSE; break; } if (!CommandValid) { Argv[0] = (PCHAR) NULL; } } } }