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::_ParseCommandPipe(int& returnCode)
{
debugger_command_pipe* pipe = (debugger_command_pipe*)checked_malloc(
sizeof(debugger_command_pipe));
pipe->segment_count = 0;
pipe->broken = false;
do {
if (pipe->segment_count >= MAX_DEBUGGER_COMMAND_PIPE_LENGTH)
parse_exception("Pipe too long", fTokenizer.NextToken().position);
debugger_command_pipe_segment& segment
= pipe->segments[pipe->segment_count];
segment.index = pipe->segment_count++;
_ParseCommand(segment);
} while (fTokenizer.NextToken().type == TOKEN_PIPE);
fTokenizer.RewindToken();
// invoke the pipe
returnCode = invoke_debugger_command_pipe(pipe);
debug_free(pipe);
return get_debug_variable("_", 0);
}
void
ExpressionParser::_GetUnparsedArgument(int& argc, char** argv)
{
int32 startPosition = fTokenizer.NextToken().position;
fTokenizer.RewindToken();
// match parentheses and brackets, but otherwise skip all tokens
int32 parentheses = 0;
int32 brackets = 0;
bool done = false;
while (!done) {
const Token& token = fTokenizer.NextToken();
switch (token.type) {
case TOKEN_OPENING_PARENTHESIS:
parentheses++;
break;
case TOKEN_OPENING_BRACKET:
brackets++;
break;
case TOKEN_CLOSING_PARENTHESIS:
if (parentheses > 0)
parentheses--;
else
done = true;
break;
case TOKEN_CLOSING_BRACKET:
if (brackets > 0)
brackets--;
else
done = true;
break;
case TOKEN_PIPE:
case TOKEN_SEMICOLON:
if (parentheses == 0 && brackets == 0)
done = true;
break;
case TOKEN_END_OF_LINE:
done = true;
break;
}
}
int32 endPosition = fTokenizer.CurrentToken().position;
fTokenizer.RewindToken();
// add the argument only, if it's not just all spaces
const char* arg = fTokenizer.String() + startPosition;
int32 argLen = endPosition - startPosition;
bool allSpaces = true;
for (int32 i = 0; allSpaces && i < argLen; i++)
allSpaces = isspace(arg[i]);
if (!allSpaces)
_AddArgument(argc, argv, arg, argLen);
}
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;
}
uint64
ExpressionParser::_ParseProduct()
{
uint64 value = _ParseUnary();
while (true) {
Token token = fTokenizer.NextToken();
switch (token.type) {
case TOKEN_STAR:
value = value * _ParseUnary();
break;
case TOKEN_SLASH: {
uint64 rhs = _ParseUnary();
if (rhs == 0)
parse_exception("division by zero", token.position);
value = value / rhs;
break;
}
case TOKEN_MODULO: {
uint64 rhs = _ParseUnary();
if (rhs == 0)
parse_exception("modulo by zero", token.position);
value = value % rhs;
break;
}
default:
fTokenizer.RewindToken();
return value;
}
}
}
uint64
ExpressionParser::_ParseDereference(void** _address, uint32* _size)
{
int32 starPosition = fTokenizer.CurrentToken().position;
// optional "{ ... }" specifying the size to read
uint64 size = 4;
if (fTokenizer.NextToken().type == TOKEN_OPENING_BRACE) {
int32 position = fTokenizer.CurrentToken().position;
size = _ParseExpression();
if (size != 1 && size != 2 && size != 4 && size != 8) {
snprintf(sTempBuffer, sizeof(sTempBuffer),
"invalid size (%" B_PRIu64 ") for unary * operator", size);
parse_exception(sTempBuffer, position);
}
_EatToken(TOKEN_CLOSING_BRACE);
} else
fTokenizer.RewindToken();
const void* address = (const void*)(addr_t)_ParseUnary();
// read bytes from address into a tempory buffer
uint64 buffer;
if (debug_memcpy(B_CURRENT_TEAM, &buffer, address, size) != B_OK) {
snprintf(sTempBuffer, sizeof(sTempBuffer),
"failed to dereference address %p", address);
parse_exception(sTempBuffer, starPosition);
}
// convert the value to uint64
uint64 value = 0;
switch (size) {
case 1:
value = *(uint8*)&buffer;
break;
case 2:
value = *(uint16*)&buffer;
break;
case 4:
value = *(uint32*)&buffer;
break;
case 8:
value = buffer;
break;
}
if (_address != NULL)
*_address = (void*)address;
if (_size != NULL)
*_size = size;
return value;
}
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;
}
uint64
ExpressionParser::EvaluateExpression(const char* expressionString)
{
fTokenizer.SetTo(expressionString);
uint64 value = _ParseExpression();
const Token& token = fTokenizer.NextToken();
if (token.type != TOKEN_END_OF_LINE)
parse_exception("parse error", token.position);
return value;
}
const Token&
ExpressionParser::_EatToken(int32 type)
{
const Token& token = fTokenizer.NextToken();
if (token.type != type) {
snprintf(sTempBuffer, sizeof(sTempBuffer), "expected token type '%c', "
"got token '%s'", char(type & ~TOKEN_FLAGS), token.string);
parse_exception(sTempBuffer, token.position);
}
return token;
}
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;
}
}
}
bool CVarManager::LoadFromFile(STRING filename)
{
Tokenizer t;
if(!t.LoadFromFile(filename))
return false;
STRING key, value, eq;
while(!t.EndOfFile())
{
key = t.NextToken();
eq = t.NextToken();
if(eq != "=")
{
LOG_WARNING2("CVar file syntax error in line %d.", t.CrtLine());
}
value = t.NextToken();
CVar cvar(key, EMPTY_STRING, NULL);
cvar.SetValue(value);
m_cvars[key] = cvar;
}
return true;
}
uint64
ExpressionParser::_ParseUnary()
{
switch (fTokenizer.NextToken().type) {
case TOKEN_MINUS:
return -_ParseUnary();
case TOKEN_STAR:
return _ParseDereference(NULL, NULL);
default:
fTokenizer.RewindToken();
return _ParseAtom();
}
return 0;
}
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;
}
uint64
ExpressionParser::_ParseSum(bool useValue, uint64 value)
{
if (!useValue)
value = _ParseProduct();
while (true) {
const Token& token = fTokenizer.NextToken();
switch (token.type) {
case TOKEN_PLUS:
value = value + _ParseProduct();
break;
case TOKEN_MINUS:
value = value - _ParseProduct();
break;
default:
fTokenizer.RewindToken();
return value;
}
}
}
uint64
ExpressionParser::_ParseExpression(bool expectAssignment)
{
const Token& token = fTokenizer.NextToken();
int32 position = token.position;
if (token.type == TOKEN_IDENTIFIER) {
char variable[MAX_DEBUG_VARIABLE_NAME_LEN];
strlcpy(variable, token.string, sizeof(variable));
int32 assignmentType = fTokenizer.NextToken().type;
if (assignmentType & TOKEN_ASSIGN_FLAG) {
// an assignment
uint64 rhs = _ParseExpression();
// handle the standard assignment separately -- the other kinds
// need the variable to be defined
if (assignmentType == TOKEN_ASSIGN) {
if (!set_debug_variable(variable, rhs)) {
snprintf(sTempBuffer, sizeof(sTempBuffer),
"failed to set value for variable \"%s\"",
variable);
parse_exception(sTempBuffer, position);
}
return rhs;
}
// variable must be defined
if (!is_debug_variable_defined(variable)) {
snprintf(sTempBuffer, sizeof(sTempBuffer),
"variable \"%s\" not defined in modifying assignment",
variable);
parse_exception(sTempBuffer, position);
}
uint64 variableValue = get_debug_variable(variable, 0);
// check for division by zero for the respective assignment types
if ((assignmentType == TOKEN_SLASH_ASSIGN
|| assignmentType == TOKEN_MODULO_ASSIGN)
&& rhs == 0) {
parse_exception("division by zero", position);
}
// compute the new variable value
switch (assignmentType) {
case TOKEN_PLUS_ASSIGN:
variableValue += rhs;
break;
case TOKEN_MINUS_ASSIGN:
variableValue -= rhs;
break;
case TOKEN_STAR_ASSIGN:
variableValue *= rhs;
break;
case TOKEN_SLASH_ASSIGN:
variableValue /= rhs;
break;
case TOKEN_MODULO_ASSIGN:
variableValue %= rhs;
break;
default:
parse_exception("internal error: unknown assignment token",
position);
break;
}
set_debug_variable(variable, variableValue);
return variableValue;
}
} else if (token.type == TOKEN_STAR) {
void* address;
uint32 size;
uint64 value = _ParseDereference(&address, &size);
int32 assignmentType = fTokenizer.NextToken().type;
if (assignmentType & TOKEN_ASSIGN_FLAG) {
// an assignment
uint64 rhs = _ParseExpression();
// check for division by zero for the respective assignment types
if ((assignmentType == TOKEN_SLASH_ASSIGN
|| assignmentType == TOKEN_MODULO_ASSIGN)
&& rhs == 0) {
parse_exception("division by zero", position);
}
// compute the new value
switch (assignmentType) {
case TOKEN_ASSIGN:
value = rhs;
break;
case TOKEN_PLUS_ASSIGN:
value += rhs;
break;
case TOKEN_MINUS_ASSIGN:
value -= rhs;
break;
case TOKEN_STAR_ASSIGN:
value *= rhs;
break;
case TOKEN_SLASH_ASSIGN:
value /= rhs;
break;
case TOKEN_MODULO_ASSIGN:
value %= rhs;
break;
default:
parse_exception("internal error: unknown assignment token",
position);
break;
}
// convert the value for writing to the address
uint64 buffer = 0;
switch (size) {
case 1:
*(uint8*)&buffer = value;
break;
case 2:
*(uint16*)&buffer = value;
break;
case 4:
*(uint32*)&buffer = value;
break;
case 8:
value = buffer;
break;
}
if (debug_memcpy(B_CURRENT_TEAM, address, &buffer, size) != B_OK) {
snprintf(sTempBuffer, sizeof(sTempBuffer),
"failed to write to address %p", address);
parse_exception(sTempBuffer, position);
}
return value;
}
}
if (expectAssignment) {
parse_exception("expected assignment",
fTokenizer.CurrentToken().position);
}
// no assignment -- reset to the identifier position and parse a sum
fTokenizer.SetPosition(position);
return _ParseSum(false, 0);
}
