static bool isCommand(const QString &str, const CommandIdType cmd) { switch (cmd) { case CommandIdType::NORTH: case CommandIdType::SOUTH: case CommandIdType::EAST: case CommandIdType::WEST: case CommandIdType::UP: case CommandIdType::DOWN: case CommandIdType::FLEE: return isCommand(str, Abbrev{getLowercase(cmd), 1}); case CommandIdType::SCOUT: return isCommand(str, Abbrev{getLowercase(cmd), 2}); case CommandIdType::LOOK: return isCommand(str, Abbrev{getLowercase(cmd), 1}) || isCommand(str, Abbrev{"examine", 3}); case CommandIdType::UNKNOWN: case CommandIdType::NONE: return false; } return false; }
unsigned int parseInput(struct directory* cluster, unsigned char* buffer, unsigned int FDS, unsigned int SPC, unsigned int RSC, unsigned int BPS, char* PWD, char* command) { char* args = (char*)calloc(sizeof(char),64); int return_val; getc(stdin); //ignore space fgets(args,64,stdin); removeTrailingNewline(args); return_val = isCommand(cluster,buffer,FDS,SPC,RSC,BPS,command,args); if(return_val){ switch(return_val){ case 2:{ presentWorkingDirectory(ADD,args); break;} case 3:{ presentWorkingDirectory(SUB,""); break;} } }else{ printf("%s is not a valid command\n",command); } return currentClusterNumber(GET,0); }
int getop(char s []) { int c, res; while ((s[0] = c = getch()) == ' ' || c == '\t'); s[1] = '\0'; if (isCommand(s)) return COMMAND; res = isNumber(s); if (res) return res; if (isAssigner(s)) return ASSIGNER; if (isVariable(s)) return VARIABLE; if (isOperator(s)) return OPERATOR; res = isFunction(s); if (res) return res; if (s[0] == '\n') return '\n'; if (c == EOF) return EOF; return ERROR; }
QString CronSegment::toString() const { QString str; if (isCommand()) return command; for(int i=0; i<singles.size(); i++) { str.append(QVariant(singles[i]).toString()); if (i < singles.size()-1) str.append(','); } if (not time_spans.isEmpty()) str.append(','); for(int i=0; i<time_spans.size(); i++) { str.append(time_spans[i].toString()); if (i < time_spans.size()-1) str.append(','); } if (glob) { if (not str.isEmpty()) str.append(','); str.append('*'); } if (repeater != 0) str.append(QString("/%1").arg(repeater)); return str; }
uint8_t respondToIbusRequest(uint8_t const * const ibusPacket) { ibusAddress_t returnAddress = getAddress(ibusPacket); autodetectFirstReceivedAddressAsBaseAddress(returnAddress); if (theAddressIsWithinOurRange(returnAddress)) { if (isCommand(IBUS_COMMAND_DISCOVER_SENSOR, ibusPacket)) { return sendIbusDiscoverSensorReply(returnAddress); } else if (isCommand(IBUS_COMMAND_SENSOR_TYPE, ibusPacket)) { return sendIbusSensorType(returnAddress); } else if (isCommand(IBUS_COMMAND_MEASUREMENT, ibusPacket)) { return dispatchMeasurementReply(returnAddress); } } return 0; }
bool ConsoleCommandParser::performParsing(const NetworkId & /* track */, const StringVector_t & argv, const String_t &, String_t & result, const CommandParser *) { bool successResult = false; if(isCommand(argv[0], "planet")) { if(argv.size() > 2) { if(isCommand(argv[2], "runState")) { successResult = true; result += Unicode::narrowToWide("running"); } } } return successResult; }
StatusWith<OplogApplier::Operations> OplogApplier::getNextApplierBatch( OperationContext* opCtx, const BatchLimits& batchLimits) { if (batchLimits.ops == 0) { return Status(ErrorCodes::InvalidOptions, "Batch size must be greater than 0."); } std::uint32_t totalBytes = 0; Operations ops; BSONObj op; while (_oplogBuffer->peek(opCtx, &op)) { auto entry = OplogEntry(op); // Check for oplog version change. If it is absent, its value is one. if (entry.getVersion() != OplogEntry::kOplogVersion) { std::string message = str::stream() << "expected oplog version " << OplogEntry::kOplogVersion << " but found version " << entry.getVersion() << " in oplog entry: " << redact(entry.toBSON()); severe() << message; return {ErrorCodes::BadValue, message}; } // Commands must be processed one at a time. The only exception to this is applyOps because // applyOps oplog entries are effectively containers for CRUD operations. Therefore, it is // safe to batch applyOps commands with CRUD operations when reading from the oplog buffer. if (entry.isCommand() && (entry.getCommandType() != OplogEntry::CommandType::kApplyOps || entry.shouldPrepare())) { if (ops.empty()) { // Apply commands one-at-a-time. ops.push_back(std::move(entry)); BSONObj opToPopAndDiscard; invariant(_oplogBuffer->tryPop(opCtx, &opToPopAndDiscard)); dassert(ops.back() == OplogEntry(opToPopAndDiscard)); } // Otherwise, apply what we have so far and come back for the command. return std::move(ops); } // Apply replication batch limits. if (ops.size() >= batchLimits.ops) { return std::move(ops); } // Never return an empty batch if there are operations left. if ((totalBytes + entry.getRawObjSizeBytes() >= batchLimits.bytes) && (ops.size() > 0)) { return std::move(ops); } // Add op to buffer. totalBytes += entry.getRawObjSizeBytes(); ops.push_back(std::move(entry)); BSONObj opToPopAndDiscard; invariant(_oplogBuffer->tryPop(opCtx, &opToPopAndDiscard)); dassert(ops.back() == OplogEntry(opToPopAndDiscard)); } return std::move(ops); }
AutoGetCollectionForRead::~AutoGetCollectionForRead() { // Report time spent in read lock auto currentOp = CurOp::get(_txn); Top::get(_txn->getClient()->getServiceContext()) .record(currentOp->getNS(), currentOp->getOp(), -1, // "read locked" _timer.micros(), currentOp->isCommand()); }
OplogEntry::OplogEntry(BSONObj rawInput) : raw(std::move(rawInput)) { raw = raw.getOwned(); parseProtected(IDLParserErrorContext("OplogEntryBase"), raw); // Parse command type from 'o' and 'o2' fields. if (isCommand()) { _commandType = parseCommandType(getObject()); } }
void Request::process( int attempt ) { init(); int op = _m.operation(); assert( op > dbMsg ); if ( op == dbKillCursors ) { cursorCache.gotKillCursors( _m ); return; } log(3) << "Request::process ns: " << getns() << " msg id:" << (int)(_m.header()->id) << " attempt: " << attempt << endl; Strategy * s = SINGLE; _counter = &opsNonSharded; _d.markSet(); if ( _chunkManager ) { s = SHARDED; _counter = &opsSharded; } bool iscmd = false; if ( op == dbQuery ) { iscmd = isCommand(); try { s->queryOp( *this ); } catch ( StaleConfigException& staleConfig ) { log() << staleConfig.what() << " attempt: " << attempt << endl; uassert( 10195 , "too many attempts to update config, failing" , attempt < 5 ); ShardConnection::checkMyConnectionVersions( getns() ); if (!staleConfig.justConnection() ) sleepsecs( attempt ); reset( ! staleConfig.justConnection() ); _d.markReset(); process( attempt + 1 ); return; } } else if ( op == dbGetMore ) { s->getMore( *this ); } else { char cl[256]; nsToDatabase(getns(), cl); uassert(15845, "unauthorized", _clientInfo->getAuthenticationInfo()->isAuthorized(cl)); s->writeOp( op, *this ); } globalOpCounters.gotOp( op , iscmd ); _counter->gotOp( op , iscmd ); }
AutoStatsTracker::~AutoStatsTracker() { auto curOp = CurOp::get(_opCtx); Top::get(_opCtx->getServiceContext()) .record(_opCtx, curOp->getNS(), curOp->getLogicalOp(), _lockType, durationCount<Microseconds>(curOp->elapsedTimeExcludingPauses()), curOp->isCommand(), curOp->getReadWriteType()); }
void adjustSizes(char** argv, int argc, size_t& commandsSize, size_t& filesSizes) { for (int word = 1; word < argc; ++word) { if (isPath(argv[word])) filesSizes++; else if (isCommand(argv[word])) commandsSize++; } }
ChatCommandContext::ChatCommandContext(const tstring& s) { dcassert(isCommand(s)); const string::size_type i = s.find(' '); if (i != string::npos) { param = s.substr(i + 1); command = s.substr(1, i - 1); } else { command = s.substr(1); } }
SCgObject* SCgMainWindow::resolveUri(const ScUri &uri) { // trying to find scg-object with uri const SCgObject::SCgObjectList& list = SCgObject::objectsByScUri(uri); //! TODO: resolve situation with multiply if (!list.empty()) return list.front(); UiRootInterface *root = SCgPlugin::rootInterface(); ScMemoryInterface *memory = root->scMemory(); SCgObject *res = 0; // get element type and create scg-object ScElementType type = memory->get_el_type(uri); // create new scg-object if (type.check(ScNode)) { // check if it a command if (isCommand(uri)) { SCgControl *control = mScene->construction()->createControl(); res = control; }else { SCgNode *node = mScene->construction()->createNode(); res = node; } }else if (type.check(ScArcMask)) { }else if (type.check(ScLink)) { } // setup identifier QString idtf_value = root->scHelper()->stringIdtf(uri, root->currentLanguage()); if (!idtf_value.isEmpty()) res->setIdentifier(idtf_value); if (res != 0) { res->setUri(uri); res->setObjectType(type); } return res; }
int processMgmt(Array command){ pid_t process = fork(); if (process<0){ return (int)process; } else if (process==0){ if (command.c[0].str[0]!='/'){ //Relative path char *pathList = getenv("PATH"); char *path = strtok(pathList,":"); char *temp; do{ temp = malloc(sizeof(char)*(command.c[0].length+strlen(path))); temp = strcpy(temp,path); strcat(temp,"/"); strcat(temp,command.c[0].str); } while (!isCommand(temp) && (path=strtok(NULL,":"))!=NULL ); if (path!=NULL){ command.c[0].str = temp; } } int argc=command.length+1; if (isBooleanOperator(command.c[command.length-1].str)){ argc--; } { char *args[argc]; int i; for (i=0;i<argc-1;i++){ args[i]=command.c[i].str; } args[i]=0; int status = execve(command.c[0].str,args,environ); } write(0,command.c[0].str,command.c[0].length); write(0,": command not found\n",20); exit(-1); } else if (process>0){ int status; waitpid(process,&status,0); return status; } return -1; }
bool ConsoleCommandParser::performParsing(const NetworkId &, const StringVector_t & argv, const String_t &, String_t & result, const CommandParser *) { bool successResult = false; if(isCommand(argv[0], "runState")) { result += Unicode::narrowToWide("running"); successResult = true; } return successResult; }
OldClientContext::~OldClientContext() { // Lock must still be held invariant(_txn->lockState()->isLocked()); auto currentOp = CurOp::get(_txn); Top::get(_txn->getClient()->getServiceContext()) .record(currentOp->getNS(), currentOp->getOp(), _txn->lockState()->isWriteLocked() ? 1 : -1, _timer.micros(), currentOp->isCommand()); }
int noArgCommand(token **ptr, const char *com) { token *now = *ptr; if (!now || !isCommand(now, com)) { return 0; } now = now->next; if (!now || now->type != CRLF) { return 0; } *ptr = now; return 1; }
// // function that disgtinguish commands from files // save the commands in char** commands array // save the file and their paths in char** pathsToFiles array // void ConsoleInput::distinguishConsoleInput(int argc, char* argv[]) { int counterCommands = 0; int counterFiles = 0; for (int i = 1; i < argc; i++) { if (isCommand(argv[i])) { counterCommands++; } else { counterFiles++; } } this->numberFiles = counterFiles; this->numberCommands = counterCommands; this->commands = new char*[this->numberCommands]; this->pathsToFiles = new char*[this->numberFiles]; int indexCommands = 0; int indexFiles = 0; for (int i = 1; i < argc; i++) { size_t buffSize = strlen(argv[i]) + 1; if (isCommand(argv[i])) { buffSize -= 2; this->commands[indexCommands] = new char[buffSize]; strcpy_s(this->commands[indexCommands], buffSize, argv[i] + 2); indexCommands++; } else { this->pathsToFiles[indexFiles] = new char[buffSize]; strcpy_s(this->pathsToFiles[indexFiles], buffSize, argv[i]); indexFiles++; } } reOrderHtmlCommand(); }
/* returns number of bytes consumed */ int QtTelnetPrivate::parseIAC(const QByteArray &data) { if (data.isEmpty()) return 0; Q_ASSERT(uchar(data.at(0)) == Common::IAC); if (data.size() >= 3 && isOperation(data[1])) { // IAC, Operation, Option const uchar operation = data[1]; const uchar option = data[2]; if (operation == Common::WONT && option == Common::Logout) { q->close(); return 3; } if (operation == Common::DONT && option == Common::Authentication) { if (loginp.isEmpty() && passp.isEmpty()) emit q->loggedIn(); nullauth = true; } if (replyNeeded(operation, option)) { bool allowed = allowOption(operation, option); sendCommand(opposite(operation, allowed), option); setMode(operation, option); } return 3; } if (data.size() >= 2 && isCommand(data[1])) { // IAC Command return 2; } QByteArray suboption = getSubOption(data); if (suboption.isEmpty()) return 0; // IAC SB Operation SubOption [...] IAC SE switch (suboption[0]) { case Common::Authentication: parseSubAuth(suboption); break; case Common::TerminalType: parseSubTT(suboption); break; case Common::NAWS: parseSubNAWS(data); break; default: qWarning("QtTelnetPrivate::parseIAC: unknown suboption %d", quint8(suboption.at(0))); break; } return suboption.size() + 4; }
int getop(char s []) { int i, c; int nextChar; while ((s[0] = c = getch()) == ' ' || c == '\t'); s[1] = '\0'; if (isNumber(s)) return NUMBER; if (isCommand(s)) return COMMAND; return c; }
void recordStatsForTopCommand(OperationContext* txn) { auto curOp = CurOp::get(txn); const int writeLocked = 1; Top::get(txn->getClient()->getServiceContext()) .record(txn, curOp->getNS(), curOp->getLogicalOp(), writeLocked, curOp->elapsedMicros(), curOp->isCommand(), curOp->getReadWriteType()); }
/** * Attempts to interpret a 'command'. These appear in the file as * $$[command-name] [options] * * Returns true on success, false on error, and puts resulting elements * into the 'target' buffer. * * If the commands are instructions to the interpreter, these are processed * frmo this function as well. */ bool MathInterpreter::interpretCommand (MDEVector &target, const std::string &src, size_t &i) { // We should only be attempting this if this is the very start of a line of // text. assert (m_isStartOfLine == true); if (src.substr(i, 2) != "$$") return false; i += 2; std::string commandName, commandParameters; // Handle $$+EnableMoreFeatures and $$-EnableMoreFeatures. Include a // trailing space in case more parameters show up below if (src [i] == '+') { commandParameters = "true "; i++; } else if (src [i] == '-') { commandParameters = "false "; i++; } // Grab the command name while (i < src.length() && isalpha(src [i])) { commandName += src[i]; i++; } // Grab the parameters, if there are any, to EOL. If there is already // a parameter there, add a space after it. while (i < src.length()) { commandParameters += src[i]; i++; } boost::trim(commandParameters); if (!isCommand(commandName)) { LOG_TRACE << "* found unrecognized command: " << commandName << " // " << commandParameters; MSG_ERROR(UNKNOWN_COMMAND, boost::str(boost::format("'%s'") % commandName)); BOOST_THROW_EXCEPTION (MathInterpreterException()); } LOG_TRACE << "* found command: " << commandName << " // " << commandParameters; MathDocumentElementPtr e = boost::make_shared<MDE_Command>(commandName, commandParameters); target.push_back (e); return true; }
void Request::process( int attempt ) { init(); int op = _m.operation(); verify( op > dbMsg ); if ( op == dbKillCursors ) { cursorCache.gotKillCursors( _m ); return; } int msgId = (int)(_m.header()->id); Timer t; LOG(3) << "Request::process begin ns: " << getns() << " msg id: " << msgId << " op: " << op << " attempt: " << attempt << endl; Strategy * s = SHARDED; _counter = &opsNonSharded; _d.markSet(); bool iscmd = false; if ( op == dbQuery ) { iscmd = isCommand(); if (iscmd) { SINGLE->queryOp(*this); } else { s->queryOp( *this ); } } else if ( op == dbGetMore ) { s->getMore( *this ); } else { s->writeOp( op, *this ); } LOG(3) << "Request::process end ns: " << getns() << " msg id: " << msgId << " op: " << op << " attempt: " << attempt << " " << t.millis() << "ms" << endl; globalOpCounters.gotOp( op , iscmd ); _counter->gotOp( op , iscmd ); }
OldClientContext::~OldClientContext() { // Lock must still be held invariant(_opCtx->lockState()->isLocked()); auto currentOp = CurOp::get(_opCtx); Top::get(_opCtx->getClient()->getServiceContext()) .record(_opCtx, currentOp->getNS(), currentOp->getLogicalOp(), _opCtx->lockState()->isWriteLocked() ? Top::LockType::WriteLocked : Top::LockType::ReadLocked, _timer.micros(), currentOp->isCommand(), currentOp->getReadWriteType()); }
void execCommand(char* command) { // Interpret the user command if(isCommand("boot\0", command)) { interrupt(33, 11, 0, 0, 0); } else if(isCommand("cls\0", command)) { interrupt(33, 12, 4, 11, 0); } else if(isCommand("dir\0", command)) { printDir(); } else if(isCommand("copy\0", command)) { copy(command + 5); } else if(isCommand("del\0", command)) { delete(command + 4); } else if(isCommand("echo\0", command)) { echo(command + 5); } else if(isCommand("type\0", command)) { type(command + 5); } else if(isCommand("run\0", command)) { run(command + 4); } else if(isCommand("tweet\0", command)) { tweet(command + 6); } else if(isCommand("help\0", command)) { help(); } else { commandNotRecognized(); } }
void Preprocessor::parse(const char* name, const char* text) { if (std::find(names.begin(), names.end(), name) != names.end()) return; files.push_back(File(name, text)); names.push_back(name); list += format("( file %u: %s )\n", (uint) names.size(), name); output.reserve(output.size() + std::strlen(text)); appendToOutput(format("#line 0 %u /* entering %s */\n", (uint) files.size(), files.back().name).c_str()); while (hasMore()) { if (isMultiLineComment()) parseMultiLineComment(); else if (isSingleLineComment()) parseSingleLineComment(); else if (isNewLine()) parseNewLine(); else if (isWhitespace()) parseWhitespace(); else if (isCommand()) parseCommand(); else { advance(1); appendToOutput(); setFirstOnLine(false); } } files.pop_back(); if (!files.empty()) { appendToOutput(format("\n#line %u %u /* returning to %s */", files.back().line, (uint) files.size(), files.back().name).c_str()); } }
void Request::process( int attempt ) { init(); int op = _m.operation(); assert( op > dbMsg ); if ( op == dbKillCursors ) { cursorCache.gotKillCursors( _m ); return; } MONGO_LOG(3) << "Request::process ns: " << getns() << " msg id:" << (int)(_m.header()->id) << " attempt: " << attempt << endl; Strategy * s = SHARDED; _counter = &opsNonSharded; _d.markSet(); bool iscmd = false; if ( op == dbQuery ) { try { iscmd = isCommand(); s->queryOp( *this ); } catch ( RecvStaleConfigException& stale ) { _d.markReset(); log( attempt == 0 ) << "got RecvStaleConfigException at top level: " << stale.toString() << " attempt: " << attempt << endl; massert( 16062 , "too many attemps to handle RecvStaleConfigException at top level" , attempt <= 5 ); process( attempt + 1 ); return; } } else if ( op == dbGetMore ) { checkAuth( Auth::READ ); // this is important so someone can't steal a cursor s->getMore( *this ); } else { checkAuth( Auth::WRITE ); s->writeOp( op, *this ); } globalOpCounters.gotOp( op , iscmd ); _counter->gotOp( op , iscmd ); }
int main (int argc, char * argv[]) { loadCommands(); /* option parsing */ int c = 0; int option_index = 0; while ((c = getopt_long(argc, argv, "cf", long_options, &option_index)) != -1) { switch (c) { case 0: /* longopt detected */ break; case 'c': /* short option, color enabled */ COLOR_FLAG = 1; break; case 'f': FORCE_FLAG = 1; break; default: fprintf(stdout, "Unknown option code %d\n", c); printUsage(); return EXIT_FAILURE; } } /* argument loop */ if(optind < argc && argv[optind] && isCommand(argv[optind])){ //then we want to process the command if (!processCommand(argv, optind)){ if (COLOR_FLAG) fprintf_red(stdout, "Your command was not processed.\n"); else printf("Your command was not processed.\n"); } }else{ printUsage(); } return 0; }
int oneStrArgCommand(token **ptr, const char *com) { token *now = *ptr; if (!now || !isCommand(now, com)) { return 0; } now = now->next; if (!now || now->type != SPACE) { return 0; } now = now->next; if (!now || !strings(now)) { return 0; } if (!now || now->type != CRLF) { return 0; } now = now->next; *ptr = now; return 1; }