Skip to content

Commit bcf8c6e

Browse files
Johni0702Johni0702
committed
Make some of the lorenz utils and convertSource publicly accessible
1 parent 4af749d commit bcf8c6e

File tree

2 files changed

+155
-151
lines changed

2 files changed

+155
-151
lines changed

‎src/main/kotlin/com/replaymod/gradle/preprocess/MappingUtils.kt‎

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
package com.replaymod.gradle.preprocess
2+
3+
import org.cadixdev.lorenz.MappingSet
4+
import org.cadixdev.lorenz.io.MappingFormats
5+
import org.cadixdev.lorenz.model.ClassMapping
6+
import org.cadixdev.lorenz.model.InnerClassMapping
7+
import org.cadixdev.lorenz.model.TopLevelClassMapping
8+
import java.io.File
9+
10+
fun File.readMappings(): MappingSet {
11+
val ext = name.substring(name.lastIndexOf(".") + 1)
12+
val format = MappingFormats.REGISTRY.values().find { it.standardFileExtension.orElse(null) == ext }
13+
?: throw UnsupportedOperationException("Cannot find mapping format for $this")
14+
return format.read(toPath())
15+
}
16+
17+
// SRG doesn't track class names, so we need to inject our manual mappings which do contain them
18+
// However, our manual mappings also contain certain manual mappings in MCP names which need to be
19+
// applied before transitioning to SRG names (i.e. not where class mappings need to be applied).
20+
// As such, we need to split our class mappings off from the rest of the manual mappings.
21+
fun MappingSet.splitOffClassMappings(): MappingSet {
22+
val clsMap = MappingSet.create()
23+
for (cls in topLevelClassMappings) {
24+
val clsOnly = clsMap.getOrCreateTopLevelClassMapping(cls.obfuscatedName)
25+
clsOnly.deobfuscatedName = cls.deobfuscatedName
26+
cls.deobfuscatedName = cls.obfuscatedName
27+
for (inner in cls.innerClassMappings) {
28+
inner.splitOffInnerClassMappings(clsOnly.getOrCreateInnerClassMapping(inner.obfuscatedName))
29+
}
30+
}
31+
return clsMap
32+
}
33+
34+
fun InnerClassMapping.splitOffInnerClassMappings(to: InnerClassMapping) {
35+
to.deobfuscatedName = deobfuscatedName
36+
deobfuscatedName = obfuscatedName
37+
for (inner in innerClassMappings) {
38+
inner.splitOffInnerClassMappings(to.getOrCreateInnerClassMapping(inner.obfuscatedName))
39+
}
40+
}
41+
42+
// Like a.merge(b) except that mappings in b which do not exist in a at all will nevertheless be preserved.
43+
fun MappingSet.mergeBoth(b: MappingSet, into: MappingSet = MappingSet.create()): MappingSet {
44+
topLevelClassMappings.forEach { aClass ->
45+
val bClass = b.getTopLevelClassMapping(aClass.deobfuscatedName).orElse(null)
46+
if (bClass != null) {
47+
val merged = into.getOrCreateTopLevelClassMapping(aClass.obfuscatedName)
48+
merged.deobfuscatedName = bClass.deobfuscatedName
49+
aClass.mergeBoth(bClass, merged)
50+
} else {
51+
aClass.copy(into)
52+
}
53+
}
54+
b.topLevelClassMappings.forEach {
55+
if (!topLevelClassMappings.any { c -> c.deobfuscatedName == it.obfuscatedName }) {
56+
it.copy(into)
57+
}
58+
}
59+
return into
60+
}
61+
62+
fun <T : ClassMapping<T, *>> ClassMapping<T, *>.mergeBoth(b: ClassMapping<T, *>, merged: ClassMapping<T, *>) {
63+
fieldMappings.forEach {
64+
val bField = b.getFieldMapping(it.deobfuscatedName).orElse(null)
65+
if (bField != null) {
66+
it.merge(bField, merged)
67+
} else {
68+
it.copy(merged)
69+
}
70+
}
71+
b.fieldMappings.forEach {
72+
if (!fieldMappings.any { c -> c.deobfuscatedSignature == it.signature }) {
73+
it.copy(merged)
74+
}
75+
}
76+
methodMappings.forEach {
77+
val bMethod = b.getMethodMapping(it.deobfuscatedSignature).orElse(null)
78+
if (bMethod != null) {
79+
it.merge(bMethod, merged)
80+
} else {
81+
it.copy(merged)
82+
}
83+
}
84+
b.methodMappings.forEach {
85+
if (!methodMappings.any { c -> c.deobfuscatedSignature == it.signature }) {
86+
it.copy(merged)
87+
}
88+
}
89+
innerClassMappings.forEach { aClass ->
90+
val bClass = b.getInnerClassMapping(aClass.deobfuscatedName).orElse(null)
91+
if (bClass != null) {
92+
val mergedInner = merged.getOrCreateInnerClassMapping(obfuscatedName)
93+
mergedInner.deobfuscatedName = bClass.deobfuscatedName
94+
aClass.merge(bClass, mergedInner)
95+
} else {
96+
aClass.copy(merged)
97+
}
98+
}
99+
b.innerClassMappings.forEach {
100+
if (!innerClassMappings.any { c -> c.deobfuscatedName == it.obfuscatedName }) {
101+
it.copy(merged)
102+
}
103+
}
104+
}
105+
106+
// Like a.merge(b) except that mappings not in b will not be in the result (even if they're in a)
107+
fun MappingSet.join(b: MappingSet, into: MappingSet = MappingSet.create()): MappingSet {
108+
topLevelClassMappings.forEach { classA ->
109+
b.getTopLevelClassMapping(classA.deobfuscatedName).ifPresent { classB ->
110+
classA.join(classB, into)
111+
}
112+
}
113+
return into
114+
}
115+
116+
fun TopLevelClassMapping.join(b: TopLevelClassMapping, into: MappingSet) {
117+
val merged = into.getOrCreateTopLevelClassMapping(obfuscatedName)
118+
merged.deobfuscatedName = b.deobfuscatedName
119+
fieldMappings.forEach { fieldA ->
120+
b.getFieldMapping(fieldA.deobfuscatedSignature).ifPresent { fieldB ->
121+
fieldA.merge(fieldB, merged)
122+
}
123+
}
124+
methodMappings.forEach { methodA ->
125+
b.getMethodMapping(methodA.deobfuscatedSignature).ifPresent { methodB ->
126+
methodA.merge(methodB, merged)
127+
}
128+
}
129+
innerClassMappings.forEach { classA ->
130+
b.getInnerClassMapping(classA.deobfuscatedName).ifPresent { classB ->
131+
classA.join(classB, merged)
132+
}
133+
}
134+
}
135+
136+
fun InnerClassMapping.join(b: InnerClassMapping, into: ClassMapping<*, *>) {
137+
val merged = into.getOrCreateInnerClassMapping(obfuscatedName)
138+
merged.deobfuscatedName = b.deobfuscatedName
139+
fieldMappings.forEach { fieldA ->
140+
b.getFieldMapping(fieldA.deobfuscatedSignature).ifPresent { fieldB ->
141+
fieldA.merge(fieldB, merged)
142+
}
143+
}
144+
methodMappings.forEach { methodA ->
145+
b.getMethodMapping(methodA.deobfuscatedSignature).ifPresent { methodB ->
146+
methodA.merge(methodB, merged)
147+
}
148+
}
149+
innerClassMappings.forEach { classA ->
150+
b.getInnerClassMapping(classA.deobfuscatedName).ifPresent { classB ->
151+
classA.join(classB, merged)
152+
}
153+
}
154+
}

