← Back to branch summary

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

« back to all changes in this revision

Viewing changes to external/nrefactory/ICSharpCode.NRefactory.VB/Ast/VBModifierToken.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:
external/nrefactory/ICSharpCode.NRefactory.VB/Ast/VBModifierToken.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using System.Linq;
 
7
 
 
8
namespace ICSharpCode.NRefactory.VB.Ast
 
9
{
 
10
        /// <summary>
 
11
        /// Description of VBModifierToken.
 
12
        /// </summary>
 
13
        public class VBModifierToken : VBTokenNode
 
14
        {
 
15
                Modifiers modifier;
 
16
                
 
17
                public Modifiers Modifier {
 
18
                        get { return modifier; }
 
19
                        set {
 
20
                                for (int i = 0; i < lengthTable.Count; i++) {
 
21
                                        if (lengthTable[i].Key == value) {
 
22
                                                this.modifier = value;
 
23
                                                this.tokenLength = lengthTable[i].Value;
 
24
                                                return;
 
25
                                        }
 
26
                                }
 
27
                                throw new ArgumentException ("Modifier " + value + " is invalid.");
 
28
                        }
 
29
                }
 
30
                
 
31
                protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
 
32
                {
 
33
                        VBModifierToken o = other as VBModifierToken;
 
34
                        return o != null && this.modifier == o.modifier;
 
35
                }
 
36
                
 
37
                // Not worth using a dictionary for such few elements.
 
38
                // This table is sorted in the order that modifiers should be output when generating code.
 
39
                static readonly List<KeyValuePair<Modifiers, int>> lengthTable = new List<KeyValuePair<Modifiers, int>> () {
 
40
                        new KeyValuePair<Modifiers, int>(Modifiers.Public, "Public".Length),
 
41
                        new KeyValuePair<Modifiers, int>(Modifiers.Protected, "Protected".Length),
 
42
                        new KeyValuePair<Modifiers, int>(Modifiers.Private, "Private".Length),
 
43
                        new KeyValuePair<Modifiers, int>(Modifiers.Friend, "Friend".Length),
 
44
                        new KeyValuePair<Modifiers, int>(Modifiers.MustInherit, "MustInherit".Length),
 
45
                        new KeyValuePair<Modifiers, int>(Modifiers.MustOverride, "MustOverride".Length),
 
46
                        new KeyValuePair<Modifiers, int>(Modifiers.Overridable, "Overridable".Length),
 
47
                        new KeyValuePair<Modifiers, int>(Modifiers.NotInheritable, "NotInheritable".Length),
 
48
                        new KeyValuePair<Modifiers, int>(Modifiers.NotOverridable, "NotOverridable".Length),
 
49
                        new KeyValuePair<Modifiers, int>(Modifiers.Dim, "Dim".Length),
 
50
                        new KeyValuePair<Modifiers, int>(Modifiers.Const, "Const".Length),
 
51
                        new KeyValuePair<Modifiers, int>(Modifiers.Shared, "Shared".Length),
 
52
                        new KeyValuePair<Modifiers, int>(Modifiers.Static, "Static".Length),
 
53
                        new KeyValuePair<Modifiers, int>(Modifiers.Override, "Override".Length),
 
54
                        new KeyValuePair<Modifiers, int>(Modifiers.ReadOnly, "ReadOnly".Length),
 
55
                        new KeyValuePair<Modifiers, int>(Modifiers.WriteOnly, "WriteOnly".Length),
 
56
                        new KeyValuePair<Modifiers, int>(Modifiers.Shadows, "Shadows".Length),
 
57
                        new KeyValuePair<Modifiers, int>(Modifiers.Partial, "Partial".Length),
 
58
                        new KeyValuePair<Modifiers, int>(Modifiers.Overloads, "Overloads".Length),
 
59
                        new KeyValuePair<Modifiers, int>(Modifiers.WithEvents, "WithEvents".Length),
 
60
                        new KeyValuePair<Modifiers, int>(Modifiers.Default, "Default".Length),
 
61
                        // parameter modifiers
 
62
                        new KeyValuePair<Modifiers, int>(Modifiers.Optional, "Optional".Length),
 
63
                        new KeyValuePair<Modifiers, int>(Modifiers.ByVal, "ByVal".Length),
 
64
                        new KeyValuePair<Modifiers, int>(Modifiers.ByRef, "ByRef".Length),
 
65
                        new KeyValuePair<Modifiers, int>(Modifiers.ParamArray, "ParamArray".Length),
 
66
                        // operator modifiers
 
67
                        new KeyValuePair<Modifiers, int>(Modifiers.Narrowing, "Narrowing".Length),
 
68
                        new KeyValuePair<Modifiers, int>(Modifiers.Widening, "Widening".Length),
 
69
                        // VB 11 modifiers
 
70
                        new KeyValuePair<Modifiers, int>(Modifiers.Async, "Async".Length),
 
71
                        new KeyValuePair<Modifiers, int>(Modifiers.Iterator, "Iterator".Length),
 
72
                        // even though it's used for patterns only, it needs to be in this table to be usable in the AST
 
73
                        new KeyValuePair<Modifiers, int>(Modifiers.Any, "Any".Length)
 
74
                };
 
75
                
 
76
                public static IEnumerable<Modifiers> AllModifiers {
 
77
                        get { return lengthTable.Select(p => p.Key); }
 
78
                }
 
79
                
 
80
                public VBModifierToken(TextLocation location, Modifiers modifier) : base (location, 0)
 
81
                {
 
82
                        this.Modifier = modifier;
 
83
                }
 
84
                
 
85
                public static string GetModifierName(Modifiers modifier)
 
86
                {
 
87
                        switch (modifier) {
 
88
                                case Modifiers.Private:
 
89
                                        return "Private";
 
90
                                case Modifiers.Friend:
 
91
                                        return "Friend";
 
92
                                case Modifiers.Protected:
 
93
                                        return "Protected";
 
94
                                case Modifiers.Public:
 
95
                                        return "Public";
 
96
                                case Modifiers.MustInherit:
 
97
                                        return "MustInherit";
 
98
                                case Modifiers.MustOverride:
 
99
                                        return "MustOverride";
 
100
                                case Modifiers.Overridable:
 
101
                                        return "Overridable";
 
102
                                case Modifiers.NotInheritable:
 
103
                                        return "NotInheritable";
 
104
                                case Modifiers.NotOverridable:
 
105
                                        return "NotOverridable";
 
106
                                case Modifiers.Const:
 
107
                                        return "Const";
 
108
                                case Modifiers.Shared:
 
109
                                        return "Shared";
 
110
                                case Modifiers.Static:
 
111
                                        return "Static";
 
112
                                case Modifiers.Override:
 
113
                                        return "Override";
 
114
                                case Modifiers.ReadOnly:
 
115
                                        return "ReadOnly";
 
116
                                case Modifiers.Shadows:
 
117
                                        return "Shadows";
 
118
                                case Modifiers.Partial:
 
119
                                        return "Partial";
 
120
                                case Modifiers.Overloads:
 
121
                                        return "Overloads";
 
122
                                case Modifiers.WithEvents:
 
123
                                        return "WithEvents";
 
124
                                case Modifiers.Default:
 
125
                                        return "Default";
 
126
                                case Modifiers.Dim:
 
127
                                        return "Dim";
 
128
                                case Modifiers.WriteOnly:
 
129
                                        return "WriteOnly";
 
130
                                case Modifiers.Optional:
 
131
                                        return "Optional";
 
132
                                case Modifiers.ByVal:
 
133
                                        return "ByVal";
 
134
                                case Modifiers.ByRef:
 
135
                                        return "ByRef";
 
136
                                case Modifiers.ParamArray:
 
137
                                        return "ParamArray";
 
138
                                case Modifiers.Widening:
 
139
                                        return "Widening";
 
140
                                case Modifiers.Narrowing:
 
141
                                        return "Narrowing";
 
142
                                case Modifiers.Async:
 
143
                                        return "Async";
 
144
                                case Modifiers.Iterator:
 
145
                                        return "Iterator";
 
146
                                default:
 
147
                                        throw new NotSupportedException("Invalid value for Modifiers: " + modifier);
 
148
                        }
 
149
                }
 
150
        }
 
151
}