Question

I’m not looking for an implementation, just pseudo-code, or at least an algorithm to handle this effectively. I need to process statements like these:

(a)     # if(a)
(a,b)   # if(a || b)
(a+b)   # if(a && b)
(a+b,c) # same as ((a+b),c) or if((a&&b) || c)
(a,b+c) # same as (a,(b|c)) or if(a || (b&&c))

So the + operator takes precedence over the , operator. (so my + is like mathematical multiplication with , being mathematical addition, but that is just confusing).

I think a recursive function would be best, so I can handle nested parentheses nice and easy by a recursive call. I’ll also take care of error handling once the function returns, so no worries there. The problems I’m having:

1. I just don’t know how to tackle the precedence thing. I could return true as soon as I see a , and the previous value was true. Otherwise, I’ll rerun the same routine. A plus would effectively be a bool multiplication (ie true*true=true, true*false=false etc…).

2. Error detection: I’ve thought up several schemes to handle the input, but there are a lot of ugly bad things I want to detect and print an error to the user. None of the schemes I thought of handle errors in a unified (read: centralized) place in the code, which would be nice for maintainability and readability:

   ()
   (,...
   (+...
   (a,,...
   (a,+...
   (a+,...
   (a++...
   

   Detecting these in my “routine” above should take care of bad input. Of course I’ll check end-of-input each time I read a token.

Of course I’ll have the problem of maybe having o read the full text file if there are unmatched parenthesis, but hey, people should avoid such tension.

EDIT: Ah, yes, I forgot the ! which should also be usable like the classic not operator:

(!a+b,c,!d)

Tiny update for those interested: I had an uninformed wild go at this, and wrote my own implementation from scratch. It may not be pretty enough for the die-hards, so hence this question on codereview.

Answer 1

The shunting-yard algorithm is easily implementable in a relatively short amount of code. It can be used to convert an infix expression like those in your examples into postfix expressions, and evaluation of a postfix expression is Easy-with-a-capital-E (you don’t strictly need to complete the infix-to-postfix conversion; you can evaluate the postfix output of the shunting yard directly and just accumulate the result as you go along).

It handles operator precedence, parentheses, and both unary and binary operators (and with a little effort can be modified to handle infix ternary operators, like the conditional operator in many languages).