‎src/main/kotlin/com/replaymod/gradle/preprocess/PreprocessTask.kt‎

Lines changed: 1 addition & 151 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,6 @@ import com.replaymod.gradle.remap.Transformer
44
import com.replaymod.gradle.remap.legacy.LegacyMapping
55
import com.replaymod.gradle.remap.legacy.LegacyMappingSetModelFactory
66
import org.cadixdev.lorenz.MappingSet
7-
import org.cadixdev.lorenz.io.MappingFormats
8-
import org.cadixdev.lorenz.model.ClassMapping
9-
import org.cadixdev.lorenz.model.InnerClassMapping
10-
import org.cadixdev.lorenz.model.TopLevelClassMapping
117
import org.gradle.api.DefaultTask
128
import org.gradle.api.file.FileCollection
139
import org.gradle.api.tasks.*
@@ -119,152 +115,6 @@ open class PreprocessTask : DefaultTask() {
119115
keywords[extension] = map
120116
}
121117

122-
private fun File.readMappings(): MappingSet {
123-
val ext = name.substring(name.lastIndexOf(".") + 1)
124-
val format = MappingFormats.REGISTRY.values().find { it.standardFileExtension.orElse(null) == ext }
125-
?: throw UnsupportedOperationException("Cannot find mapping format for $this")
126-
return format.read(toPath())
127-
}
128-
129-
// SRG doesn't track class names, so we need to inject our manual mappings which do contain them
130-
// However, our manual mappings also contain certain manual mappings in MCP names which need to be
131-
// applied before transitioning to SRG names (i.e. not where class mappings need to be applied).
132-
// As such, we need to split our class mappings off from the rest of the manual mappings.
133-
private fun MappingSet.splitOffClassMappings(): MappingSet {
134-
val clsMap = MappingSet.create()
135-
for (cls in topLevelClassMappings) {
136-
val clsOnly = clsMap.getOrCreateTopLevelClassMapping(cls.obfuscatedName)
137-
clsOnly.deobfuscatedName = cls.deobfuscatedName
138-
cls.deobfuscatedName = cls.obfuscatedName
139-
for (inner in cls.innerClassMappings) {
140-
inner.splitOffInnerClassMappings(clsOnly.getOrCreateInnerClassMapping(inner.obfuscatedName))
141-
}
142-
}
143-
return clsMap
144-
}
145-
146-
private fun InnerClassMapping.splitOffInnerClassMappings(to: InnerClassMapping) {
147-
to.deobfuscatedName = deobfuscatedName
148-
deobfuscatedName = obfuscatedName
149-
for (inner in innerClassMappings) {
150-
inner.splitOffInnerClassMappings(to.getOrCreateInnerClassMapping(inner.obfuscatedName))
151-
}
152-
}
153-
154-
// Like a.merge(b) except that mappings in b which do not exist in a at all will nevertheless be preserved.
155-
private fun MappingSet.mergeBoth(b: MappingSet, into: MappingSet = MappingSet.create()): MappingSet {
156-
topLevelClassMappings.forEach { aClass ->
157-
val bClass = b.getTopLevelClassMapping(aClass.deobfuscatedName).orElse(null)
158-
if (bClass != null) {
159-
val merged = into.getOrCreateTopLevelClassMapping(aClass.obfuscatedName)
160-
merged.deobfuscatedName = bClass.deobfuscatedName
161-
aClass.mergeBoth(bClass, merged)
162-
} else {
163-
aClass.copy(into)
164-
}
165-
}
166-
b.topLevelClassMappings.forEach {
167-
if (!topLevelClassMappings.any { c -> c.deobfuscatedName == it.obfuscatedName }) {
168-
it.copy(into)
169-
}
170-
}
171-
return into
172-
}
173-
174-
private fun <T : ClassMapping<T, *>> ClassMapping<T, *>.mergeBoth(b: ClassMapping<T, *>, merged: ClassMapping<T, *>) {
175-
fieldMappings.forEach {
176-
val bField = b.getFieldMapping(it.deobfuscatedName).orElse(null)
177-
if (bField != null) {
178-
it.merge(bField, merged)
179-
} else {
180-
it.copy(merged)
181-
}
182-
}
183-
b.fieldMappings.forEach {
184-
if (!fieldMappings.any { c -> c.deobfuscatedSignature == it.signature }) {
185-
it.copy(merged)
186-
}
187-
}
188-
methodMappings.forEach {
189-
val bMethod = b.getMethodMapping(it.deobfuscatedSignature).orElse(null)
190-
if (bMethod != null) {
191-
it.merge(bMethod, merged)
192-
} else {
193-
it.copy(merged)
194-
}
195-
}
196-
b.methodMappings.forEach {
197-
if (!methodMappings.any { c -> c.deobfuscatedSignature == it.signature }) {
198-
it.copy(merged)
199-
}
200-
}
201-
innerClassMappings.forEach { aClass ->
202-
val bClass = b.getInnerClassMapping(aClass.deobfuscatedName).orElse(null)
203-
if (bClass != null) {
204-
val mergedInner = merged.getOrCreateInnerClassMapping(obfuscatedName)
205-
mergedInner.deobfuscatedName = bClass.deobfuscatedName
206-
aClass.merge(bClass, mergedInner)
207-
} else {
208-
aClass.copy(merged)
209-
}
210-
}
211-
b.innerClassMappings.forEach {
212-
if (!innerClassMappings.any { c -> c.deobfuscatedName == it.obfuscatedName }) {
213-
it.copy(merged)
214-
}
215-
}
216-
}
217-
218-
// Like a.merge(b) except that mappings not in b will not be in the result (even if they're in a)
219-
private fun MappingSet.join(b: MappingSet, into: MappingSet = MappingSet.create()): MappingSet {
220-
topLevelClassMappings.forEach { classA ->
221-
b.getTopLevelClassMapping(classA.deobfuscatedName).ifPresent { classB ->
222-
classA.join(classB, into)
223-
}
224-
}
225-
return into
226-
}
227-
228-
private fun TopLevelClassMapping.join(b: TopLevelClassMapping, into: MappingSet) {
229-
val merged = into.getOrCreateTopLevelClassMapping(obfuscatedName)
230-
merged.deobfuscatedName = b.deobfuscatedName
231-
fieldMappings.forEach { fieldA ->
232-
b.getFieldMapping(fieldA.deobfuscatedSignature).ifPresent { fieldB ->
233-
fieldA.merge(fieldB, merged)
234-
}
235-
}
236-
methodMappings.forEach { methodA ->
237-
b.getMethodMapping(methodA.deobfuscatedSignature).ifPresent { methodB ->
238-
methodA.merge(methodB, merged)
239-
}
240-
}
241-
innerClassMappings.forEach { classA ->
242-
b.getInnerClassMapping(classA.deobfuscatedName).ifPresent { classB ->
243-
classA.join(classB, merged)
244-
}
245-
}
246-
}
247-
248-
private fun InnerClassMapping.join(b: InnerClassMapping, into: ClassMapping<*, *>) {
249-
val merged = into.getOrCreateInnerClassMapping(obfuscatedName)
250-
merged.deobfuscatedName = b.deobfuscatedName
251-
fieldMappings.forEach { fieldA ->
252-
b.getFieldMapping(fieldA.deobfuscatedSignature).ifPresent { fieldB ->
253-
fieldA.merge(fieldB, merged)
254-
}
255-
}
256-
methodMappings.forEach { methodA ->
257-
b.getMethodMapping(methodA.deobfuscatedSignature).ifPresent { methodB ->
258-
methodA.merge(methodB, merged)
259-
}
260-
}
261-
innerClassMappings.forEach { classA ->
262-
b.getInnerClassMapping(classA.deobfuscatedName).ifPresent { classB ->
263-
classA.join(classB, merged)
264-
}
265-
}
266-
}
267-
268118
@TaskAction
269119
fun preprocess() {
270120
val source = source!!
@@ -369,7 +219,7 @@ class CommentPreprocessor(private val vars: Map<String, Int>) {
369219
private val String.indentation: Int
370220
get() = takeWhile { it == ' ' }.length
371221

372-
private fun convertSource(kws: Keywords, lines: List<String>, remapped: List<String>, fileName: String): List<String> {
222+
fun convertSource(kws: Keywords, lines: List<String>, remapped: List<String>, fileName: String): List<String> {
373223
val ifStack = mutableListOf<Boolean>()
374224
val indentStack = mutableListOf<Int>()
375225
var active = true

0 commit comments

Comments
 (0)