March 13, 2012 Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

I'm reading through D's grammar spec, and maybe it's just not enough sleep or some such, but my brain is turning to mud: Is there a simple operator precidence chart somewhere? (Also, for associativity: Assign and OpAssign are right-associative and everything else is left-associative, correct?) |

March 13, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Nick Sabalausky | On 03/13/2012 11:29 PM, Nick Sabalausky wrote: > I'm reading through D's grammar spec, and maybe it's just not enough sleep > or some such, but my brain is turning to mud: > > Is there a simple operator precidence chart somewhere? I don't think there is, but I think I can create one: ! // 1 template instantiation => // 2 goesto, binds weaker to the right . ++ -- ( [ // 3 postfix operators ^^ // 4 power (right-associative) & ++ -- * - + ! ~ // 5 prefix operators * / % // 6 multiplicative operators + - ~ // 7 additive operators >> << >>> // 8 shift operators == != > < >= <= \ // 9 relational operators !> !< !>= !<= <>\ !<> <>= !<>= in \ !in is !is & // 10 bitwise AND (ambiguous with 9) ^ // 11 bitwise XOR (ambiguous with 9) | // 12 bitwise OR (ambiguous with 9) && // 13 logical AND || // 14 logical OR ?: // 15 conditional operator /= &= |= -= += \ // 16 assignment operators (right-associative) <<= >>= >>>= = \ *= %= ^= ^^= ~= => // 17 goesto, binds stronger to the left , // 18 comma operator .. // range (not actually an operator) > (Also, for > associativity: Assign and OpAssign are right-associative and everything else > is left-associative, correct?) > > Power is right-associative too. |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Nick Sabalausky | On Tuesday, March 13, 2012 18:29:03 Nick Sabalausky wrote: > I'm reading through D's grammar spec, and maybe it's just not enough sleep or some such, but my brain is turning to mud: > > Is there a simple operator precidence chart somewhere? (Also, for associativity: Assign and OpAssign are right-associative and everything else is left-associative, correct?) For all of the operators which come from C/C++, the operator precendence chart from C/C++ should work: http://en.cppreference.com/w/cpp/language/operator_precedence It's how the D-specific ones fit in that gets harder to figure out. IIRC TDPL has an operator precedence table though, so you should be able to look there. - Jonathan M Davis |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Timon Gehr | "Timon Gehr" <timon.gehr@gmx.ch> wrote in message news:jjokc7$t3j$1@digitalmars.com... > On 03/13/2012 11:29 PM, Nick Sabalausky wrote: >> I'm reading through D's grammar spec, and maybe it's just not enough >> sleep >> or some such, but my brain is turning to mud: >> >> Is there a simple operator precidence chart somewhere? > > > I don't think there is, but I think I can create one: > Thanks! > == != > < >= <= \ // 9 relational operators > !> !< !>= !<= <>\ > !<> <>= !<>= in \ > !in is !is > & // 10 bitwise AND (ambiguous with 9) > ^ // 11 bitwise XOR (ambiguous with 9) > | // 12 bitwise OR (ambiguous with 9) Ah, see, that's what I was tripping up on. I thought there seemed to be something slightly odd going on with those (and then from there I started second-guessing everything). It seemed almost like these had both ordered priorities *and* the same priority. So how exactly does this part work then? > >> (Also, for >> associativity: Assign and OpAssign are right-associative and everything >> else >> is left-associative, correct?) >> >> > > Power is right-associative too. Oh that's right. I keep forgetting we have that now. |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Nick Sabalausky | On 03/14/2012 01:20 AM, Nick Sabalausky wrote: > "Timon Gehr"<timon.gehr@gmx.ch> wrote in message >> >> << >>> // 8 shift operators >> == !=> < >=<= \ // 9 relational operators >> !> !< !>= !<=<>\ >> !<> <>= !<>= in \ >> !in is !is >> & // 10 bitwise AND (ambiguous with 9) >> ^ // 11 bitwise XOR (ambiguous with 9) >> | // 12 bitwise OR (ambiguous with 9) > > Ah, see, that's what I was tripping up on. I thought there seemed to be > something slightly odd going on with those (and then from there I started > second-guessing everything). It seemed almost like these had both ordered > priorities *and* the same priority. > > So how exactly does this part work then? > It is a special case. If a bitwise operator appears next to a relational operator, then the expression has to be parenthesised for disambiguation. You can think of it as a partial order: ... | shift operators ^ ^ / \ / bitwise AND / \ / bitwise XOR / \ relational operators bitwise OR ^ ^ \ / \ / \ / \ / logical AND ^ | logical OR ^ | ... The precedence of bitwise operators cannot be compared with the precedence of relational operators, and D disallows programs that cannot be parsed unambiguously. |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Timon Gehr | "Timon Gehr" <timon.gehr@gmx.ch> wrote in message news:jjpmov$305u$1@digitalmars.com... > On 03/14/2012 01:20 AM, Nick Sabalausky wrote: >> "Timon Gehr"<timon.gehr@gmx.ch> wrote in message > >>> >> << >>> // 8 shift operators >>> == !=> < >=<= \ // 9 relational operators >>> !> !< !>= !<=<>\ >>> !<> <>= !<>= in \ >>> !in is !is >>> & // 10 bitwise AND (ambiguous with 9) >>> ^ // 11 bitwise XOR (ambiguous with 9) >>> | // 12 bitwise OR (ambiguous with 9) >> >> Ah, see, that's what I was tripping up on. I thought there seemed to be something slightly odd going on with those (and then from there I started second-guessing everything). It seemed almost like these had both ordered priorities *and* the same priority. >> >> So how exactly does this part work then? >> > > It is a special case. If a bitwise operator appears next to a relational operator, then the expression has to be parenthesised for disambiguation. You can think of it as a partial order: > > ... > | > shift operators > ^ ^ > / \ > / bitwise AND > / \ > / bitwise XOR > / \ > relational operators bitwise OR > ^ ^ > \ / > \ / > \ / > \ / > logical AND > ^ > | > logical OR > ^ > | > ... > > The precedence of bitwise operators cannot be compared with the precedence of relational operators, and D disallows programs that cannot be parsed unambiguously. Ok, I see. Thanks. |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Timon Gehr | ```
On 14-3-2012 0:14, Timon Gehr wrote:
> I don't think there is, but I think I can create one:
>
> ! // 1 template instantiation
> => // 2 goesto, binds weaker to the right
> . ++ -- ( [ // 3 postfix operators
> ^^ // 4 power (right-associative)
> & ++ -- * - + ! ~ // 5 prefix operators
> * / % // 6 multiplicative operators
> + - ~ // 7 additive operators
> >> << >>> // 8 shift operators
> == != > < >= <= \ // 9 relational operators
> !> !< !>= !<= <>\
> !<> <>= !<>= in \
> !in is !is
> & // 10 bitwise AND (ambiguous with 9)
> ^ // 11 bitwise XOR (ambiguous with 9)
> | // 12 bitwise OR (ambiguous with 9)
> && // 13 logical AND
> || // 14 logical OR
> ?: // 15 conditional operator
> /= &= |= -= += \ // 16 assignment operators (right-associative)
> <<= >>= >>>= = \
> *= %= ^= ^^= ~=
> => // 17 goesto, binds stronger to the left
> , // 18 comma operator
> .. // range (not actually an operator)
The TDPL has a list of expressions in decreasing precedence
on pages 61-63. Some of these operators, like <> or ^^= are
not listed there.
Is there a difference between != and <> ?
Why is the "goesto" operator listed twice? Is that accidental?
Jos
``` |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Jos van Uden | On 03/14/2012 01:23 PM, Jos van Uden wrote: > On 14-3-2012 0:14, Timon Gehr wrote: >> I don't think there is, but I think I can create one: >> >> ! // 1 template instantiation >> => // 2 goesto, binds weaker to the right >> . ++ -- ( [ // 3 postfix operators >> ^^ // 4 power (right-associative) >> & ++ -- * - + ! ~ // 5 prefix operators >> * / % // 6 multiplicative operators >> + - ~ // 7 additive operators >> >> << >>> // 8 shift operators >> == != > < >= <= \ // 9 relational operators >> !> !< !>= !<= <>\ >> !<> <>= !<>= in \ >> !in is !is >> & // 10 bitwise AND (ambiguous with 9) >> ^ // 11 bitwise XOR (ambiguous with 9) >> | // 12 bitwise OR (ambiguous with 9) >> && // 13 logical AND >> || // 14 logical OR >> ?: // 15 conditional operator >> /= &= |= -= += \ // 16 assignment operators (right-associative) >> <<= >>= >>>= = \ >> *= %= ^= ^^= ~= >> => // 17 goesto, binds stronger to the left >> , // 18 comma operator >> .. // range (not actually an operator) > > The TDPL has a list of expressions in decreasing precedence > on pages 61-63. Some of these operators, like <> or ^^= are > not listed there. Some guys want to deprecate <>, but I think it is actually quite nice. ^^ and ^^= were added after TDPL was released afaik. > > Is there a difference between != and <> ? Yes, != gives true when at least one of the arguments is NAN, while <> gives false if at least one of the arguments is NAN. != means not equal. <> means ordered, but not equal. There is also <>=, which just means ordered, etc. > > Why is the "goesto" operator listed twice? Is that accidental? > That is intentional. It binds stronger to the left than to the right, for example: x+x=>x+x will be parsed as: x+(x=>(x+x)) (It could be argued that => is not a proper 'operator', but an operator precedence parser can be slightly more efficient if it is treated as one.) |

March 14, 2012 Re: Simple operator precidence chart (and associativity)? | ||||
---|---|---|---|---|

| ||||

Posted in reply to Timon Gehr | ```
On 13/03/2012 23:14, Timon Gehr wrote:
<snip>
>> (Also, for
>> associativity: Assign and OpAssign are right-associative and everything else
>> is left-associative, correct?)
>>
>>
>
> Power is right-associative too.
You forgot the conditional operator.
And the relational operators are non-associative (a == b == c or similar is illegal).
Stewart.
``` |