Make tree from mathematical expression by std::regex - c++

Question

Programm get string like:VARIABLE=EXPRESSION.
where VARIABLE is some letters and numbers, starting letter
and EXPRESSION is mathematical expression that can include:
1) + or *
2) ( or )
3) numbers (for example, 5; 3.8; 1e+18, 8.41E-10)
4) another names of variables.
I need to turn this into the tree (just in memory) using one regular exprassion.
How can i do this?
Was proposed method:
search for = out of ()
search for + out of ()
search for * out of ()
if somethig found - break expression in 2 parts, else we got number or variable.
Looks pretty simple, but i can't create this expressions.
I'm alse found how to put conditional operator into regular expression.
Mostly, i just need 3 regular exprassions for =, + and *.
Example:
http://i.stack.imgur.com/I8R12.png

Answer 1

As stated by n.m., regular expressions can't deal with nested parentheses. However there are simple alternatives that can parse nested parenthesis, such as recursive descent parsers.
Example:
enum TokenType
{
TTId,
TTNumber,
TTPlus,
TTMinus,
TTTimes,
TTDivide,
TTLParen,
TTRParen,
TTEndOfInput
};
TokenType token = TTEndOfInput;
string tokenValue;
int peekChar();
void nextChar();
void error(string msg); // doesn't return
Value *createConstant(string value);
Value *createReadVariable(string name);
Value *createAdd(Value *l, Value *r);
Value *createSubtract(Value *l, Value *r);
Value *createMultiply(Value *l, Value *r);
Value *createDivide(Value *l, Value *r);
Value *createNegate(Value *l, Value *r);
Value *expression();
void getToken()
{
token = TTEndOfInput;
tokenValue = "";
if(peekChar() == EOF)
return;
if(isalpha(peekChar()))
{
while(isalnum(peekChar()))
{
tokenValue += (char)peekChar();
nextChar();
}
token = TTId;
return;
}
if(isdigit(peekChar()) || peekChar() == '.')
{
while(isdigit(peekChar()))
{
tokenValue += (char)peekChar();
nextChar();
}
if(peekChar() == '.')
{
tokenValue += (char)peekChar();
nextChar();
while(isdigit(peekChar()))
{
tokenValue += (char)peekChar();
nextChar();
}
if(tokenValue == ".")
error("missing digit");
}
if(peekChar() == 'e')
{
tokenValue += (char)peekChar();
nextChar();
if(peekChar() == '+' || peekChar() == '-')
{
tokenValue += (char)peekChar();
nextChar();
}
if(!isdigit(peekChar()))
error("missing digit");
while(isdigit(peekChar()))
{
tokenValue += (char)peekChar();
nextChar();
}
}
token = TTNumber;
return;
}
switch(peekChar())
{
case '+':
token = TTPlus;
nextChar();
return;
case '-':
token = TTMinus;
nextChar();
return;
case '*':
token = TTTimes;
nextChar();
return;
case '/':
token = TTDivide;
nextChar();
return;
case '(':
token = TTLParen;
nextChar();
return;
case ')':
token = TTRParen;
nextChar();
return;
default:
error("invalid charater");
}
}
Value *topLevel()
{
Value *retval;
switch(token)
{
case TTId:
retval = createReadVariable(tokenValue);
getToken();
return retval;
case TTNumber:
retval = createConstant(tokenValue);
getToken();
return retval;
case TTLParen:
getToken();
retval = expression();
if(token != TTRParen)
error("expected )");
getToken();
return retval;
case TTMinus:
getToken();
return createNegate(topLevel());
default:
error("unexpected token");
}
}
Value *mulDiv()
{
Value *retval = topLevel();
while(token == TTTimes || token == TTDivide)
{
TokenType operation = token;
getToken();
Value *rhs = topLevel();
if(operation == TTTimes)
{
retval = createMultiply(retval, rhs);
}
else // operation == TTDivide
{
retval = createDivide(retval, rhs);
}
}
return retval;
}
Value *addSub()
{
Value *retval = mulDiv();
while(token == TTPlus || token == TTMinus)
{
TokenType operation = token;
getToken();
Value *rhs = mulDiv();
if(operation == TTPlus)
{
retval = createAdd(retval, rhs);
}
else // operation == TTMinus
{
retval = createSubtract(retval, rhs);
}
}
return retval;
}
Value *expression()
{
return addSub();
}
void error(string msg)
{
cerr << "error : " << msg << endl;
exit(1);
}
int main()
{
getToken();
Value *expressionTree = expression();
// ...
return 0;
}