FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
processing/app/src/processing/app/syntax/KeywordMap.java at master · orgicus/processing · GitHub
orgicus
processing
Repository navigation
Code
Pull requests
Actions
Projects
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
processing
/
app
/
src
/
processing
/
app
/
syntax
/
KeywordMap.java
Copy path
More file actions
More file actions
Latest commit
History
History
History
176 lines (151 loc) · 4.72 KB
Breadcrumbs
processing
/
app
/
src
/
processing
/
app
/
syntax
/
KeywordMap.java
Copy path
File metadata and controls
176 lines (151 loc) · 4.72 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
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
;
}
}
}
Back
|
FazBrowse Home
|
New Git URL