// Main Debugger Loop void Debugger::enter() { // TODO: Having three I/O methods #ifdef-ed in this file is not the // cleanest approach to this... #ifndef USE_TEXT_CONSOLE if (_firstTime) { DebugPrintf("Debugger started, type 'exit' to return to the game.\n"); DebugPrintf("Type 'help' to see a little list of commands and variables.\n"); _firstTime = false; } if (_errStr) { DebugPrintf("ERROR: %s\n\n", _errStr); free(_errStr); _errStr = NULL; } _debuggerDialog->runModal(); #else printf("Debugger entered, please switch to this console for input.\n"); #ifdef USE_READLINE // TODO: add support for saving/loading history? g_readline_debugger = this; rl_completion_entry_function = &readline_completionFunction; char *line_read = 0; do { free(line_read); line_read = readline("debug> "); if (line_read && line_read[0]) add_history(line_read); } while (line_read && parseCommand(line_read)); free(line_read); line_read = 0; #else int i; char buf[256]; do { printf("debug> "); if (!fgets(buf, sizeof(buf), stdin)) return; i = strlen(buf); while (i > 0 && buf[i - 1] == '\n') buf[--i] = 0; if (i == 0) continue; } while (parseCommand(buf)); #endif #endif }
//Pipe function to allow piping between two programs. void pipe(const std::string command, std::chrono::duration<double>& totalTime){ char** argv1; char** argv2; //Getting two char** argv's from the one already made, //splitting it by the '|' character/argument in argv. std::string command1 = ""; std::string command2 = ""; std::stringstream ss; ss.str(command); getline(ss, command1, '|'); getline(ss, command2); parseCommand(command1, argv1); parseCommand(command2, argv2); //Constants setup const int PIPE_COUNT = 2; const int PIPE_READ_END = 0; const int PIPE_WRITE_END = 1; const int STDIN = 0; const int STDOUT = 1; //Pipe creation int pids[PIPE_COUNT]; pipe(pids); //Duplicate stdout and stdin to use to connect the //ends back together later int savedStdout = dup(STDOUT); int savedStdin = dup(STDIN); //First process: put the pipe's write end in place of stdout. pid_t pid1 = fork(); if (pid1 == 0){ dup2(pids[PIPE_WRITE_END], STDOUT); runAndTimeChildProcess(argv1[0], argv1, totalTime); exit(111); } //Second process: put the pipe's read end in place of stdin, //and close the pipe's write end to tell 2nd process no more //data is coming for it to read. pid_t pid2 = fork(); if (pid2 == 0){ dup2(pids[PIPE_READ_END], STDIN); close(pids[PIPE_WRITE_END]); runAndTimeChildProcess(argv2[0], argv2, totalTime); exit(111); } int status; waitpid(pid1, &status, 0); close(pids[PIPE_WRITE_END]); close(pids[PIPE_READ_END]); waitpid(pid2, &status, 0); dup2(savedStdout, STDOUT); dup2(savedStdin, STDIN); }
int main(int argc, char*argv[]){ string test = "PUT:fileName:DATA"; int t = parseCommand(test); string data = listen(PORT); int command = parseCommand(data); if(command == PUT){ string fileName = getFileName(data); string dataToWrite = getData(data); writeFile(fileName, dataToWrite); } return 0; }
int connectionReceiveCommand(connection *con) { int socketFD = con->tArgs->socketFD; command *cmd = con->cmd; error *err = con->err; // if (cmd->args != NULL) { // free(cmd->args); // cmd->args = NULL; // } destroyCommandArgs(cmd); printf("\n>====== Waiting to receive command from client...\n"); char buf[BUFSIZE]; memset(buf, 0, BUFSIZE); int term; if (messageReceive(socketFD, buf, &(con->dataBytes), &(con->data), &term)) { if (term) { ERROR(err, E_EXIT); } else { ERROR(err, E_MSG); } return 1; } return parseCommand(buf, cmd, err); }
void ClientThread::run() { QTcpSocket tcpSocket; if (!tcpSocket.setSocketDescriptor(m_socketDescriptor)) { qWarning() << ":((("; emit error(tcpSocket.error()); return; } m_running = true; QString command, response; // Send greetings tcpSocket.write("OK MPD 0.12.2\n"); while (m_running && (tcpSocket.state() == QAbstractSocket::ConnectedState)) { m_running = tcpSocket.waitForReadyRead(); // Wait for command, // if none is received until timeout // (default 30 seconds, stop running). command = QString(tcpSocket.readLine()).trimmed(); qDebug() << command; tcpSocket.write(parseCommand(command).toLocal8Bit()); } tcpSocket.disconnectFromHost(); }
void browsers::CellBrowser::OnWXOpenCell(wxCommandEvent& event) { _activeStructure = top_structure = RBcellID; wxString cmd; cmd << wxT("opencell(\"") << GetItemText(RBcellID) <<wxT("\");"); parseCommand(cmd); }
CMD *parseCommand(token **lstHead) { CMD *cmd = parseAndOr(lstHead); if(cmd->type == ERROR) { //propagate an error return cmd; } //check to make sure that end of linked list not reached if(cmd && *lstHead && ((*lstHead)->type == SEP_END || (*lstHead)->type == SEP_BG)) { CMD *andorCMD = cmd; cmd = mallocCMD(); cmd->type = (*lstHead)->type; cmd->left = andorCMD; *lstHead = (*lstHead)->next; if(*lstHead) { cmd->right = parseCommand(lstHead); if(cmd->right->type == ERROR) { //propagate along an error return cmd->right; } } } return cmd; }
static void handleCommand(char *command) { commandinfo *cinfo = parseCommand(command, MSG_OUTGOING); switch (cinfo->command) { case C_QUIT: cleanup(0); break; case C_SYNACK: sendMessage(sock, "ACK"); break; case C_GET: if (cinfo->param == P_POSTS) { sendMessage(sock, command); } else if (cinfo->param == P_POST) { sendMessage(sock, command); } break; default: sendMessage(sock, command); break; } freeCommandInfo(cinfo); }
//Ingresa un string que puede ser tanto un comando, una variable o un literal //por lo que se procesa y devuelve resuelto, si corresponde, en formato de lista std::vector<std::string> InterpreteLISP::procesarComandoLISP( const std::string &input) const { std::vector<std::string> comando; std::string palabra; if (input.empty()) return comando; if (input.at(0) =='(') { //el string ingresado es comando LISP comando = parseCommand(input); std::string nombreFuncion; nombreFuncion = comando.front(); comando.erase(comando.begin()); FuncionLISP* funcion = (*funcionesAmbiente)[nombreFuncion]; comando = funcion->resolver(comando, *this); } else { //el string ingresado es un simbolo if ((*variablesAmbiente)[input] != NULL) { //el simbolo es una variable definida anteriormente return *((*variablesAmbiente)[input])->getVariable(); } else { //el simbolo ingresado es un literal comando.push_back(input); } } return comando; }
void printNetDevSentBytes(const char *cmd) { int i; char **retval; retval = parseCommand(cmd); if (retval == NULL) return; for (i = 0; i < NetDevCnt; i++) { if (!strcmp(NetDevs[i].name, retval[0])) { if (!strncmp(retval[1], "data", 4)) fprintf(CurrentClient, "%lu", (u_long)((NetDevs[i].sentBytes - NetDevsOld[i].sentBytes) / (1024 * elapsed))); if (!strncmp(retval[1], "packets", 7)) fprintf(CurrentClient, "%lu", (u_long)((NetDevs[i].sentPacks - NetDevsOld[i].sentPacks) / elapsed)); if (!strncmp(retval[1], "errors", 6)) fprintf(CurrentClient, "%lu", (u_long)((NetDevs[i].sentErrs - NetDevsOld[i].sentErrs) / elapsed)); if (!strncmp(retval[1], "multicast", 9)) fprintf(CurrentClient, "%lu", (u_long)((NetDevs[i].sentMulticast - NetDevsOld[i].sentMulticast) / elapsed)); if (!strncmp(retval[1], "collisions", 10)) fprintf(CurrentClient, "%lu", (u_long)((NetDevs[i].sentColls - NetDevsOld[i].sentColls) / elapsed)); } } free(retval[0]); free(retval[1]); free(retval); fprintf(CurrentClient, "\n"); }
void Client::listen() { string line; string response = ""; string request = ""; cout << "% "; // loop to handle user interface while (getline(cin,line)) { request = parseCommand(line); if(request.size() == 0){ cout << "% "; continue; } bool success = sendRequest(request); // break if an error occurred if (not success) break; // get a response success = getResponse(); // break if an error occurred if (not success) break; cout << "% "; } close(server_); }
void parseByte (int newByte) // parse an incoming commandbyte from serial interface, perform command if valid { static uint8_t cmdlen=0; if (CimParserActive) parse_CIM_protocol(newByte); // handle AsTeRICS CIM protocol messages ! else { switch (readstate) { case 0: if ((newByte=='A') || (newByte=='a')) readstate++; if (newByte=='@') { readstate++; CimParserActive=1; } // switch to AsTeRICS CIM protocol parser break; case 1: if ((newByte=='T') || (newByte=='t')) readstate++; else readstate=0; break; case 2: if ((newByte=='\r') || (newByte=='\n')) // AT reply: "OK" { Serial.println("OK"); readstate=0; } else if (newByte==' ') { cmdlen=0; readstate++; } else goto err; break; case 3: if ((newByte=='\r') || (newByte=='\n') || (cmdlen>=MAX_CMDLEN-1)) { tmpstring[cmdlen]=0; parseCommand(tmpstring); readstate=0; } else tmpstring[cmdlen++]=newByte; break; default: err: Serial.println("?");readstate=0; } } }
// Checked: 2009-12-27 (RLVa-1.1.0k) | Modified: RLVa-1.1.0k RlvCommand::RlvCommand(const LLUUID& idObj, const std::string& strCommand) : m_idObj(idObj), m_eBehaviour(RLV_BHVR_UNKNOWN), m_fStrict(false), m_eParamType(RLV_TYPE_UNKNOWN) { if ((m_fValid = parseCommand(strCommand, m_strBehaviour, m_strOption, m_strParam))) { S32 nTemp = 0; if ( ("n" == m_strParam) || ("add" == m_strParam) ) m_eParamType = RLV_TYPE_ADD; else if ( ("y" == m_strParam) || ("rem" == m_strParam) ) m_eParamType = RLV_TYPE_REMOVE; else if (m_strBehaviour == "clear") // clear is the odd one out so just make it its own type m_eParamType = RLV_TYPE_CLEAR; else if ("force" == m_strParam) m_eParamType = RLV_TYPE_FORCE; else if (LLStringUtil::convertToS32(m_strParam, nTemp)) // Assume it's a reply command if we can convert <param> to an S32 m_eParamType = RLV_TYPE_REPLY; else { m_eParamType = RLV_TYPE_UNKNOWN; m_fValid = false; } } if (!m_fValid) { m_strBehaviour = m_strOption = m_strParam = ""; return; } // HACK: all those @addoutfit* synonyms are rather tedious (and error-prone) to deal with so replace them their @attach* equivalent if ( (RLV_TYPE_FORCE == m_eParamType) && (0 == m_strBehaviour.find("addoutfit")) ) m_strBehaviour.replace(0, 9, "attach"); m_eBehaviour = getBehaviourFromString(m_strBehaviour, &m_fStrict); }
void Client::readClient() { //qDebug()<<"Client::readClient"; QTcpSocket* socket = (QTcpSocket*)sender(); QByteArray buffer=socket->readLine(); QString response=parseCommand(QString(buffer)); socket->write(response.toLatin1()); }
int Programmanalisator::processCommand(QString* Kadr, int LNum) { int Typ=parseCommand(Kadr, LNum); // анализируем кадр if (Typ<0) { return -1; } switch (Typ) { // выдача сигнала по результатам команды case BULK_FORM1 : break; case BULK_FORM2 : emit Kommand(BULK_FORM2, Q1, Q2, Q3, Q4, Q5, Q6, 0); break; case FRES_X : emit Kommand(FRES_X,Q1,0,0,0,0,0,0); break; case FRES_Y : emit Kommand(FRES_Y,Q1,0,0,0,0,0,0); break; case FRES_Z : emit Kommand(FRES_Z,Q1,0,0,0,0,0,0); break; case FRES_IX : emit Kommand(FRES_IX,Q1,0,0,0,0,0,0); break; case FRES_IY : emit Kommand(FRES_IY,Q1,0,0,0,0,0,0); break; case FRES_IZ : emit Kommand(FRES_IZ,Q1,0,0,0,0,0,0); break; case TOOL_CALL : emit Kommand(TOOL_CALL,0,0,0,0,0,0,I1); break; case LBL_CALL : return I1; break; default : break; } return 0; }
void prvCommsTask(void *pvParameters) { pvParameters = pvParameters; static uint8_t line[80]; static uint8_t characterPosition = 0; initGlobals(); /* Timer to cause outgoing communications to cease if nothing received for 10 seconds */ lapseCommsTimer = xTimerCreate("Lapse Comms",10000,pdFALSE,0,lapseCommsCallback); while(1) { /* Build a command line string before actioning. The task will block indefinitely waiting for input. */ char character; xQueueReceive(commsReceiveQueue,&character,portMAX_DELAY); if ((character == 0x0D) || (character == 0x0A) || (characterPosition > 78)) { if (lapseCommsTimer != NULL) xTimerReset(lapseCommsTimer,0); line[characterPosition] = 0; characterPosition = 0; parseCommand(line); } else line[characterPosition++] = character; } }
void parseByte (int newByte) // parse an incoming commandbyte from serial interface, perform command if valid { static uint8_t state=0; static uint8_t cmdlen=0; switch (state) { case 0: if ((newByte=='A') || (newByte=='a')) state++; break; case 1: if ((newByte=='T') || (newByte=='t')) state++; else state=0; break; case 2: if ((newByte==13) || (newByte==10)) { Serial.println("OK"); state=0; } else if (newByte==' ') { cmdlen=0; state++; } else goto err; break; case 3: if ((newByte==13) || (newByte==10) || (cmdlen>=MAX_CMDLEN-1)) { cmdstring[cmdlen]=0; parseCommand(cmdstring); state=0; } else cmdstring[cmdlen++]=newByte; break; default: err: Serial.println("?");state=0; } }
void ArgumentParser::parse(const QStringList& args) { ArgumentScanner scanner; scanner.scan(args); const auto tokens = scanner.tokens(); int i = 0; do { if (int tokensConsumed = parseCommand(tokens, i)) { i += tokensConsumed; continue; } if (int tokensConsumed = parseLongOption(tokens, i)) { i += tokensConsumed; continue; } if (int tokensConsumed = parseShortOption(tokens, i)) { i += tokensConsumed; continue; } i += parseOther(tokens, i); } while (i < tokens.size()); }
byte parser( char *message, byte length, bytecode_t *bytecode) { byte errorCode = 0; byte position = 0; skipWhitespace(message, length, & position); command_t *command; errorCode = parseCommand(message, length, & position, & command); if (errorCode == 0) { skipWhitespace(message, length, & position); errorCode = (command->parser)(message, length, & position, command, bytecode); if (errorCode == 0) { skipWhitespace(message, length, & position); } } return(errorCode); }
void SpellManager::invokeSpell(const TextCommand *const spell, const Being *const target) { if (!chatWindow || !spell || !target) return; chatWindow->localChatInput(parseCommand(spell->getCommand(), target)); }
static boolean parseVimLine (const unsigned char *line) { boolean readNextLine = TRUE; if ( (!strncmp ((const char*) line, "comp", (size_t) 4) == 0) && (!strncmp ((const char*) line, "comc", (size_t) 4) == 0) && (strncmp ((const char*) line, "com", (size_t) 3) == 0) ) { readNextLine = parseCommand(line); /* TODO - Handle parseCommand returning FALSE */ } if (isMap(line)) { parseMap(line); } if (strncmp ((const char*) line, "fu", (size_t) 2) == 0) { parseFunction(line); } if (strncmp ((const char*) line, "aug", (size_t) 3) == 0) { parseAutogroup(line); } if ( strncmp ((const char*) line, "let", (size_t) 3) == 0 ) { parseLet(line); } return readNextLine; }
void SpellManager::invokeCommand(const std::string &command, const Being *const target) { if (!chatWindow) return; chatWindow->localChatInput(parseCommand(command, target)); }
int main(int argc, char** argv) { aLog::init("c:\\file.log",aLog::MT_DEBUG); printf("dwd1\n"); if(argc <=1) { showError("", invalid_usage); return 1; } printf("dwd\n"); QStringList args; fillArgsFromArgv(&args, argv, argc); QString command = parseCommand(&args); if(!isValidCommand(command)) { showError(command, invalid_command); return 1; } QString argument = parseArgument(&args); if(!isValidArgument(argument)) { showError(argument, invalid_argument); return 2; } QStringList options; parseOptions(&args, &options); removeInvalidOptions(&options); int res = doAction(command, argument, &options); aLog::close(); return res; }
static boolean parseVimLine (const unsigned char *line, int infunction) { boolean readNextLine = TRUE; if (wordMatchLen (line, "command", 3)) { readNextLine = parseCommand(line); /* TODO - Handle parseCommand returning FALSE */ } else if (isMap(line)) { parseMap(skipWord(line)); } else if (wordMatchLen (line, "function", 2)) { parseFunction(skipWord(line)); } else if (wordMatchLen (line, "augroup", 3)) { parseAutogroup(skipWord(line)); } else if (wordMatchLen (line, "let", 3)) { parseLet(skipWord(line), infunction); } return readNextLine; }
tCommandWithOperands parseCommandText(tLine command_text, tDatabase label_values) { char cmd_name[MAX_COMMAND_LENGTH]; sscanf(command_text.str, "%s", cmd_name); tCommand cmd = parseCommand(cmd_name); tCommandWithOperands command_with_operands = {cmd, {0, 0}, {0, 0}}; int operands_number = getOperandsNumberForCommandType(cmd.type); if (operands_number == 0) return command_with_operands; else if (operands_number == 1) { char operand_name[MAX_OPERAND_LEXEM_LENGTH]; sscanf(command_text.str, "%s %s", cmd_name, operand_name); tOperand op = parseLabelOperand(operand_name, label_values); command_with_operands.left = op; } else if (operands_number == 2) { char operand1_name[MAX_OPERAND_LEXEM_LENGTH], operand2_name[MAX_OPERAND_LEXEM_LENGTH]; *strchr(command_text.str, ',') = ' '; //FIXME: HARDCORE in source code... sscanf(command_text.str, "%s %s %s", cmd_name, operand1_name, operand2_name); tOperand op1 = parseLabelOperand(operand1_name, label_values); command_with_operands.left = op1; tOperand op2 = parseLabelOperand(operand2_name, label_values); command_with_operands.right = op2; } else //exception { printf("Wrong number of operands!!!\n"); exit(-1); } return command_with_operands; }
/** * printInfo: * @pid: process id of the process whose information is to be printed * * The function prints the information available fot a certain process. The * information includes name, pid, status, virtual memory size, and executable * path (only for the shell) */ void printInfo(int pid) { char statFile[DIRECTORY_LEN_MAX]; char statInfo[INFO_LEN_MAX]; char **info = NULL; sprintf(statFile, "/proc/%d/stat", pid != -1 ? pid: getpid()); FILE *fp = fopen(statFile, "r"); if (!fp) { perror("fopen() error"); return; } fgets(statInfo, INFO_LEN_MAX, fp); info = parseCommand(statInfo, " "); printf("Process ID\t--\t%s\n" "Process Name\t--\t%s\n" "Process Status\t--\t%s\n" "Virtual Memory Size\t--\t%s\n", info[0], info[1], info[2], info[22]); if (pid == -1) printf("Executable Path\t--\t%s\n", EXECPATH); stringListFree(info); }
void browsers::layerbrowser::OnActiveLayerM(wxCommandEvent&) { word layno = getFirstSelected(); wxString cmd; cmd << wxT("usinglayer(") << layno << wxT(");"); parseCommand(cmd); }
int main(void) { clock_setup(); gpio_setup(); usart_setup(); spi_setup(); buffer_init(send_buffer,BUFFER_SIZE); buffer_init(receive_buffer,BUFFER_SIZE); usart_enable_tx_interrupt(USART1); /* Send a greeting message on USART1. */ usart_print_string("SD Card SPI Mode Test\r\n"); while (1) { /* Command interface */ if (buffer_input_available(receive_buffer)) { char character = buffer_get(receive_buffer); if (character == 0x0D) { line[characterPosition] = 0; characterPosition = 0; parseCommand(line); } else line[characterPosition++] = character; } } return 0; }
void Player_AD::musicSeekTo(const uint position) { // This method is actually dangerous to use and should only be used for // loading save games because it does not set up anything like the engine // music timer or similar. _isSeeking = true; // Seek until the given position. while (_curOffset != position) { if (parseCommand()) { // We encountered an EOT command. This should not happen unless // we try to seek to an illegal position. In this case just abort // seeking. ::debugC(3, DEBUG_SOUND, "AD illegal seek to %u", position); break; } parseVLQ(); } _isSeeking = false; // Turn on all notes. for (int i = 0; i < ARRAYSIZE(_voiceChannels); ++i) { if (_voiceChannels[i].lastEvent != 0) { const int reg = 0xB0 + i; writeReg(reg, readReg(reg)); } } }
void ConnectionParser::dataReceived() { while (mSocket->canReadLine()) { QString line = mSocket->readLine(); QStringList parsedArray = splitRawLine(line, true); QString coreCommand = parsedArray.at(0); qDebug() << parsedArray; if (coreCommand == "PING") { mInternalSender->sendPong(parsedArray.at(1)); } else if (coreCommand == "ERROR") { return; } else { QString command = parsedArray.at(1); bool numeric; int code = command.toInt(&numeric); if (numeric) { if (parseCode(parsedArray, code)) { QObject::disconnect(mSocket, &QTcpSocket::readyRead, this, &ConnectionParser::dataReceived); return; } } else { parseCommand(parsedArray, command); } } } }