shift/reduce conflict and grouping

["Pieter van der Spek" <pieter@West.NL>]

In the grammar I'm currently working on I'm getting a shift/reduce
conflict that I cannot explain

shift/reduce conflict in state [stack: TKlasse TIdentifier TThread TCases
PPlusExpression *] on TPlus in {
        [ PPlusExpression = PPlusExpression * TPlus PStarExpression ]
(shift),
        [ PRelationExpression = PPlusExpression * ] followed by TPlus
(reduce)
}

shift/reduce conflict in state [stack: TKlasse TIdentifier TThread TCases
PPlusE
xpression *] on TMinus in {
        [ PPlusExpression = PPlusExpression * TMinus PStarExpression ]
(shift),
        [ PRelationExpression = PPlusExpression * ] followed by TMinus
(reduce)
}


Below are the corresponding productions:

relation_expression = {psubset} relation_expression psubset plus_expression
	| {not_in_set} relation_expression not_in_set plus_expression
	| {in_set} relation_expression in_set plus_expression
	| {subset} relation_expression subset plus_expression
	| {not_equal} relation_expression not_equal plus_expression
	| {less_than} relation_expression less_than plus_expression
	| {greater_than} relation_expression greater_than plus_expression
        | {less_or_equal} relation_expression less_or_equal plus_expression
	| {greater_or_equal} relation_expression greater_or_equal plus_expression
	| {plus} plus_expression;

plus_expression = {plus} plus_expression plus star_expression
	| {minus} plus_expression minus star_expression
	| {union} plus_expression union star_expression
	| {set_diff} plus_expression set_diff star_expression
	| {munion} plus_expression munion star_expression
	| {double_plus} plus_expression double_plus star_expression
	| {concat} plus_expression concat star_expression
	| {star} star_expression;


I compared my code to a simple example, which works flawlessly:

	start = expr semi;

	expr = {plus} expr plus mexpr
		| {minus} expr minus mexpr
		| {mexpr} mexpr;

	mexpr = {star} mexpr star atom
		| {div} mexpr div atom
		| {atom} atom;

	atom = int;


I cannot see any significant differences. So why does my real grammar
result in a shift/reduce conflict ?

------------------------------------------

I also have another problem. How can I create productions that are
left/right grouping (not both at the same time) ? The simple example above
is left grouping (if I'm not mistaken). However, the grammar I'm working
on has operators that are right grouping. How do I model that ?

Thanks in advance for your help.

-------------------

Pieter van der Spek
---- West Consulting B.V.        - www.west.nl
---- Tu Delft / Computer Science - www.tudelft.nl