void ExpressionParser::_ParseCommand(debugger_command_pipe_segment& segment) { fTokenizer.SetCommandMode(false); const Token& token = _EatToken(TOKEN_IDENTIFIER); fTokenizer.SetCommandMode(true); bool ambiguous; debugger_command* command = find_debugger_command(token.string, true, ambiguous); if (command == NULL) { if (ambiguous) { snprintf(sTempBuffer, sizeof(sTempBuffer), "Ambiguous command \"%s\". Use tab completion or enter " "\"help %s\" get a list of matching commands.\n", token.string, token.string); } else { snprintf(sTempBuffer, sizeof(sTempBuffer), "Unknown command \"%s\". Enter \"help\" to get a list of " "all supported commands.\n", token.string); } parse_exception(sTempBuffer, -1); } // allocate temporary buffer for the argument vector char** argv = (char**)checked_malloc(kMaxArgumentCount * sizeof(char*)); int argc = 0; argv[argc++] = (char*)command->name; // get the arguments if ((command->flags & B_KDEBUG_DONT_PARSE_ARGUMENTS) != 0) { _GetUnparsedArgument(argc, argv); } else { while (fTokenizer.NextToken().type != TOKEN_END_OF_LINE) { fTokenizer.RewindToken(); if (!_ParseArgument(argc, argv)) break; } } if (segment.index > 0) { if (argc >= kMaxArgumentCount) parse_exception("too many arguments for command", 0); else argc++; } segment.command = command; segment.argc = argc; segment.argv = argv; segment.invocations = 0; }
bool ExpressionParser::_ParseArgument(int& argc, char** argv) { const Token& token = fTokenizer.NextToken(); switch (token.type) { case TOKEN_OPENING_PARENTHESIS: { // this starts an expression fTokenizer.SetCommandMode(false); uint64 value = _ParseExpression(); fTokenizer.SetCommandMode(true); _EatToken(TOKEN_CLOSING_PARENTHESIS); snprintf(sTempBuffer, sizeof(sTempBuffer), "%" B_PRIu64, value); _AddArgument(argc, argv, sTempBuffer); return true; } case TOKEN_OPENING_BRACKET: { // this starts a sub command int returnValue; uint64 value = _ParseCommandPipe(returnValue); _EatToken(TOKEN_CLOSING_BRACKET); snprintf(sTempBuffer, sizeof(sTempBuffer), "%" B_PRIu64, value); _AddArgument(argc, argv, sTempBuffer); return true; } case TOKEN_STRING: case TOKEN_UNKNOWN: _AddArgument(argc, argv, token.string); return true; case TOKEN_CLOSING_PARENTHESIS: case TOKEN_CLOSING_BRACKET: case TOKEN_PIPE: case TOKEN_SEMICOLON: // those don't belong to us fTokenizer.RewindToken(); return false; default: { snprintf(sTempBuffer, sizeof(sTempBuffer), "unexpected token " "\"%s\"", token.string); parse_exception(sTempBuffer, token.position); return false; } } }
uint64 ExpressionParser::EvaluateCommand(const char* expressionString, int& returnCode) { fTokenizer.SetTo(expressionString); // Allowed are command or assignment. A command always starts with an // identifier, an assignment either with an identifier (variable name) or // a dereferenced address. const Token& token = fTokenizer.NextToken(); uint64 value = 0; while (true) { int32 startPosition = token.position; if (token.type == TOKEN_IDENTIFIER) { fTokenizer.NextToken(); if (token.type & TOKEN_ASSIGN_FLAG) { // an assignment fTokenizer.SetPosition(startPosition); value = _ParseExpression(true); returnCode = 0; } else { // no assignment, so let's assume it's a command fTokenizer.SetPosition(startPosition); fTokenizer.SetCommandMode(true); value = _ParseCommandPipe(returnCode); } } else if (token.type == TOKEN_STAR) { // dereferenced address -- assignment fTokenizer.SetPosition(startPosition); value = _ParseExpression(true); returnCode = 0; } else parse_exception("expected command or assignment", token.position); // might be chained with ";" if (fTokenizer.NextToken().type != TOKEN_SEMICOLON) break; fTokenizer.SetCommandMode(false); fTokenizer.NextToken(); } if (token.type != TOKEN_END_OF_LINE) parse_exception("parse error", token.position); return value; }
status_t ExpressionParser::ParseNextCommandArgument(const char** expressionString, char* buffer, size_t bufferSize) { fTokenizer.SetTo(*expressionString); fTokenizer.SetCommandMode(true); if (fTokenizer.NextToken().type == TOKEN_END_OF_LINE) return B_ENTRY_NOT_FOUND; fTokenizer.RewindToken(); char* argv[2]; int argc = 0; if (!_ParseArgument(argc, argv)) return B_BAD_VALUE; strlcpy(buffer, argv[0], bufferSize); const Token& token = fTokenizer.NextToken(); if (token.type == TOKEN_END_OF_LINE) *expressionString = NULL; else *expressionString += token.position; return B_OK; }
uint64 ExpressionParser::_ParseAtom() { const Token& token = fTokenizer.NextToken(); if (token.type == TOKEN_END_OF_LINE) parse_exception("unexpected end of expression", token.position); if (token.type == TOKEN_CONSTANT) return token.value; if (token.type == TOKEN_IDENTIFIER) { if (!is_debug_variable_defined(token.string)) { snprintf(sTempBuffer, sizeof(sTempBuffer), "variable '%s' undefined", token.string); parse_exception(sTempBuffer, token.position); } return get_debug_variable(token.string, 0); } if (token.type == TOKEN_OPENING_PARENTHESIS) { uint64 value = _ParseExpression(); _EatToken(TOKEN_CLOSING_PARENTHESIS); return value; } // it can only be a "[ command ]" expression now fTokenizer.RewindToken(); _EatToken(TOKEN_OPENING_BRACKET); fTokenizer.SetCommandMode(true); int returnValue; uint64 value = _ParseCommandPipe(returnValue); fTokenizer.SetCommandMode(false); _EatToken(TOKEN_CLOSING_BRACKET); return value; }