-
-
Notifications
You must be signed in to change notification settings - Fork 156
Expand file tree
/
Copy pathKeywordMap.java
More file actions
176 lines (151 loc) · 4.69 KB
/
KeywordMap.java
File metadata and controls
176 lines (151 loc) · 4.69 KB
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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
/*
* KeywordMap.java - Fast keyword->id map
* Copyright (C) 1998, 1999 Slava Pestov
* Copyright (C) 1999 Mike Dillon
*
* You may use and modify this package for any purpose. Redistribution is
* permitted, in both source and binary form, provided that this notice
* remains intact in all source distributions of this package.
*/
package processing.app.syntax;
import javax.swing.text.Segment;
/**
* A <code>KeywordMap</code> is similar to a hashtable in that it maps keys
* to values. However, the `keys' are Swing segments. This allows lookups of
* text substrings without the overhead of creating a new string object.
* <p>
* This class is used by <code>CTokenMarker</code> to map keywords to ids.
*
* @author Slava Pestov, Mike Dillon
* @version $Id$
*/
public class KeywordMap {
// private Keyword[] map;
// protected int mapLength;
private boolean ignoreCase;
private Keyword[] literalMap;
private Keyword[] parenMap;
// A value of 52 will give good performance for most maps.
static private int MAP_LENGTH = 52;
/**
* Creates a new <code>KeywordMap</code>.
* @param ignoreCase True if keys are case insensitive
*/
public KeywordMap(boolean ignoreCase) {
// this(ignoreCase, 52);
this.ignoreCase = ignoreCase;
literalMap = new Keyword[MAP_LENGTH];
parenMap = new Keyword[MAP_LENGTH];
}
// /**
// * Creates a new <code>KeywordMap</code>.
// * @param ignoreCase True if the keys are case insensitive
// * @param mapLength The number of `buckets' to create.
// * A value of 52 will give good performance for most maps.
// */
// public KeywordMap(boolean ignoreCase, int mapLength) {
// this.mapLength = mapLength;
// this.ignoreCase = ignoreCase;
// map = new Keyword[mapLength];
// }
/**
* Looks up a key.
* @param text The text segment
* @param offset The offset of the substring within the text segment
* @param length The length of the substring
*/
public byte lookup(Segment text, int offset, int length, boolean paren) {
if (length == 0) {
return Token.NULL;
}
int key = getSegmentMapKey(text, offset, length);
Keyword k = paren ? parenMap[key] : literalMap[key];
while (k != null) {
// if (length != k.keyword.length) {
// k = k.next;
// continue;
// }
if (length == k.keyword.length) {
if (regionMatches(ignoreCase, text, offset, k.keyword)) {
return k.id;
}
}
k = k.next;
}
return Token.NULL;
}
/**
* Checks if a subregion of a <code>Segment</code> is equal to a
* character array.
* @param ignoreCase True if case should be ignored, false otherwise
* @param text The segment
* @param offset The offset into the segment
* @param match The character array to match
*/
static public boolean regionMatches(boolean ignoreCase, Segment text,
int offset, char[] match) {
int length = offset + match.length;
char[] textArray = text.array;
if (length > text.offset + text.count) {
return false;
}
for (int i = offset, j = 0; i < length; i++, j++) {
char c1 = textArray[i];
char c2 = match[j];
if (ignoreCase) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
}
if (c1 != c2) {
return false;
}
}
return true;
}
/**
* Adds a key-value mapping.
* @param keyword The key
* @param id The value
*/
public void add(String keyword, byte id, boolean paren) {
int key = getStringMapKey(keyword);
Keyword[] map = paren ? parenMap : literalMap;
map[key] = new Keyword(keyword.toCharArray(), id, map[key]);
}
/**
* Returns true if the keyword map is set to be case insensitive,
* false otherwise.
*/
public boolean getIgnoreCase() {
return ignoreCase;
}
/**
* Sets if the keyword map should be case insensitive.
* @param ignoreCase True if the keyword map should be case
* insensitive, false otherwise
*/
public void setIgnoreCase(boolean ignoreCase) {
this.ignoreCase = ignoreCase;
}
protected int getStringMapKey(String s) {
return (Character.toUpperCase(s.charAt(0)) +
Character.toUpperCase(s.charAt(s.length()-1)))
% MAP_LENGTH;
}
protected int getSegmentMapKey(Segment s, int off, int len) {
return (Character.toUpperCase(s.array[off]) +
Character.toUpperCase(s.array[off + len - 1]))
% MAP_LENGTH;
}
// private members
private static class Keyword {
public final char[] keyword;
public final byte id;
public final Keyword next;
public Keyword(char[] keyword, byte id, Keyword next) {
this.keyword = keyword;
this.id = id;
this.next = next;
}
}
}