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
|
package cuchaz.enigma.mapping;
import com.google.common.collect.Queues;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Deque;
public class MappingsReaderOld {
public Mappings read(Reader in) throws IOException, MappingParseException {
return read(new BufferedReader(in));
}
public Mappings read(BufferedReader in) throws IOException, MappingParseException {
Mappings mappings = new Mappings();
Deque<Object> mappingStack = Queues.newArrayDeque();
int lineNumber = 0;
String line;
while ((line = in.readLine()) != null) {
lineNumber++;
// strip comments
int commentPos = line.indexOf('#');
if (commentPos >= 0) {
line = line.substring(0, commentPos);
}
// skip blank lines
if (line.trim().length() <= 0) {
continue;
}
// get the indent of this line
int indent = 0;
for (int i = 0; i < line.length(); i++) {
if (line.charAt(i) != '\t') {
break;
}
indent++;
}
// handle stack pops
while (indent < mappingStack.size()) {
mappingStack.pop();
}
String[] parts = line.trim().split("\\s");
try {
// read the first token
String token = parts[0];
if (token.equalsIgnoreCase("CLASS")) {
ClassMapping classMapping;
if (indent <= 0) {
// outer class
classMapping = readClass(parts, false);
mappings.addClassMapping(classMapping);
} else {
// inner class
if (!(mappingStack.peek() instanceof ClassMapping)) {
throw new MappingParseException(lineNumber, "Unexpected CLASS entry here!");
}
classMapping = readClass(parts, true);
((ClassMapping) mappingStack.peek()).addInnerClassMapping(classMapping);
}
mappingStack.push(classMapping);
} else if (token.equalsIgnoreCase("FIELD")) {
if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
throw new MappingParseException(lineNumber, "Unexpected FIELD entry here!");
}
((ClassMapping) mappingStack.peek()).addFieldMapping(readField(parts));
} else if (token.equalsIgnoreCase("METHOD")) {
if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
throw new MappingParseException(lineNumber, "Unexpected METHOD entry here!");
}
MethodMapping methodMapping = readMethod(parts);
((ClassMapping) mappingStack.peek()).addMethodMapping(methodMapping);
mappingStack.push(methodMapping);
} else if (token.equalsIgnoreCase("ARG")) {
if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof MethodMapping)) {
throw new MappingParseException(lineNumber, "Unexpected ARG entry here!");
}
((MethodMapping) mappingStack.peek()).addArgumentMapping(readArgument(parts));
}
} catch (ArrayIndexOutOfBoundsException | IllegalArgumentException ex) {
throw new MappingParseException(lineNumber, "Malformed line:\n" + line);
}
}
return mappings;
}
private ArgumentMapping readArgument(String[] parts) {
return new ArgumentMapping(Integer.parseInt(parts[1]), parts[2]);
}
private ClassMapping readClass(String[] parts, boolean makeSimple) {
if (parts.length == 2) {
return new ClassMapping(parts[1]);
} else {
return new ClassMapping(parts[1], parts[2]);
}
}
/* TEMP */
protected FieldMapping readField(String[] parts) {
return new FieldMapping(parts[1], new Type(parts[3]), parts[2]);
}
private MethodMapping readMethod(String[] parts) {
if (parts.length == 3) {
return new MethodMapping(parts[1], new Signature(parts[2]));
} else {
return new MethodMapping(parts[1], new Signature(parts[3]), parts[2]);
}
}
}
|
