Extending the shunting-yard algorithm to support the conditional ternary operator - ternary-operator

Question

How to extend the shunting yard algorithm, that's originally meant for binary operators to support the conditional ternary operator ("a ? b : c") ?
I haven't seen an answer to this here and I have one, so I'm posting it.

Answer 1

The way I did it was to add three new operators:
"?" ternary-open-if
":" ternary-else
ternary-closed-if
Only the first two will be created directly when reading the initial expression.
However, only the third one will exists in the output (the RPN of the initial expression).
The ternary-open-if is put on the operators stack whenever a "?" is seen.
The ternary-else is never put on the stack. Rather, the stack is poped until a ternary-open-if is found, then the ternary-open-if is replaced with the ternary-closed-if (thus indicating that we're in the else part of the conditional operator).
All three operators have higher precedence than all other operators (higher meaning they're evaluated AFTER other operators).
The ternary-if operators have the same precedence and right associativity (like in C), meaning that a ternary-if will never cause a pop of another ternary-if.
The ternary-else has a precedence higher than the ternary-ifs, and its associativity is irrelevant (since it is never put on the stack). So, when encountering a ternary-open-if it will convert it to a closed one as mentioned before.
When encountering a ternary-closed-if it will pop it.
Examples (ternary-closed-if notated as "?:"):
"a ? b : c" -->
"a b c ?:"
"a ? b : x ? y : z" -->
"a b x y z ?: ?:"
"a ? x ? y : z : b" -->
"a x y z ?: b ?:"
This method is more hard to explain than to implement, and it does make a slight change to the algorithm, so if anyone has a simpler solution, please post it.

Answer 2

For anyone still searching here, the conditional ternary operator can also be implemented as an IF function with three arguments:
IF([boolean], [expr_if_true], [expr_if_false])
For example, to convert IF(5 > 4, 9, 8) to Reverse Polish Notation by extending the shunting yard algorithm, do:
+-------+---------------------------------------------------+--------------+----------------+
| Token | Action | RPN Output | Operator stack |
+-------+---------------------------------------------------+--------------+----------------+
| IF | Push token to stack | | IF |
| ( | Push token to stack | | IF ( |
| 5 | Add token to output | 5 | IF ( |
| > | Push token to stack | 5 | 15 ( > |
| 4 | Add token to output | 5 4 | IF ( > |
| , | Pop from stack onto output until left parenthesis | 5 4 > | IF ( |
| 9 | Add token to output | 5 4 > 9 | IF ( |
| , | Pop from stack onto output until left parenthesis | 5 4 > 9 | IF ( |
| 8 | Add token to output | 5 4 > 9 8 | IF ( |
| ) | Pop from stack onto output until left parenthesis | 5 4 > 9 8 | IF |
| end | Pop entire stack onto output | 5 4 > 9 8 IF | |
+-------+---------------------------------------------------+--------------+----------------+
The postfix is evaluated as:
+-------+------------------------------------------------------------------------------------------+-------+
| Token | Action | Stack |
+-------+------------------------------------------------------------------------------------------+-------+
| 5 | Push to stack | 5 |
| 4 | Push to stack | 4 |
| > | Pop from stack twice (5, 4), evaluate (5 > 4) and push onto stack | TRUE |
| 9 | Push onto stack | 9 |
| 8 | Push onto stack | 8 |
| IF | Pop from stack thrice (TRUE, 9, 8), evaluate (IF TRUE THEN 9 ELSE 8) and push onto stack | 9 |
+-------+------------------------------------------------------------------------------------------+-------+