← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to contrib/NRefactory/Project/Src/OperatorPrecedence.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/NRefactory/Project/Src/OperatorPrecedence.cs
1
 
// <file>
2
 
//     <copyright see="prj:///doc/copyright.txt"/>
3
 
//     <license see="prj:///doc/license.txt"/>
4
 
//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
5
 
//     <version>$Revision: 2644$</version>
6
 
// </file>
7
 
 
8
 
using System;
9
 
using System.Collections.Generic;
10
 
using ICSharpCode.OldNRefactory.Ast;
11
 
 
12
 
namespace ICSharpCode.OldNRefactory
13
 
{
14
 
        /// <summary>
15
 
        /// Stores the operator precedences for the output visitor.
16
 
        /// </summary>
17
 
        static class OperatorPrecedence
18
 
        {
19
 
                static readonly Dictionary<BinaryOperatorType, int> vbDict = MakePrecedenceTable(
20
 
                        new BinaryOperatorType[] { BinaryOperatorType.Power },
21
 
                        new BinaryOperatorType[] { BinaryOperatorType.Multiply, BinaryOperatorType.Divide },
22
 
                        new BinaryOperatorType[] { BinaryOperatorType.DivideInteger },
23
 
                        new BinaryOperatorType[] { BinaryOperatorType.Modulus },
24
 
                        new BinaryOperatorType[] { BinaryOperatorType.Add, BinaryOperatorType.Subtract },
25
 
                        new BinaryOperatorType[] { BinaryOperatorType.Concat },
26
 
                        new BinaryOperatorType[] { BinaryOperatorType.ShiftLeft, BinaryOperatorType.ShiftRight },
27
 
                        new BinaryOperatorType[] {
28
 
                                BinaryOperatorType.Equality, BinaryOperatorType.InEquality,
29
 
                                BinaryOperatorType.LessThan, BinaryOperatorType.LessThanOrEqual,
30
 
                                BinaryOperatorType.GreaterThan, BinaryOperatorType.GreaterThanOrEqual,
31
 
                                BinaryOperatorType.ReferenceEquality, BinaryOperatorType.ReferenceInequality,
32
 
                                BinaryOperatorType.Like
33
 
                        },
34
 
                        new BinaryOperatorType[] { BinaryOperatorType.LogicalAnd, BinaryOperatorType.BitwiseAnd },
35
 
                        new BinaryOperatorType[] { BinaryOperatorType.LogicalOr, BinaryOperatorType.BitwiseOr },
36
 
                        new BinaryOperatorType[] { BinaryOperatorType.ExclusiveOr }
37
 
                );
38
 
                
39
 
                static readonly Dictionary<BinaryOperatorType, int> csharpDict = MakePrecedenceTable(
40
 
                        new BinaryOperatorType[] { BinaryOperatorType.Multiply, BinaryOperatorType.Divide, BinaryOperatorType.Modulus },
41
 
                        new BinaryOperatorType[] { BinaryOperatorType.Add, BinaryOperatorType.Subtract },
42
 
                        new BinaryOperatorType[] { BinaryOperatorType.ShiftLeft, BinaryOperatorType.ShiftRight },
43
 
                        new BinaryOperatorType[] {
44
 
                                BinaryOperatorType.LessThan, BinaryOperatorType.LessThanOrEqual,
45
 
                                BinaryOperatorType.GreaterThan, BinaryOperatorType.GreaterThanOrEqual,
46
 
                        },
47
 
                        new BinaryOperatorType[] { BinaryOperatorType.Equality, BinaryOperatorType.InEquality },
48
 
                        new BinaryOperatorType[] { BinaryOperatorType.BitwiseAnd },
49
 
                        new BinaryOperatorType[] { BinaryOperatorType.ExclusiveOr },
50
 
                        new BinaryOperatorType[] { BinaryOperatorType.BitwiseOr },
51
 
                        new BinaryOperatorType[] { BinaryOperatorType.LogicalAnd, BinaryOperatorType.LogicalOr },
52
 
                        new BinaryOperatorType[] { BinaryOperatorType.NullCoalescing }
53
 
                );
54
 
                
55
 
                // create a dictionary operator->precedence (higher value = higher precedence)
56
 
                static Dictionary<BinaryOperatorType, int> MakePrecedenceTable(params BinaryOperatorType[][] input)
57
 
                {
58
 
                        Dictionary<BinaryOperatorType, int> dict = new Dictionary<BinaryOperatorType, int>();
59
 
                        for (int i = 0; i < input.Length; i++) {
60
 
                                foreach (BinaryOperatorType op in input[i]) {
61
 
                                        dict.Add(op, input.Length - i);
62
 
                                }
63
 
                        }
64
 
                        return dict;
65
 
                }
66
 
                
67
 
                public static int ComparePrecedenceVB(BinaryOperatorType op1, BinaryOperatorType op2)
68
 
                {
69
 
                        int p1 = GetOperatorPrecedence(vbDict, op1);
70
 
                        int p2 = GetOperatorPrecedence(vbDict, op2);
71
 
                        return p1.CompareTo(p2);
72
 
                }
73
 
                
74
 
                public static int ComparePrecedenceCSharp(BinaryOperatorType op1, BinaryOperatorType op2)
75
 
                {
76
 
                        int p1 = GetOperatorPrecedence(csharpDict, op1);
77
 
                        int p2 = GetOperatorPrecedence(csharpDict, op2);
78
 
                        return p1.CompareTo(p2);
79
 
                }
80
 
                
81
 
                static int GetOperatorPrecedence(Dictionary<BinaryOperatorType, int> dict, BinaryOperatorType op)
82
 
                {
83
 
                        int p;
84
 
                        dict.TryGetValue(op, out p);
85
 
                        return p;
86
 
                }
87
 
        }
88
 
}