1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
* Use of this file is governed by the BSD 3-clause license that
* can be found in the LICENSE.txt file in the project root.
*/
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Sharpen;
namespace Antlr4.Runtime.Atn
{
/// <summary>
/// Executes a custom lexer action by calling
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// with the
/// rule and action indexes assigned to the custom action. The implementation of
/// a custom action is added to the generated code for the lexer in an override
/// of
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// when the grammar is compiled.
/// <p>This class may represent embedded actions created with the <code>{...}</code>
/// syntax in ANTLR 4, as well as actions created for lexer commands where the
/// command argument could not be evaluated when the grammar was compiled.</p>
/// </summary>
/// <author>Sam Harwell</author>
/// <since>4.2</since>
public sealed class LexerCustomAction : ILexerAction
{
private readonly int ruleIndex;
private readonly int actionIndex;
/// <summary>
/// Constructs a custom lexer action with the specified rule and action
/// indexes.
/// </summary>
/// <remarks>
/// Constructs a custom lexer action with the specified rule and action
/// indexes.
/// </remarks>
/// <param name="ruleIndex">
/// The rule index to use for calls to
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// .
/// </param>
/// <param name="actionIndex">
/// The action index to use for calls to
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// .
/// </param>
public LexerCustomAction(int ruleIndex, int actionIndex)
{
this.ruleIndex = ruleIndex;
this.actionIndex = actionIndex;
}
/// <summary>
/// Gets the rule index to use for calls to
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// .
/// </summary>
/// <returns>The rule index for the custom action.</returns>
public int RuleIndex
{
get
{
return ruleIndex;
}
}
/// <summary>
/// Gets the action index to use for calls to
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// .
/// </summary>
/// <returns>The action index for the custom action.</returns>
public int ActionIndex
{
get
{
return actionIndex;
}
}
/// <summary><inheritDoc/></summary>
/// <returns>
/// This method returns
/// <see cref="LexerActionType.Custom"/>
/// .
/// </returns>
public LexerActionType ActionType
{
get
{
return LexerActionType.Custom;
}
}
/// <summary>Gets whether the lexer action is position-dependent.</summary>
/// <remarks>
/// Gets whether the lexer action is position-dependent. Position-dependent
/// actions may have different semantics depending on the
/// <see cref="Antlr4.Runtime.ICharStream"/>
/// index at the time the action is executed.
/// <p>Custom actions are position-dependent since they may represent a
/// user-defined embedded action which makes calls to methods like
/// <see cref="Antlr4.Runtime.Lexer.Text()"/>
/// .</p>
/// </remarks>
/// <returns>
/// This method returns
/// <see langword="true"/>
/// .
/// </returns>
public bool IsPositionDependent
{
get
{
return true;
}
}
/// <summary>
/// <inheritDoc/>
/// <p>Custom actions are implemented by calling
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Action(Antlr4.Runtime.RuleContext, int, int)"/>
/// with the
/// appropriate rule and action indexes.</p>
/// </summary>
public void Execute(Lexer lexer)
{
lexer.Action(null, ruleIndex, actionIndex);
}
public override int GetHashCode()
{
int hash = MurmurHash.Initialize();
hash = MurmurHash.Update(hash, (int)(ActionType));
hash = MurmurHash.Update(hash, ruleIndex);
hash = MurmurHash.Update(hash, actionIndex);
return MurmurHash.Finish(hash, 3);
}
public override bool Equals(object obj)
{
if (obj == this)
{
return true;
}
else
{
if (!(obj is Antlr4.Runtime.Atn.LexerCustomAction))
{
return false;
}
}
Antlr4.Runtime.Atn.LexerCustomAction other = (Antlr4.Runtime.Atn.LexerCustomAction)obj;
return ruleIndex == other.ruleIndex && actionIndex == other.actionIndex;
}
}
}