zaaarf.foo

ZipDist

2025-08-19T17:30:00+01:00
I maintain my own Maven repository, to publish things that are not necessarily of general interest (or that do not follow standard Java naming conventions).
This plugin simplifies deployment of new versions: you use it to generate the relevant ZIP, and then you extract it in the root folder of your repository. Everything gets placed in the correct spot, or at least it should be.
You can find the source code here</a>.
jni-toolbox

2024-09-21T18:30:00+01:00
A Rust crate providing a proc-macro that will generate for you JNI-compatible extern</code> functions and a trait to "guide you" towards conversion logic between Rust and Java type.
Unlike many of its competitors, jni-toolbox</code> keeps it simple and does not implement any overly-complicated wrapper structures on top of the basic JNI types, nor does it try to use serde</code> to trade efficiency for simplicity.
You can follow development on the GitHub</a>.


codemp
2024-01-19T18:30:00+01:00

  
  
</div>

codemp</code> is a collaborative text editing solution to work remotely. It seamlessly integrates in your editor providing remote cursors and instant text synchronization, as well as a remote virtual workspace for you and your team.</p>
</blockquote>
...that's ripped verbatim from the project page, and it gives you a pretty good idea of what it's about. Leveraging diamond-types</code></a>' super-fast CRDT, we offer a solid Rust library for cooperative development, complete with a number of ready-to-use FFI bindings and even an open protocol.</p>
You can follow development on our GitHub</a> and take a look at our website</a> (nice snipe, eh?).</p>


A new home
2023-12-12T23:50:00+01:00
Hello there, my valued and likely imaginary reader! It's been a while. This is just a short one to state the obvious and let you know that I moved my blogposts from ftbsc</a> to this website of mine. It's better this way - the other website acts as an aggregator of our collective posts, which you can then read on our respective websites, where we can all be free from each other's questionable taste in web design.</p>
Static generators</h2>
Liking the new website? I think it's pretty cool, if I may say so myself. For my own website, I ditched hugo</a> in favour of zola</a>. Those are what we call static website generators: you write some Markdown and it spits out this sexy HTML blog page. They are near indistinguishable (with zola ripping off</del> taking inspiration</em> from the older hugo), but zola is generally faster (and I find its theme composition syntax to be a lot clearer). Also, zola is written in Rust whereas Hugo is written in Go, which means that if I ever need a missing feature there's a tiny possibility of me sitting down to write it.</p>
This theme is kind</em> of custom. Web design not being my strong suit, I relied on the work of people better at it than me. I've been editing off of the excellent anemone</a> theme, to add some custom features and especially to adapt some stuff from my favourite hugo theme: hello-friend-ng</a>. It took the better part of two days, but I managed to get my website to a usable state. Mobile version still sucked, and I couldn't get code blocks to scroll instead of break (solved thanks to this</a> article, by the way). Finishing the job took a few more days of tinkering and tweaking, but I'm pretty proud of the final result. Man, working with CSS and HTML was a horrid</em> experience. I pity those poor bastards that do this for a living.</p>
Over and out</h2>
That's it for this one. Maybe I don't always need to write kilometer-long blogposts, huh. Anyway, I hope I'll be writing more. It's not that I didn't want to, I just couldn't find stuff to post about! Not to say that I've been sitting on my ass - far from it. Since you last heard from me, I've become at least passable in Rust, and I've even worked with C++ (gasp</em>) for the first time since the university course I took on the topic. I must say, I've been pleasantly surprised.</p>
I digress. Have a good one, and hopefully you'll read some more stuff soon.</p>


GEB
2023-06-19T18:30:00+01:00
GEB is a Java event bus that relies on compile-time annotation processing to function, theoretically achieving maximum possible efficiency. The current version is pretty much just a proof of concept, and lacks thorough benchmarking and testing.</p>
Currently, GEB is made up of two components:</p>

The Library</a> (javadoc</a>)</li>
The Processor</a> (javadoc</a>)</li>
</ul>


To kill a boilerplate - a dev diary
2023-02-27T12:22:00+01:00

  
  
</div>

  
  
</div></p>
Introduction - the magical world of annotations</h2>
Ah, annotations. Truly, one of the most bizarre constructs Java has to offer. Not that they themselves are revolutionary as a concept. The way they are handled, though? Now that</em>'s insane... not in a good way. If you've done Java before, chances are you found yourself using weird reflection</a> magic you barely understood to get all the classes you annotated at runtime, all while feeling that there has to be a better way to do it, you're just doing it wrong. Alas, your instincts were tricking you: that's actually how you do it. But, enough about reflection. Let's get onto the topic of this article.</p>
Did you know that you can set something called RetentionPolicy</a> on your custom annotations? Now, what does that mean? Well, it means that you can make it so that your annotation does not last all the way to RUNTIME</code>, but can only be present in the SOURCE</code> or CLASS</code>! Isn't that something?</p>
Now, you may understandably be wondering what would even be the point of such a thing, considering that reflection is a runtime-only thing. How would you use those annotations, if they get dropped before your code even runs? Meet reflection handling's far less known brother: the Annotation Processor.</p>
An Annotation Processor is, in its simplest form, an implementation of the Processor</a> interface, loaded up as a service and fed all items annotated with one or more specific annotations. It gets loaded way early on, before compilation, when the rest of the code isn't actually executable yet, and all you can access is its Abstract Syntax Tree</a> representation. Crazy stuff.</p>
The catch? You can't actually edit the existing classes. You can analyze them, and even generate new ones, but touching the existing ones is not allowed. Wait, what? If you're familiar enough with Java, you may have heard of Project Lombok</a> and its crusade against boilerplate code. If an annotation processor can't edit the existing files, how do @Getter</code> and @Setter</code> work? For those that don't know, those are two annotations that, when placed on a field, instruct lombok to generate a getter and a setter, respectively, for that field. So, what gives?</p>
Well, the truth is, they are using a trick</a>. Which is really nothing to be ashamed about - it's entirely Java's fault that there isn't a more legitimate way to do it - but this approach may be a turnoff for some. Why do I even care about this fringe topic? Well...</p>
The problem</h3>
Remember my previous post</a>? It's quite the rant, but to give you a summary, it's basically about me struggling to create a way to efficiently do ASM patching in Minecraft Forge for 1.13 and above. The final result of my blood and tears are lillero</a> and its loader</a>. Basically, patches are registered as Java Services, implementing the IInjector</code> interface we created. As a solution, it's great, because it's elegant and uses no "dirty tricks" to accomplish this. But it also has its drawbacks, namely how tedious it is for the programmer.</p>
Let's take the example patch from the README.md</code>, for example:</p>
package</span> example.</span>patches</span></span></span>;</span>
</span>import</span> ftbsc</span></span>.</span>lll</span>.</span>IInjector</span></span></span>;</span>
</span>public</span> class</span> SamplePatch</span></span> implements</span> IInjector</span> </span>{</span>
</span></span></span></span>	public</span> String</span> name</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>SamplePatch"</span></span>;</span> }</span></span></span>
</span></span></span></span>	public</span> String</span> targetClass</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>net.minecraft.client.Minecraft"</span></span>;</span> }</span></span></span>
</span></span></span></span>	public</span> String</span> methodName</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>func_71407_l"</span></span>;</span> }</span></span></span> //</span> tick()
</span></span></span></span></span>	public</span> String</span> methodDesc</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>()V"</span></span>;</span> }</span></span></span> //</span> void, no params
</span></span></span></span></span>	public</span> void</span> inject</span></span>(</span>ClassNode</span> clazz</span>,</span> MethodNode</span> main</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		InsnList</span> insnList =</span> new</span> InsnList</span>(</span>)</span></span></span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		main.</span>instructions.</span>insert</span>(</span>insnList)</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
Three lines of actual patching, rest is boilerplate. Having to manually look up SRG names</a> is horrible, manually registering the patch is a hassle, and even if my DescriptorBuilder</code></a> makes generating method descriptors easier, it also makes it considerably more verbose.</p>
Despite these considerable drawbacks, we carried on, because we had an idea: annotations to automate this stuff. We figured that we were not the first ones: as usual, fr1kin's ForgeHax</a> predated whatever we were coming up with. And, once again, implemented it in a completely different way. I can't say I went too deep into the code, but it would seem that fr1kin hooked his own processor into Lombok, rather than making it standalone, letting it do the heavy lifting. Clever, but lazy.</p>
His solution did the trick, but it would've meant bringing lombok into the project. Yeah, I know it doesn't actually get compiled in, but I didn't really want to import a whole suite just for a single use. Instead, I went to work on my own solution.</p>
The story</h2>
My first idea was to do whatever Lombok was doing, on my own. Couldn't be too hard, right? Wrong.</p>
First off, Lombok is based on the so-called tools.jar</code>, an internal JVM API that wasn't really meant for public use. And, while there are Javadocs for it, figuring out how they worked wasn't easy at all. Secondly, apparently Lombok goes in very deep, hooking into Javac itself. That wasn't exactly something I was ready to face quite yet, especially considering the lack of online examples, articles and tutorials on the subject. I resolved to come back to it as the very last option, but luckily I didn't have to.</p>
I tried a different approach. Maybe I couldn't edit classes, but I apparently could generate new ones. Why, that's all I need! At first, I was counting on figuring out a way to print a new version of the class and discard the old one, but eventually I figured out that there was no need. Together with a friend, we outlined how my processor could act in theory. The results were pretty interesting.</p>
Remember the example from earlier? Here is how it would look in the new system:</p>
package</span> example.</span>patches</span></span></span>;</span>
</span>import</span> ftbsc</span></span>.</span>lll</span>.</span>processor</span>.</span></span>*</span></span></span>;</span>
</span>import</span> net</span></span>.</span>minecraft</span>.</span>client</span>.</span>Minecraft</span></span></span>;</span>
</span>@</span></span>Patch</span></span>(</span>Minecraft</span>.</span>class</span>)</span></span></span>
</span>public</span> abstract</span> class</span> SamplePatch</span></span> {</span>
</span></span></span></span>	@</span></span>Target</span>
</span></span></span></span></span></span>	</span></span>public</span> abstract</span> void</span> tick</span></span>(</span>)</span></span></span></span>;</span>
</span></span></span></span>	@</span></span>Injector</span>
</span></span></span></span></span></span>	</span></span>public</span> static</span> void</span> anyNameWorks</span></span>(</span>ClassNode</span> clazz</span>,</span> MethodNode</span> main</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		InsnList</span> insnList =</span> new</span> InsnList</span>(</span>)</span></span></span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		main.</span>instructions.</span>insert</span>(</span>insnList)</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
That's a LOT</em> better, isn't it? I'll explain now, but I'll preface by saying that the class being abstract isn't really a requirement, it's just so the method stub doesnt have two empty brackets.</p>
For starters, it's important to note that all those three annotations do not</em> make it to RUNTIME</code>. Therefore, calling Minecraft.class</code> in there is perfectly legal, because that reference won't exist anymore when the class is actually loaded. And imports don't actually exist in bytecode, so that won't be a problem either.</p>
Anyway, my objective was to make a processor that, from that, could create a second class called SamplePatchInjector</code>, in the same package, looking like this:</p>
package</span> example.</span>patches</span></span></span>;</span>
</span>import</span> ftbsc</span></span>.</span>lll</span>.</span>IInjector</span></span></span>;</span>
</span>public</span> class</span> SamplePatchInjector</span></span> implements</span> IInjector</span> </span>{</span>
</span></span></span></span>	public</span> String</span> name</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>SamplePatch"</span></span>;</span> }</span></span></span>
</span></span></span></span>	public</span> String</span> targetClass</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>net.minecraft.client.Minecraft"</span></span>;</span> }</span></span></span>
</span></span></span></span>	public</span> String</span> methodName</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>func_71407_l"</span></span>;</span> }</span></span></span> //</span> tick()
</span></span></span></span></span>	public</span> String</span> methodDesc</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> new</span> DescriptorBuilder</span>(</span>)</span></span></span>.</span>setReturnType</span>(</span>void.</span>class</span>)</span></span>.</span>build</span>(</span>)</span></span>;</span> }</span></span></span>
</span></span></span></span>	public</span> void</span> inject</span></span>(</span>ClassNode</span> clazz</span>,</span> MethodNode</span> main</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		SamplePatch</span>.</span>anyNameWorks</span>(</span>clazz,</span> main)</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
The return value for the method name()</code> is the extrapolated from the name of the old class, the targetClass() is extrapolated from the class given as value for @Patch</code>. Optionally, @Injector</code> can also contain a reason, a string that is printed in the console on injection explaining what the patch does.</p>
methodName()</code> is just the name of the method annotated with @Target</code>, and the descriptor for methodDesc()</code> is also extrapolated from it. Finally, the @Injector annotation can be used on any static void method that takes in a ClassNode and a MethodNode, and that's the one that will be called to actually apply the patch.</p>
It's also implied that a service provider (i.e. META-INF/services/ftbsc.lll.IInjector</code>) will be made for every IInjector class generated this way. Now that I had a solid idea of how I wanted it to act, it was time to figure out the actual implementation.</p>
Writing an annotation processor</h3>
The only in-depth guide about generating classes through an annotation processor I could find was a Baeldung article</a>. It's really not great, but it was the basis for my work, so props to them I guess. I implemented the Processor</code> interface (rather, I extended the AbstractProcessor</code> class which implemented it), made the service provider (META-INF/services/javax.annotation.processing.Processor</code>), and sketched our core, the process(Set<? extends TypeElement>, RoundEnvironment)</code> method:</p>
@</span></span>SupportedAnnotationTypes</span></span>(</span>"</span>ftbsc.lll.processor.annotations.Patch"</span></span>)</span></span></span>
</span>@</span></span>SupportedSourceVersion</span></span>(</span>SourceVersion</span>.</span>RELEASE_8</span>)</span></span></span>
</span>public</span> class</span> LilleroProcessor</span></span> extends</span> AbstractProcessor</span> </span>{</span>
</span></span></span></span>	@</span></span>Override</span>
</span></span></span></span></span></span>	</span></span>public</span> boolean</span> process</span></span>(</span>Set</span><</span>?</span> extends</span> TypeElement</span>></span></span> annotations</span>,</span> RoundEnvironment</span> roundEnv</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		for</span> (</span>TypeElement</span> annotation :</span> annotations)</span></span> {</span>
</span></span></span></span></span></span></span>			if</span>(</span>annotation.</span>getQualifiedName</span>(</span>)</span></span>.</span>toString</span>(</span>)</span></span>.</span>equals</span>(</span>Patch</span>.</span>class</span>.</span>getName</span>(</span>)</span></span>)</span></span>)</span></span> {</span>
</span></span></span></span></span></span></span></span>				Set</span><</span>TypeElement</span>></span></span> validInjectors =</span>
</span></span></span></span></span></span></span></span></span>					roundEnv.</span>getElementsAnnotatedWith</span>(</span>annotation)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>stream</span>(</span>)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>map</span>(</span>e</span></span> -></span> (</span>TypeElement</span>)</span></span> e</span>)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>filter</span>(</span>this</span>::</span>isValidInjector</span>)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>collect</span>(</span>Collectors</span>.</span>toSet</span>(</span>)</span></span>)</span></span></span>;</span>
</span></span></span></span></span></span></span></span>				if</span>(</span>!</span>validInjectors.</span>isEmpty</span>(</span>)</span></span>)</span></span> {</span>
</span></span></span></span></span></span></span></span></span>					//</span>do stuff
</span></span></span></span></span></span></span></span></span></span>				}</span></span>
</span></span></span></span></span></span></span></span>			}</span></span>
</span></span></span></span></span></span></span>		}</span></span>
</span></span></span></span></span></span>		return</span> false</span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
For the sake of clarity and of my own dignity, we'll pretend like I knew all along that annotations</code> referred to the annotations themselves, and not to the annotated classes. I totally didn't change that near the end because I'd completely misunderstood.</p>
Now, let's unpack what happens here. The annotations on the class itself say which source version can we work with - we want Java 8, since Minecraft 1.16 is still on that - and which annotation(s) we want to process.</p>
We get every annotated class that is passed to our method, and check if it's of the Patch</code> type. This is actually useless, since this processor only has one type of annotation, but I figured it wouldn't hurt. Call it future-proofing, I guess. Anyway, what I'm doing is checking that the user annotated everything properly, which isn't a given at all. That's the job of the isValidInjector(TypeElement)</code> method:</p>
private</span> boolean</span> isValidInjector</span>(</span>TypeElement</span> elem)</span></span> {</span>
</span></span>	TypeMirror</span> classNodeType =</span> processingEnv.</span>getElementUtils</span>(</span>)</span></span>.</span>getTypeElement</span>(</span>"</span>org.objectweb.asm.tree.ClassNode"</span></span>)</span></span>.</span>asType</span>(</span>)</span></span></span>;</span>
</span></span>	TypeMirror</span> methodNodeType =</span> processingEnv.</span>getElementUtils</span>(</span>)</span></span>.</span>getTypeElement</span>(</span>"</span>org.objectweb.asm.tree.MethodNode"</span></span>)</span></span>.</span>asType</span>(</span>)</span></span></span>;</span>
</span></span>	if</span> (</span>
</span></span></span>		elem.</span>getEnclosedElements</span>(</span>)</span></span>.</span>stream</span>(</span>)</span></span>.</span>anyMatch</span>(</span>e</span></span> -></span> e.</span>getAnnotation</span>(</span>Target</span>.</span>class</span>)</span></span> !=</span> null</span></span>)</span></span>
</span></span></span>			&&</span> elem.</span>getEnclosedElements</span>(</span>)</span></span>.</span>stream</span>(</span>)</span></span>.</span>anyMatch</span>(</span>e</span></span> -></span> {</span>
</span></span></span></span></span></span>				List</span><</span>?</span> extends</span> TypeMirror</span>></span></span> params =</span> (</span>(</span>ExecutableType</span>)</span></span> e.</span>asType</span>(</span>)</span></span>)</span></span>.</span>getParameterTypes</span>(</span>)</span></span></span>;</span>
</span></span></span></span></span></span>				return</span> e.</span>getAnnotation</span>(</span>Injector</span>.</span>class</span>)</span></span> !=</span> null</span>
</span></span></span></span></span></span>					&&</span> e.</span>getAnnotation</span>(</span>Target</span>.</span>class</span>)</span></span> ==</span> null</span>
</span></span></span></span></span></span>					&&</span> e.</span>getModifiers</span>(</span>)</span></span>.</span>contains</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span></span></span></span>					&&</span> e.</span>getModifiers</span>(</span>)</span></span>.</span>contains</span>(</span>Modifier</span>.</span>STATIC</span>)</span></span>
</span></span></span></span></span></span>					&&</span> params.</span>size</span>(</span>)</span></span> ==</span> 2</span>
</span></span></span></span></span></span>					&&</span> processingEnv.</span>getTypeUtils</span>(</span>)</span></span>.</span>isSameType</span>(</span>params.</span>get</span>(</span>0</span>)</span></span>,</span> classNodeType)</span></span>
</span></span></span></span></span></span>					&&</span> processingEnv.</span>getTypeUtils</span>(</span>)</span></span>.</span>isSameType</span>(</span>params.</span>get</span>(</span>1</span>)</span></span>,</span> methodNodeType)</span></span>;</span>
</span></span></span></span></span></span>			}</span></span>
</span></span></span></span></span>		</span>)</span></span>
</span></span></span>	)</span></span> return</span> true</span>;</span>
</span></span>
</span></span>	processingEnv.</span>getMessager</span>(</span>)</span></span>.</span>printMessage</span>(</span>
</span></span></span>		Diagnostic</span>.</span>Kind</span>.</span>WARNING</span>,</span>
</span></span></span>		"</span>Missing valid @Injector method in @Patch class "</span></span> +</span> elem +</span> "</span>, skipping."</span></span>
</span></span></span>	)</span></span>;</span>
</span></span>	return</span> false</span>;</span>
</span></span>}</span></span>
</span></code></pre>
It MAY seem complicated, but it really isn't. The TypeMirror are AST representations of the ClassNode</code> and MethodNode</code> classes from ObjectWeb's ASM library, which Lillero uses for patching. Basically, we're checking that within the given class there is one method annotated with @Target</code>, and one method annotated with @Injector</code> which is not annotated with @Target</code>, is public static</code> and has two parameters, which must be ClassNode</code> and MethodNode</code>, in this order. I also make it a point to warn the user when an invalid injector is declared, at the cost of making the code look fugly.</p>
Every injector who passes this test is put into validInjectors</code>, a Set. Well, finally we got them... what now? I figured I'd start from the actual class generation, which seemed like the hardest part. And thus, I added a validInjectors.forEach(this::generateInjector);</code>...</p>
...aaand I had no clue of what to write in that method.</p>
Class generation</h3>
Baledung's guide made it look like a daunting task: they wrote the entire class, indentation included, line by line. That seems like a recipe for insanity, if you ask me. And, as I was looking for more examples, I found JavaPoet</a>. It generates code in a simple and elegant way: just what I needed! It also turned out to be extremely lightweight (ten or so classes), which is a plus, even if it wouldn't get compiled in regardless.</p>
Alright, now we have a simple API for writing. What's next? I suppose the first thing would have to be getting the values from our annotation, right?</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	Patch</span> ann =</span> cl.</span>getAnnotation</span>(</span>Patch</span>.</span>class</span>)</span></span></span>;</span>
</span></span>	Class</span><</span>?</span>></span></span> clazz =</span> ann.</span>value</span>(</span>)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
There. That easy, huh? Well... not really. While looking for something else, I stumbled by pure coincidence on a pretty good blogpost</a> explaining that there can be problems in extracting a Class</code> object from your annotation. Which sucks, since that was my design. On the upside, he does provide a neat trick to at least get the fully qualified name, which is really all I need from the class object. Shoutout to him for writing a good article, even if he is completely incapable of properly formatting his code.</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	Patch</span> ann =</span> cl.</span>getAnnotation</span>(</span>Patch</span>.</span>class</span>)</span></span></span>;</span>
</span></span>	String</span> targetClassCanonicalName;</span>
</span></span>	try</span> {</span>
</span></span></span>		targetClassCanonicalName =</span> ann.</span>value</span>(</span>)</span></span>.</span>getCanonicalName</span>(</span>)</span></span></span>;</span>
</span></span></span>	}</span></span> catch</span></span>(</span>MirroredTypeException</span> e</span>)</span></span></span> {</span>
</span></span></span>		targetClassCanonicalName =</span> e.</span>getTypeMirror</span>(</span>)</span></span>.</span>toString</span>(</span>)</span></span></span>;</span>
</span></span></span>	}</span></span>
</span></span>}</span></span>
</span></code></pre>
Go read the article if you want to know why or how: it'd be pointless to repeat it here.</p>
The next thing probably has to be getting a representation of the two annotated methods. My first approach was to do it by generating two dummy MethodSpec</code>s (from JavaPoet), but it turned out to be as broken as it was janky. In the end, I settled for the much more sober (and built-in) ExecutableElement</code>. The following code should be pretty self-explanatory:</p>
@</span></span>SuppressWarnings</span></span>(</span>"</span>OptionalGetWithoutIsPresent"</span></span>)</span></span></span>
</span>private</span> static</span> ExecutableElement</span> findAnnotatedMethod</span>(</span>TypeElement</span> cl,</span> Class</span><</span>?</span> extends</span> Annotation</span>></span></span> ann)</span></span> {</span>
</span></span>	return</span> (</span>ExecutableElement</span>)</span></span> cl.</span>getEnclosedElements</span>(</span>)</span></span>
</span></span>		.</span>stream</span>(</span>)</span></span>
</span></span>		.</span>filter</span>(</span>e</span></span> -></span> e.</span>getAnnotation</span>(</span>ann)</span></span> !=</span> null</span></span>)</span></span>
</span></span>		.</span>findFirst</span>(</span>)</span></span>
</span></span>		.</span>get</span>(</span>)</span></span>;</span> //</span>will never be null so can ignore warning
</span></span></span>}</span></span>
</span>
</span>private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	ExecutableElement</span> targetMethod =</span> findAnnotatedMethod</span>(</span>cl,</span> Target</span>.</span>class</span>)</span></span></span>;</span>
</span></span>	ExecutableElement</span> injectorMethod =</span> findAnnotatedMethod</span>(</span>cl,</span> Injector</span>.</span>class</span>)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
It'll never be null because we already know from isValidInjector(TypeElement)</code> that those methods exist, so they can't be null. Now, this is as good a time as ever to build the names for our generated classes. I did it like this:</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	Element</span> packageElement =</span> cl.</span>getEnclosingElement</span>(</span>)</span></span></span>;</span>
</span></span>	while</span> (</span>packageElement.</span>getKind</span>(</span>)</span></span> !=</span> ElementKind</span>.</span>PACKAGE</span>)</span></span>
</span></span>		packageElement =</span> packageElement.</span>getEnclosingElement</span>(</span>)</span></span></span>;</span>
</span></span>	String</span> packageName =</span> packageElement.</span>toString</span>(</span>)</span></span></span>;</span>
</span></span>	String</span> injectorSimpleClassName =</span> cl.</span>getSimpleName</span>(</span>)</span></span>.</span>toString</span>(</span>)</span></span> +</span> "</span>Injector"</span></span></span>;</span>
</span></span>	String</span> injectorClassName =</span> packageName +</span> "</span>."</span></span> +</span> injectorSimpleClassName</span>;</span>
</span></span>}</span></span>
</span></code></pre>
The while</code> loop ensures that we get to the package even if the patch is an inner class, regardless of how nested it is. It's important to note that packageElement.getQualifiedName()</code> would return the name of the class, rather than that of the package, for some stupid reason.</p>
Well, that's about all the preparation we could do, right? Time to actually get to using JavaPoet!</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>		MethodSpec</span> name =</span> MethodSpec</span>.</span>methodBuilder</span>(</span>"</span>name"</span></span>)</span></span>
</span></span></span>		.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span>		.</span>returns</span>(</span>String</span>.</span>class</span>)</span></span>
</span></span></span>		.</span>addStatement</span>(</span>"</span>return $S"</span></span>,</span> injectorSimpleClassName)</span></span>
</span></span></span>		.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>		MethodSpec</span> reason =</span> MethodSpec</span>.</span>methodBuilder</span>(</span>"</span>reason"</span></span>)</span></span>
</span></span></span>		.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span>		.</span>returns</span>(</span>String</span>.</span>class</span>)</span></span>
</span></span></span>		.</span>addStatement</span>(</span>"</span>return $S"</span></span>,</span> ann.</span>reason</span>(</span>)</span></span>)</span></span>
</span></span></span>		.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
Simple enough; JavaPoet takes care of the actual generation, placing of semicolons and all that. $S</code> is a String placeholder, telling JavaPoet to place quotation marks around the provided text. Now we get to the ugly part. The others aren't going to be that easy, since we need to generate stuff. For the descriptor generation, I had to write a method to handle that, once again:</p>
public</span> static</span> String</span> descriptorFromType</span>(</span>TypeMirror</span> t)</span></span> {</span>
</span></span>	TypeName</span> type =</span> TypeName</span>.</span>get</span>(</span>t)</span></span></span>;</span>
</span></span>	StringBuilder</span> desc =</span> new</span> StringBuilder</span>(</span>)</span></span></span></span>;</span>
</span></span>	//</span>add array brackets
</span></span></span>	while</span>(</span>type instanceof</span> ArrayTypeName</span>)</span></span> {</span>
</span></span></span>		desc.</span>append</span>(</span>"</span>["</span></span>)</span></span>;</span>
</span></span></span>		type =</span> (</span>(</span>ArrayTypeName</span>)</span></span> type)</span></span>.</span>componentType</span>;</span>
</span></span></span>	}</span></span>
</span></span>	if</span>(</span>type instanceof</span> ClassName</span>)</span></span> {</span>
</span></span></span>		ClassName</span> var</span> =</span> (</span>ClassName</span>)</span></span> type</span>;</span>
</span></span></span>		desc.</span>append</span>(</span>DescriptorBuilder</span>.</span>nameToDescriptor</span>(</span>var.</span>canonicalName</span>(</span>)</span></span>,</span> 0</span>)</span></span>)</span></span>;</span>
</span></span></span>	}</span></span> else</span> {</span>
</span></span></span>		if</span>(</span>TypeName</span>.</span>BOOLEAN</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>Z"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>CHAR</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>C"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>BYTE</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>B"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>SHORT</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>S"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>INT</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>I"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>FLOAT</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>F"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>LONG</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>J"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>DOUBLE</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>D"</span></span>)</span></span>;</span>
</span></span></span>		else</span> if</span>(</span>TypeName</span>.</span>VOID</span>.</span>equals</span>(</span>type)</span></span>)</span></span>
</span></span></span>			desc.</span>append</span>(</span>"</span>V"</span></span>)</span></span>;</span>
</span></span></span>	}</span></span>
</span></span>	return</span> desc.</span>toString</span>(</span>)</span></span>;</span>
</span></span>}</span></span>
</span>
</span>public</span> static</span> String</span> descriptorFromMethodSpec</span>(</span>ExecutableElement</span> m)</span></span> {</span>
</span></span>	StringBuilder</span> methodSignature =</span> new</span> StringBuilder</span>(</span>)</span></span></span></span>;</span>
</span></span>	methodSignature.</span>append</span>(</span>"</span>("</span></span>)</span></span>;</span>
</span></span>	m.</span>getParameters</span>(</span>)</span></span>.</span>forEach</span>(</span>p</span></span> -></span> methodSignature.</span>append</span>(</span>descriptorFromType</span>(</span>p.</span>asType</span>(</span>)</span></span>)</span></span>)</span></span></span>)</span></span>;</span>
</span></span>	methodSignature.</span>append</span>(</span>"</span>)"</span></span>)</span></span>;</span>
</span></span>	methodSignature.</span>append</span>(</span>descriptorFromType</span>(</span>m.</span>getReturnType</span>(</span>)</span></span>)</span></span>)</span></span>;</span>
</span></span>	return</span> methodSignature.</span>toString</span>(</span>)</span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
For SRG mapping, I added a utility class</a> to Lillero for the occasion. Explaining how it works would go beyond the scope of this post; all you need to know is that now the method contains a few more things:</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	//</span>pretty sure class names de facto never change but better safe than sorry
</span></span></span>	String</span> targetClassSrgName =</span> mapper.</span>getMcpClass</span>(</span>
</span></span></span></span>		targetClassCanonicalName.</span>replace</span>(</span>'</span>.'</span></span>,</span> '</span>/'</span></span>)</span></span>
</span></span></span></span>	)</span></span></span>;</span>
</span></span>	if</span>(</span>targetClassSrgName ==</span> null</span>)</span></span>
</span></span>		throw</span> new</span> MappingNotFoundException</span>(</span>targetClassCanonicalName)</span></span></span>;</span>
</span></span>	String</span> targetMethodDescriptor =</span> descriptorFromMethodSpec</span>(</span>targetMethod)</span></span></span>;</span>
</span></span>	String</span> targetMethodSrgName =</span> mapper.</span>getSrgMember</span>(</span>
</span></span></span></span>		targetClassCanonicalName.</span>replace</span>(</span>'</span>.'</span></span>,</span> '</span>/'</span></span>)</span></span>,</span>
</span></span></span></span>		targetMethod.</span>getSimpleName</span>(</span>)</span></span> +</span> "</span> "</span></span> +</span> targetMethodDescriptor
</span></span></span></span>	)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
We now have all we need to make the remaining specs:</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>		MethodSpec</span> methodName =</span> MethodSpec</span>.</span>methodBuilder</span>(</span>"</span>methodName"</span></span>)</span></span>
</span></span></span>		.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span>		.</span>returns</span>(</span>String</span>.</span>class</span>)</span></span>
</span></span></span>		.</span>addStatement</span>(</span>"</span>return $S"</span></span>,</span> targetMethodSrgName)</span></span>
</span></span></span>		.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>
</span></span>		MethodSpec</span> methodDesc =</span> MethodSpec</span>.</span>methodBuilder</span>(</span>"</span>methodDesc"</span></span>)</span></span>
</span></span></span>		.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span>		.</span>returns</span>(</span>String</span>.</span>class</span>)</span></span>
</span></span></span>		.</span>addStatement</span>(</span>"</span>return $S"</span></span>,</span> targetMethodDescriptor)</span></span>
</span></span></span>		.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
Writing yet another descriptor generator did irk me; at first, I was really trying to generate code which would call my other generator, rather than a String</code> directly, but I eventually figured that it was useless. I might still move the descriptor generators over to Lillero, but there was basically no way of reusing the old code as far as I could see. Damn AST.</p>
There's just one method left: the injector. Its spec is a bit less straightforward, but again JavaPoet made it very easy:</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	MethodSpec</span> inject =</span> MethodSpec</span>.</span>methodBuilder</span>(</span>"</span>inject"</span></span>)</span></span>
</span></span></span>			.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span>			.</span>returns</span>(</span>void.</span>class</span>)</span></span>
</span></span></span>			.</span>addParameter</span>(</span>
</span></span></span></span>				ParameterSpec</span>.</span>builder</span>(</span>
</span></span></span></span></span>					TypeName</span>.</span>get</span>(</span>
</span></span></span></span></span></span>						processingEnv
</span></span></span></span></span></span>							.</span>getElementUtils</span>(</span>)</span></span>
</span></span></span></span></span></span>							.</span>getTypeElement</span>(</span>"</span>org.objectweb.asm.tree.ClassNode"</span></span>)</span></span>
</span></span></span></span></span></span>							.</span>asType</span>(</span>)</span></span>
</span></span></span></span></span></span>					)</span></span>,</span>
</span></span></span></span></span>					"</span>clazz"</span></span>
</span></span></span></span></span>				)</span></span>.</span>build</span>(</span>)</span></span>
</span></span></span></span>			)</span></span>.</span>addParameter</span>(</span>
</span></span></span></span>				ParameterSpec</span>.</span>builder</span>(</span>
</span></span></span></span></span>					TypeName</span>.</span>get</span>(</span>
</span></span></span></span></span></span>						processingEnv
</span></span></span></span></span></span>							.</span>getElementUtils</span>(</span>)</span></span>
</span></span></span></span></span></span>							.</span>getTypeElement</span>(</span>"</span>org.objectweb.asm.tree.MethodNode"</span></span>)</span></span>
</span></span></span></span></span></span>							.</span>asType</span>(</span>)</span></span>
</span></span></span></span></span></span>					)</span></span>,</span>
</span></span></span></span></span>					"</span>main"</span></span>
</span></span></span></span></span>				)</span></span>.</span>build</span>(</span>)</span></span>
</span></span></span></span>			)</span></span>.</span>addStatement</span>(</span>"</span>$T."</span></span> +</span> injectorMethod.</span>getSimpleName</span>(</span>)</span></span> +</span> "</span>(clazz, main)"</span></span>,</span> TypeName</span>.</span>get</span>(</span>cl.</span>asType</span>(</span>)</span></span>)</span></span>)</span></span>
</span></span></span>			.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
I again do that weird getTypeElement(CharSequence)</code> thing to avoid directly referencing ObjectWeb's ASM so I don't have to import them; everything else should be self-explanatory. Oh yeah: $T</code> is the JavaPoet placeholder for a type, and will also auto-import whatever gets put there.</p>
Now it's time to create the TypeSpec</code>, the actual class. I kind of figured out that all method specs except for this last one were pretty much identical, so I made a helper method to reduce code redundancy:</p>
private</span> static</span> MethodSpec</span> buildStringReturnMethod</span>(</span>String</span> name,</span> String</span> returnString)</span></span> {</span>
</span></span>	return</span> MethodSpec</span>.</span>methodBuilder</span>(</span>name)</span></span>
</span></span>		.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span>		.</span>returns</span>(</span>String</span>.</span>class</span>)</span></span>
</span></span>		.</span>addStatement</span>(</span>"</span>return $S"</span></span>,</span> returnString)</span></span>
</span></span>		.</span>build</span>(</span>)</span></span>;</span>
</span></span>}</span></span>
</span>
</span>private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	TypeSpec</span> injectorClass =</span> TypeSpec</span>.</span>classBuilder</span>(</span>injectorSimpleClassName)</span></span>
</span></span></span>		.</span>addModifiers</span>(</span>Modifier</span>.</span>PUBLIC</span>)</span></span>
</span></span></span>		.</span>addSuperinterface</span>(</span>ClassName</span>.</span>get</span>(</span>IInjector</span>.</span>class</span>)</span></span>)</span></span>
</span></span></span>		.</span>addMethod</span>(</span>buildStringReturnMethod</span>(</span>"</span>name"</span></span>,</span> cl.</span>getSimpleName</span>(</span>)</span></span>.</span>toString</span>(</span>)</span></span>)</span></span>)</span></span>
</span></span></span>		.</span>addMethod</span>(</span>buildStringReturnMethod</span>(</span>"</span>reason"</span></span>,</span> ann.</span>reason</span>(</span>)</span></span>)</span></span>)</span></span>
</span></span></span>		.</span>addMethod</span>(</span>buildStringReturnMethod</span>(</span>"</span>targetClass"</span></span>,</span> targetClassSrgName.</span>replace</span>(</span>'</span>/'</span></span>,</span> '</span>.'</span></span>)</span></span>)</span></span>)</span></span>
</span></span></span>		.</span>addMethod</span>(</span>buildStringReturnMethod</span>(</span>"</span>methodName"</span></span>,</span> targetMethodSrgName)</span></span>)</span></span>
</span></span></span>		.</span>addMethod</span>(</span>buildStringReturnMethod</span>(</span>"</span>methodDesc"</span></span>,</span> targetMethodDescriptor)</span></span>)</span></span>
</span></span></span>		.</span>addMethod</span>(</span>inject)</span></span>
</span></span></span>		.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
There. now all that's left is actually printing it to a file. There's this thing called a Filer</code></a> which is meant to aid AnnotationProcessors in generation, so I used that:</p>
private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	JavaFile</span> javaFile =</span> JavaFile</span>.</span>builder</span>(</span>packageName,</span> injectorClass)</span></span>.</span>build</span>(</span>)</span></span></span>;</span>
</span></span>	try</span> {</span>
</span></span></span>		JavaFileObject</span> injectorFile =</span> processingEnv.</span>getFiler</span>(</span>)</span></span>.</span>createSourceFile</span>(</span>injectorClassName)</span></span></span>;</span>
</span></span></span>		PrintWriter</span> out =</span> new</span> PrintWriter</span>(</span>injectorFile.</span>openWriter</span>(</span>)</span></span>)</span></span></span></span>;</span>
</span></span></span>		javaFile.</span>writeTo</span>(</span>out)</span></span>;</span>
</span></span></span>		out.</span>close</span>(</span>)</span></span>;</span>
</span></span></span>	}</span></span> catch</span></span>(</span>IOException</span> e</span>)</span></span></span> {</span>
</span></span></span>		throw</span> new</span> RuntimeException</span>(</span>e)</span></span></span>;</span>
</span></span></span>	}</span></span>
</span></span>}</span></span>
</span></code></pre>
The code above should be self-explanatory. Now, back to the original process(Set<? extends TypeElement>, RoundEnvironment)</code> method, all that's left to do is generate the service provider. I'm going to need the fully qualified names of the newly generated injectors, so I add one last line to the generation class:</p>
private</span> final</span> Set</span><</span>String</span>></span></span> generatedInjectors =</span> new</span> HashSet</span><></span>(</span>)</span></span></span></span>;</span>
</span>
</span>private</span> void generateInjector</span>(</span>TypeElement</span> cl)</span></span> {</span>
</span></span>	.</span>.</span>.</span>
</span></span>	this</span>.</span>generatedInjectors.</span>add</span>(</span>injectorClassName)</span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
Generating resources</h3>
It's time to make the service provider. By the way, after</em> writing my own, I stumbled on a processor made to specifically handle service provider generation. If that's all you need, you don't have to write anything yourself, and you can find it here</a>. I still need to make my own, since I'm pretty sure that it can't be applied to classes by another processor. Anyway, back to process(Set<? extends TypeElement>, RoundEnvironment)</code></p>
@</span></span>SupportedAnnotationTypes</span></span>(</span>"</span>ftbsc.lll.processor.annotations.Patch"</span></span>)</span></span></span>
</span>@</span></span>SupportedSourceVersion</span></span>(</span>SourceVersion</span>.</span>RELEASE_8</span>)</span></span></span>
</span>public</span> class</span> LilleroProcessor</span></span> extends</span> AbstractProcessor</span> </span>{</span>
</span></span></span></span>	 @</span></span>Override</span>
</span></span></span></span></span></span>	</span></span>public</span> boolean</span> process</span></span>(</span>Set</span><</span>?</span> extends</span> TypeElement</span>></span></span> annotations</span>,</span> RoundEnvironment</span> roundEnv</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		for</span> (</span>TypeElement</span> annotation :</span> annotations)</span></span> {</span>
</span></span></span></span></span></span></span>			if</span>(</span>annotation.</span>getQualifiedName</span>(</span>)</span></span>.</span>toString</span>(</span>)</span></span>.</span>equals</span>(</span>Patch</span>.</span>class</span>.</span>getName</span>(</span>)</span></span>)</span></span>)</span></span> {</span>
</span></span></span></span></span></span></span></span>				Set</span><</span>TypeElement</span>></span></span> validInjectors =</span>
</span></span></span></span></span></span></span></span></span>					roundEnv.</span>getElementsAnnotatedWith</span>(</span>annotation)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>stream</span>(</span>)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>map</span>(</span>e</span></span> -></span> (</span>TypeElement</span>)</span></span> e</span>)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>filter</span>(</span>this</span>::</span>isValidInjector</span>)</span></span>
</span></span></span></span></span></span></span></span></span>						.</span>collect</span>(</span>Collectors</span>.</span>toSet</span>(</span>)</span></span>)</span></span></span>;</span>
</span></span></span></span></span></span></span></span>				if</span>(</span>!</span>validInjectors.</span>isEmpty</span>(</span>)</span></span>)</span></span> {</span>
</span></span></span></span></span></span></span></span></span>					validInjectors.</span>forEach</span>(</span>this</span>::</span>generateInjector</span>)</span></span>;</span>
</span></span></span></span></span></span></span></span></span>					if</span> (</span>!</span>this</span>.</span>generatedInjectors.</span>isEmpty</span>(</span>)</span></span>)</span></span> {</span>
</span></span></span></span></span></span></span></span></span></span>						generateServiceProvider</span>(</span>)</span></span>;</span>
</span></span></span></span></span></span></span></span></span></span>						return</span> true</span>;</span>
</span></span></span></span></span></span></span></span></span></span>					}</span></span>
</span></span></span></span></span></span></span></span></span>				}</span></span>
</span></span></span></span></span></span></span></span>			}</span></span>
</span></span></span></span></span></span></span>		}</span></span>
</span></span></span></span></span></span>		return</span> false</span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
I add another isEmpty()</code> check, in case there's some errors I failed to handle. Then, I call a method, which I'm going to paste all at once here, since it's very straightforward:</p>
private</span> void generateServiceProvider</span>(</span>)</span></span> {</span>
</span></span>	try</span> {</span>
</span></span></span>		FileObject</span> serviceProvider =</span>
</span></span></span></span>			processingEnv.</span>getFiler</span>(</span>)</span></span>.</span>createResource</span>(</span>
</span></span></span></span></span>				StandardLocation</span>.</span>CLASS_OUTPUT</span>,</span> "</span>"</span></span>,</span> "</span>META-INF/services/ftbsc.lll.IInjector"</span></span>
</span></span></span></span></span>			)</span></span></span>;</span>
</span></span></span>		PrintWriter</span> out =</span> new</span> PrintWriter</span>(</span>serviceProvider.</span>openWriter</span>(</span>)</span></span>)</span></span></span></span>;</span>
</span></span></span>		this</span>.</span>generatedInjectors.</span>forEach</span>(</span>out::</span>println</span>)</span></span>;</span>
</span></span></span>		out.</span>close</span>(</span>)</span></span>;</span>
</span></span></span>	}</span></span> catch</span></span>(</span>IOException</span> e</span>)</span></span></span> {</span>
</span></span></span>		throw</span> new</span> RuntimeException</span>(</span>e)</span></span></span>;</span>
</span></span></span>	}</span></span>
</span></span>}</span></span>
</span></code></pre>
All done. The only thing I feel like pointing out is the creative</em> (stupid) way resource location is handled. The empty string is the "package name", as if you'd ever need to place a resource in a package, while you need to write subfolders as part of the filename. CLASS_OUTPUT</code> is the StandardLocation</code> you're looking for if you want it to actually be compiled in. If you simply need to generate a service provider but don't want it to be compiled in, for whatever reason, SOURCE_OUTPUT</code> should do the trick.</p>
Gradle magic</h3>
Now, aside from a bunch of debugging that I unceremoniously glossed over, pretending I got everything right on the first try, the only thing left is telling Gradle how to use this darn thing. At first, I thought I'd need to make a proper plugin - fr1kin did it! - but as it turns out it's much simpler than that.</p>
As outlined in the relevant Gradle docs</a> (fair warning, Gradle seems to change doc structure far more often than they should, so this link might break), they use something called incremental compilation</strong>, which is meant to speed up the process as much as possible. With Gradle, it's possible</a> for annotation processors to become "incremental" as well, and make use of this feature.</p>
There's three types of incremental annotation processors: isolating, aggregating, dynamic. The explanation is all over the place in gradle, so check out this StackOverflow thread</a> for a better one. Since we get all the info we need from the AST structure, isolating</code> is the type we need. So, we create the resource META-INF/gradle/incremental.annotation.processors</code> and inside we write:</p>
ftbsc.lll.LilleroProcessor,isolating</code></p>
That's it. I added it to BoSCoVicino</a> and it worked. Currently, the way to add it to a build.gradle</code> is</p>
dependencies {</span>
</span></span>	 implementation '</span>ftbsc.lll:processor:0.1.0'</span></span>
</span></span>	 annotationProcessor '</span>com.squareup:javapoet:1.13.0'</span></span>
</span></span>	 annotationProcessor '</span>ftbsc:lll:0.2.1'</span></span>
</span></span>	 annotationProcessor '</span>ftbsc.lll:processor:0.1.0'</span></span>
</span></span>}</span></span>
</span></code></pre>
which kind of sucks, but hopefully I'll figure out a better way in the future. If I do, I might edit this post.</del> I did! It's really simple. Now all it needs is</p>
dependencies {</span>
</span></span>	 implementation '</span>ftbsc.lll:processor:0.1.0'</span></span>
</span></span>	 annotationProcessor '</span>ftbsc.lll:processor:0.1.0'</span></span>
</span></span>}</span></span>
</span></code></pre>
...which is about as good as it can get - I might even split the annotations (which is what has to be accessible from the project) from the processor itself in the future.</p>
Here's how I did it. As you may know, we host the builds on our own Maven instance. It was as simple as actually declaring the dependency on Maven:</p>
<</span>project</span>></span></span>
</span>	<</span>modelVersion</span>></span></span>4.0.0</</span>modelVersion</span>></span></span>
</span>	<</span>groupId</span>></span></span>ftbsc.lll</</span>groupId</span>></span></span>
</span>	<</span>artifactId</span>></span></span>processor</</span>artifactId</span>></span></span>
</span>	<</span>version</span>></span></span>0.2.1</</span>version</span>></span></span>
</span>	<</span>repositories</span>></span></span>
</span>		<</span>repository</span>></span></span>
</span>			<</span>id</span>></span></span>ftbsc</</span>id</span>></span></span>
</span>			<</span>name</span>></span></span>fantabos.co</</span>name</span>></span></span>
</span>			<</span>url</span>></span></span>https://maven.fantabos.co</</span>url</span>></span></span>
</span>		</</span>repository</span>></span></span>
</span>	</</span>repositories</span>></span></span>
</span>	<</span>dependencies</span>></span></span>
</span>		<</span>dependency</span>></span></span>
</span>			<</span>groupId</span>></span></span>ftbsc</</span>groupId</span>></span></span>
</span>			<</span>artifactId</span>></span></span>lll</</span>artifactId</span>></span></span>
</span>			<</span>version</span>></span></span>0.3.0</</span>version</span>></span></span>
</span>			<</span>type</span>></span></span>jar</</span>type</span>></span></span>
</span>		</</span>dependency</span>></span></span>
</span>		<</span>dependency</span>></span></span>
</span>			<</span>groupId</span>></span></span>com.squareup</</span>groupId</span>></span></span>
</span>			<</span>artifactId</span>></span></span>javapoet</</span>artifactId</span>></span></span>
</span>			<</span>version</span>></span></span>1.13.0</</span>version</span>></span></span>
</span>			<</span>type</span>></span></span>jar</</span>type</span>></span></span>
</span>		</</span>dependency</span>></span></span>
</span>	</</span>dependencies</span>></span></span>
</span></</span>project</span>></span></span>
</span></code></pre>
Obviously (although this simple fact somehow eluded me for days), the build.gradle isn't compiled in and therefore its information can't be retrieved by other buildscripts importing the processor. Now I feel kind of stupid, I even asked this on StackOverflow. Oh, well. All is well that ends well.</p>
Conclusions</h2>
Honestly, writing this was actually fun. It's just a shame that the documentation was that sparse - I spent far more time looking up stuff than actually writing code.</p>
It's barebones and needs some tweaking, but Lillero-processor</strong> is perfectly usable. Considering the API itself consists of three annotations, it's very unlikely that it will change in ways that affect the functioning. You can check it out on GitHub</a> or on moonlit</a>.</p>


OpenVic
2023-02-19T18:30:00+01:00
OpenVic is an upcoming FOSS game, written with Godot in C++, which aims to recreate and enhance the experience from popular videogame Victoria 2.
The project is made up of multiple components:</p>

The main repo</a>, containing the Godot part of the code.</li>
The simulation</a>, containing the underlying C++ "library".</li>
The dataloader</a>, containing the parser for Victoria 2's defines.</li>
</ul>
Finally, you can find the project's official website here</a>.</p>

  
  
</div>


Don't do coremods - a dev diary
2023-02-08T17:36:23+01:00

  
  
</div>

  
  
</div></p>
Introduction - a rant about the Forge forums</h2>
Unless you are very familiar with Minecraft modding (and especially with hacked cli- er, I mean, utility mods) you are unlikely to know what a "core mod" is. According to the first thread I found from googling</a>, core mods are:</p>

a special type of mod that have the ability to not only have their own code in it, but also modify every piece of code in vanilla minecraft however they please</p>
</blockquote>
In other words, they are mods that mess with Minecraft's source. The follow up egregiously summarises the Forum's official stance on the matter:</p>

This is a bad thing, because if this modified code fails, it will look as if vanilla minecraft itself has produced this problem, often making it near impossible to trace it back to the originating mod. Moreover ensuring compatibility when mods just modify vanilla code is much harder.</p>
</blockquote>
Put simply, they are getting overwhelmed with stupid bug reports that they can't really solve because the patched code looks just like vanilla Minecraft. It must suck, but... what can you do? Well, I can tell you what they</em> did: demonise core mods, and eventually ban all discussion of them.</p>
Skim through a few threads: you might notice the ever-friendly forum folks equating more and more core mods to hacking. Even if that was the case (it's really not), what's the big deal? We "utility mod" folks are as legitimate as any other mod developer. If you want to blame someone, blame the idiots using our clients to ruin everyone's fun. Not us developers. Most of us don't make a buck out of it, we develop these for ourselves to mess around on our own servers for fun.</p>
And, as I said, they have eventually dropped core mod support altogether, locking any thread daring to ask questions even vaguely related to the subject, often accompanied by passive-aggressive remarks by the moderator about how "they don't support hacking".</p>
Yeah, you heard me right. They don't just discard bug reports that include core mods (as would be legitimate), they outright ban any discussion even about implementing them. That's dumb, especially if you consider that most support is given by peers, not moderators.</p>
This "father knows best" approach, discouraging any inquire about anything but the most basic API, ensures that nobody looks further than their own noses. Unfortunately, this attitude is spread to a good chunk of the project, not just the forums. Take a look at the READMEs of any Forge repo if you don't believe me: they are cryptic at best, and openly gatekeeping (saying stuff like "we won't spoonfeed you", as if writing documentation was a bad thing) at worst.</p>
I'm pretty sure that this attitude deterred a number of competent developers who otherwise might've contributed. Just saying, most people would probably rather start from scratch than contribute to a barely-documented project. Ah, I'm just bitter. That</a> won't</a> happen</a>!</p>
But honestly, what actually annoys me is the hacker boogeyman. Whenever a question is asked on there that deviates from API usage, they will insistently inquire about why would you need to do that, regardless of how relevant that is to the question asked. The purpose here - and you can't convince me otherwise - is to find out if any evil hackers are hiding among the honest, hard-working, God-fearing folks of the forum, and out them as such and lock their thread, regardless of whether the question was interesting or even related.</p>

muh xy problem</a></p>
</blockquote>
I could write another blogpost about how that's a non-issue, and I might, but for now let's just say that's my opinion and leave it that. The thing is though, Minecraft has a very wide age target. This means that they will attract anyone between the 35-years-old professional developer and the 13-years-old newbie.</p>
Logically, even assuming that the XY problem is legitimate, you can't expect everyone to ask intelligent and to-the-point questions in such an environment. Kids will be kids. This, however, must not prevent someone capable of understanding from asking questions. The solution to the XY problem is most definitely not to assume everyone but you is stupid.</p>
But if core mods are off-limits, how do they suggest we modify the code? Because, obviously, it's unrealistic for all mods (which, I remind you, stands for "modifications") to work around modifying the game code.</p>
The problems stems from them being somehow unable to recognize core mod errors (even though any crash log is flagged with "core mod detected"), so what's their better way? That would be Mixin</a>, which is shipped as a part Forge 1.13+ and can be used as a library in some earlier versions.</p>
I, frankly, fail to see the merits in using it over direct ASM patching, as a poorly written Mixin patch is (obviously) just as prone to conflicts. It's probably easier for the developer, especially since you write Java rather than bytecode instructions. Downside is that, for obvious reasons, Mixin is a pretty big - even bloated - library. And, depending on who you ask, having to write in Java is a downside of its own. Cherry on top, in 1.12.2 and prior, you even had to compile Mixin into your mod's JAR.</p>
Of course, that's no longer necessary, and the Forums have taken note of that. Since now they ship together, any inquire on the forums remotely related to "the devil's mixins" - the barbarous practice formerly known as core modding - will be met with distrust. Since newbies aren't capable of doing it, suggesting that it's possible to modify Minecraft classes without passing through Mixin is tantamount to heresy, and as such it should be treated with the same approach used a long time ago by the Spanish Inquisition.</p>
You can't ask about core modding in older versions, either. Because asking about "old versions" gets your thread locked even if you are asking the most basic, innocent thing ever. "It's no longer supported" the moderator cries "use modern Minecraft!". Considering that, as I said, most support is given by peers, I can't help but think that banning discussion of Forge for older versions is... a bit of an odd decision. They even went out of their way to hide the 1.12 official Forge documentation, don't ask me why.</p>
Enough about the Forums, though. You are probably here for the code, so let's get into that part.</p>
The problem</h3>
Now that we have established that there is nothing wrong with a modder patching the game's code directly, and that Mixin is not ideal either, let's give them a point. Core mods are</em>, admittedly, an inefficient way to patch the game. Reason being that they are applied at runtime by Forge. Plus, with how much they dislike this practice, they may eventually drop support for it altogether. I, in fact, thought they had when I originally wrote this post. They actually just moved it elsewhere in 1.13+ and never explained how to do it in the new way anywhere.</p>
Now, I've mentioned "1.13+" a few times, and that is because the Forge developers decided to do a major rewrite of a lot of their code in that version (which is apparently the reason it took years to even reach beta status). The point is that they made Forge less monolithic, separating it into its various components. Of course, this modularity has a price, and interal components that previously could only work with each other had to be changed into publicly-accessible APIs.</p>
This is relevant to us, because now we can write a program that acts on the same level as Forge and Mixin. This will enable us to apply ASM patches without bothering with middlemen. This is supposed to be more efficient than core mods, while still enabling us to patch with actual ASM, just how we like it. Why? Why not!</p>
This is my dev diary of how we achieved that, despite the documentation roughly amounting to "here be dragons", and of all the problems we ran into during development. The code feature here is by definition buggy and broken, and is here just to detail how it evolved. So, if you are just interested in the final result, scroll to the end, but I'll hate you forever if you do.</p>
The story</h2>
So, as we got the first prototype of our alternate auth server</a> working, we figured that we could use a client to test it on. After some debating, during which even talks of using Kotlin (shivers</em>) were heard, we decided to start a brand new client</a>. We retained the name theme, for those who can get it.</p>
As I mentioned, we thought Forge had ditched core mods altogether. My stubborness compelled me to continue looking for a way to do direct ASM patching, despite my less-than-enthusiast co-developer, and we got into it.</p>
We needed to dig around for ideas from others. One problem: as I mentioned, ASM patching is really rare nowadays. Many client developers, unfortunately, are script kiddies who barely know Java. The idea of messing with something as scary-looking as ASM frightens them. This is not to say that Mixin is only used by incompetent people: many great developers</a> do, in fact, use it, for ease of use or other considerations. I'm just saying that, between those that choose it out of convenience and those who choose it because bytecode looks spooky, not many are left.</p>
To my knowledge, only two recent, good clients using ASM patching exist: Seppuku</a> (although it's 1.12, so it wasn't going to help us), and...</p>
On our own (sort of)</h3>
...ForgeHax</a>, a client I was very</em> familiar with. And by that I mean that I learned most of the Java I know by messing on a private fork of it. It contained something related to what we were shooting for in its 1.16 branch; it was, however, imperfect. It applies - just like it was in 1.12 - the patches using runtime reflection. That can get really slow. ForgeHax 1.16 has, like, a dozen patches, so it's not really noticeable; but in my ForgeHax 1.12 fork, there used to be a lot more. And let me tell you, that go slow</em>. There went my original plan of skidding the shit out of whatever he did.</p>
At least, he gave us a nudge in the general direction: it was by looking at his code that we figured out how to use Java Services</a> and that one of Forge's libraries, called ModLauncher</a>, was our ticket to ASM patching. It was very clearly only meant for internal use, but we figured that wouldn't be an issue: it was obviously designed to make integrating whatever new services they came up with easy. In other words, they had no easy way to lock everyone else out.</p>
Figuring out ModLauncher</h3>
It took some digging (and reading what little documentation</a> was available) but we figured out what we had to do: an ILaunchPlugin</code></a> - called at the very beginning - would just do the trick.</p>
So, apparently all it took to make a service was a META-INF</code> file to let it know that we were there too, and to implement a pretty simple interface. Neat! Unsure about where to beging with, we figured out that, as the only obligatory one to implement, handlesClass()</code> was definitely the one who would receive the classes. It expected us to return an EnumSet<Phase></code>, so we weren't sure what that was all about, but we put together an initial skeleton that would simply print whatever classes it received.</p>
package</span> ftbsc.</span>bscv.</span>asm</span></span></span>;</span>
</span>
</span>import</span> java</span></span>.</span>io</span>.</span>File</span></span></span>;</span>
</span>import</span> java</span></span>.</span>io</span>.</span>IOException</span></span></span>;</span>
</span>import</span> java</span></span>.</span>util</span>.</span>EnumSet</span></span></span>;</span>
</span>
</span>import</span> org</span></span>.</span>apache</span>.</span>logging</span>.</span>log4j</span>.</span>LogManager</span></span></span>;</span>
</span>import</span> org</span></span>.</span>apache</span>.</span>logging</span>.</span>log4j</span>.</span>Logger</span></span></span>;</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>Type</span></span></span>;</span>
</span>
</span>import</span> cpw</span></span>.</span>mods</span>.</span>modlauncher</span>.</span>serviceapi</span>.</span>ILaunchPluginService</span></span></span>;</span>
</span>
</span>public</span> class</span> BoSCoVicinoLoader</span></span> implements</span> ILaunchPluginService</span> </span>{</span>
</span></span></span></span>
</span></span></span></span>	public</span> static</span> Logger</span> LOGGER</span> =</span> LogManager</span>.</span>getLogger</span>(</span>"</span>BSCV-ASM"</span></span>)</span></span></span>;</span>
</span></span></span></span>
</span></span></span></span>	public</span> BoSCoVicinoLoader</span></span>(</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		LOGGER</span>.</span>info</span>(</span>"</span>BoSCoVicinoLoader instantiation"</span></span>)</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>
</span></span></span></span>	@</span></span>Override</span>
</span></span></span></span></span></span>	</span></span>public</span> String</span> name</span></span>(</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		return</span> "</span>boscovicino_asm"</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>
</span></span></span></span>	@</span></span>Override</span>
</span></span></span></span></span></span>	</span></span>public</span> EnumSet</span><</span>ILaunchPluginService</span>.</span>Phase</span>></span></span> handlesClass</span></span>(</span>Type</span> classType</span>,</span> final</span> boolean</span> isEmpty</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		LOGGER</span>.</span>info</span>(</span>String</span>.</span>format</span>(</span>"</span>CLAZZ >>> %s"</span></span>,</span> classType.</span>getClassName</span>(</span>)</span></span>)</span></span>)</span></span>;</span>
</span></span></span></span></span></span>		return</span> EnumSet</span>.</span>noneOf</span>(</span>Phase</span>.</span>class</span>)</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
Unfortunately, it didn't seem to load us. Why? Well, we figured it out soon enough: we are a Forge mod, so our JAR is loaded way after this takes place. I had an idea: we edited the version JSON and added ourselves in as a library. It worked! We resolved to split the client into two: a patch framework, and the actual client. But, for now, we'd keep it together, for testing.</p>
We then went to sleep, content with what we achieved. We were hopeful, and thought it might just work, for a change.</p>
Minimum Viable Product (MVP)</h3>
The next day I went nuclear on it. I figured out that the next step was processClassWithFlags()</code>. The person working with me had told me that, according to what he'd read, at this stage we'd receive unobfuscted names. As we'll see, this claim came straight from his anus, but we can't fault the man for misreading. The documentation was not exactly clear.</p>
Anyway, this is where the Loader got really big. Ready?</p>
For starters, a quick dive into Mixin's code taught me that there are two different handlesClass()</code> methods in the interface for retrocompatibility. We want to work with whatever Forge brings in, so I did the same as them:</p>
private</span> static</span> final</span> HashMultimap</span><</span>String</span>,</span> Class</span><</span>?</span>></span></span>></span></span> patchClasses =</span> HashMultimap</span>.</span>create</span>(</span>)</span></span></span>;</span>
</span>
</span>private</span> static</span> final</span> EnumSet</span><</span>Phase</span>></span></span> YAY</span> =</span> EnumSet</span>.</span>of</span>(</span>Phase</span>.</span>BEFORE</span>)</span></span></span>;</span>
</span>private</span> static</span> final</span> EnumSet</span><</span>Phase</span>></span></span> NAY</span> =</span> EnumSet</span>.</span>noneOf</span>(</span>Phase</span>.</span>class</span>)</span></span></span>;</span>
</span>
</span>@</span></span>Override</span>
</span></span></span></span></span>public</span> EnumSet</span><</span>Phase</span>></span></span> handlesClass</span>(</span>Type</span> classType,</span> final boolean</span> isEmpty)</span></span> {</span>
</span></span>	throw</span> new</span> IllegalStateException</span>(</span>"</span>Outdated ModLauncher"</span></span>)</span></span></span>;</span> //</span>mixin does it
</span></span></span>}</span></span>
</span>
</span>@</span></span>Override</span>
</span></span></span></span></span>public</span> EnumSet</span><</span>Phase</span>></span></span> handlesClass</span>(</span>Type</span> classType,</span> final boolean</span> isEmpty,</span> final String</span> reason)</span></span> {</span>
</span></span>	if</span>(</span>isEmpty)</span></span> return</span> NAY</span>;</span>
</span></span>	String</span> name =</span> classType.</span>getClassName</span>(</span>)</span></span></span>;</span>
</span></span>	if</span>(</span>name.</span>startsWith</span>(</span>"</span>net.minecraft."</span></span>)</span></span> ||</span> name.</span>indexOf</span>(</span>'</span>.'</span></span>)</span></span> ==</span> -</span>1</span>)</span></span>
</span></span>		return</span> YAY</span>;</span>
</span></span>	else</span> {</span>
</span></span></span>		try</span> {</span>
</span></span></span></span>			if</span>(</span>hasAnnotation</span>(</span>name)</span></span>)</span></span> {</span>
</span></span></span></span></span>				Class</span><</span>?</span>></span></span> patch =</span> Class</span>.</span>forName</span>(</span>name)</span></span></span>;</span>
</span></span></span></span></span>				patchClasses.</span>put</span>(</span>Type</span>.</span>getDescriptor</span>(</span>patch.</span>getAnnotation</span>(</span>Patch</span>.</span>class</span>)</span></span>.</span>value</span>(</span>)</span></span>)</span></span>,</span> patch)</span></span>;</span>
</span></span></span></span></span>				return</span> YAY</span>;</span>
</span></span></span></span></span>			}</span></span>
</span></span></span></span>		}</span></span> catch</span></span>(</span>IOException</span> |</span> ClassNotFoundException</span> e</span>)</span></span></span> {</span>
</span></span></span></span>			LOGGER</span>.</span>debug</span>(</span>"</span>Could not load {}"</span></span>,</span> name)</span></span>;</span>
</span></span></span></span>		}</span></span>
</span></span></span>		return</span> NAY</span>;</span>
</span></span></span>	}</span></span>
</span></span>}</span></span>
</span></code></pre>
The YAY</code>/NAY</code> thing is copied from Forge's Access transformer: apparently you give it a Phase</code> to mark that your mod is interested in the class, or an empty EnumSet</code> to say that you don't care about it. To this day I've got no clue about what the exact difference between BEFORE</code> and AFTER</code> is, but whatever. If it works, it works.
HashMultimap</code> is a guava</a> thing, it allows multiple values for each key. I'm using it because, potentially, multiple patches may want to work on the same class. And also for future-proofing: while writing this, I was daydreaming about the possibility of multiple clients using this.</p>
hasAnnotation()</code> should be self-explanatory, but since it's custom, I'll briefly explain how it works:</p>
private</span> boolean</span> hasAnnotation</span>(</span>String</span> name)</span></span> throws IOException</span> {</span>
</span></span>	ClassReader</span> cr =</span> new</span> ClassReader</span>(</span>name)</span></span></span></span>;</span>
</span></span>	AnnotationChecker</span> ac =</span> new</span> AnnotationChecker</span>(</span>Patch</span>.</span>class</span>)</span></span></span></span>;</span>
</span></span>	cr.</span>accept</span>(</span>ac,</span> 0</span>)</span></span>;</span>
</span></span>	return</span> ac.</span>isAnnotationPresent</span>(</span>)</span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
This checks whether a certain class (passed through the fully qualified name) has the @Patch</code> annotation, which is how we originally recognized patches. The AnnotationChecker is a very simple ClassVisitor</a> I wrote myself:</p>
public</span> class</span> AnnotationChecker</span></span> extends</span> ClassVisitor</span> </span>{</span>
</span></span></span></span>	private</span> boolean</span> annotationPresent</span>;</span>
</span></span></span></span>	private</span> final</span> String</span> annotationDesc</span>;</span>
</span></span></span></span>
</span></span></span></span>	public</span> AnnotationChecker</span></span>(</span>Class</span><</span>?</span> extends</span> Annotation</span>></span></span> a</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		super</span>(</span>Opcodes</span>.</span>ASM8</span>)</span></span>;</span> //</span>hopefully lol
</span></span></span></span></span></span></span>		this</span>.</span>annotationPresent =</span> false</span></span>;</span>
</span></span></span></span></span></span>		this</span>.</span>annotationDesc =</span> Type</span>.</span>getDescriptor</span>(</span>a)</span></span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>
</span></span></span></span>	@</span></span>Override</span>
</span></span></span></span></span></span>	</span></span>public</span> AnnotationVisitor</span> visitAnnotation</span></span>(</span>String</span> desc</span>,</span> boolean</span> visible</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		if</span> (</span>visible &&</span> desc.</span>equals</span>(</span>this</span>.</span>annotationDesc)</span></span>)</span></span>
</span></span></span></span></span></span>			this</span>.</span>annotationPresent =</span> true</span></span>;</span>
</span></span></span></span></span></span>		return</span> super</span>.</span>visitAnnotation</span>(</span>desc,</span> visible)</span></span>;</span>
</span></span></span></span></span></span>		//</span>returning null would delete our annotation, but we don't want that
</span></span></span></span></span></span></span>		//</span>so we just delegate to superclass
</span></span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>
</span></span></span></span>	public</span> boolean</span> isAnnotationPresent</span></span>(</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		return</span> this</span>.</span>annotationPresent;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
Without going into much detail - read the ASM documentation</a> if you want to go in depth about how ClassVisitors work - all it does is "visit" a certain class, and set a boolean if it has a certain annotation. Next, I wrote the actual processClassWithFlags()</code> method.</p>
@</span></span>Override</span>
</span></span></span></span></span>public</span> int</span> processClassWithFlags</span>(</span>Phase</span> phase,</span> ClassNode</span> classNode,</span> Type</span> classType,</span> String</span> reason)</span></span> {</span>
</span></span>	if</span>(</span>patchClasses.</span>containsKey</span>(</span>classType.</span>getDescriptor</span>(</span>)</span></span>)</span></span>)</span></span> {</span>
</span></span></span>		//</span>can have multiple patches working on same class
</span></span></span></span>		//</span>each of these classes may attempt to patch a method one or more times
</span></span></span></span>		Set</span><</span>String</span>></span></span> classMethodNames =</span> classNode.</span>methods
</span></span></span></span>			.</span>stream</span>(</span>)</span></span>
</span></span></span></span>			.</span>map</span>(</span>m</span></span> -></span> m.</span>name</span>)</span></span>
</span></span></span></span>			.</span>collect</span>(</span>Collectors</span>.</span>toSet</span>(</span>)</span></span>)</span></span></span>;</span>
</span></span></span>		Set</span><</span>String</span>></span></span> classMethodDescriptors =</span> classNode.</span>methods
</span></span></span></span>			.</span>stream</span>(</span>)</span></span>
</span></span></span></span>			.</span>map</span>(</span>m</span></span> -></span> m.</span>desc</span>)</span></span>
</span></span></span></span>			.</span>collect</span>(</span>Collectors</span>.</span>toSet</span>(</span>)</span></span>)</span></span></span>;</span>
</span></span></span>		Set</span><</span>Class</span><</span>?</span>></span></span>></span></span> relevantPatches =</span> patchClasses.</span>get</span>(</span>classType.</span>getDescriptor</span>(</span>)</span></span>)</span></span></span>;</span>
</span></span></span>		HashMultimap</span><</span>Object</span>,</span> Method</span>></span></span> patches =</span> HashMultimap</span>.</span>create</span>(</span>)</span></span></span>;</span>
</span></span></span>		relevantPatches
</span></span></span>			.</span>forEach</span>(</span>p</span></span> -></span> {</span>
</span></span></span></span></span></span>				Set</span><</span>Method</span>></span></span> injectors =</span>
</span></span></span></span></span></span></span>					getInjectorsInPatch</span>(</span>p)</span></span>
</span></span></span></span></span></span></span>						.</span>stream</span>(</span>)</span></span>
</span></span></span></span></span></span></span>						.</span>filter</span>(</span>m</span></span> -></span> {</span>
</span></span></span></span></span></span></span></span></span></span>							Inject</span> a =</span> m.</span>getAnnotation</span>(</span>Inject</span>.</span>class</span>)</span></span></span>;</span>
</span></span></span></span></span></span></span></span></span></span>							return</span>
</span></span></span></span></span></span></span></span></span></span>								classMethodNames.</span>contains</span>(</span>a.</span>methodName</span>(</span>)</span></span>)</span></span>
</span></span></span></span></span></span></span></span></span></span>									&&</span> classMethodDescriptors.</span>contains</span>(</span>descriptorBuilder</span>(</span>a.</span>returnType</span>(</span>)</span></span>,</span> a.</span>parameters</span>(</span>)</span></span>)</span></span>)</span></span>;</span>
</span></span></span></span></span></span></span></span></span></span>						}</span></span></span>)</span></span>
</span></span></span></span></span></span></span>						.</span>collect</span>(</span>Collectors</span>.</span>toSet</span>(</span>)</span></span>)</span></span></span>;</span>
</span></span></span></span></span></span>				if</span>(</span>!</span>injectors.</span>isEmpty</span>(</span>)</span></span>)</span></span> {</span>
</span></span></span></span></span></span></span>					try</span> {</span>
</span></span></span></span></span></span></span></span>						patches.</span>putAll</span>(</span>p.</span>newInstance</span>(</span>)</span></span>,</span> injectors)</span></span>;</span>
</span></span></span></span></span></span></span></span>					}</span></span> catch</span></span>(</span>InstantiationException</span> |</span> IllegalAccessException</span> e</span>)</span></span></span> {</span>
</span></span></span></span></span></span></span></span>						throw</span> new</span> RuntimeException</span>(</span>e)</span></span></span>;</span> //</span>todo: better catch
</span></span></span></span></span></span></span></span></span>					}</span></span>
</span></span></span></span></span></span></span>				}</span></span>
</span></span></span></span></span></span>			}</span></span></span>)</span></span>;</span>
</span></span></span>		if</span>(</span>patches.</span>isEmpty</span>(</span>)</span></span>)</span></span>
</span></span></span>			return</span> ComputeFlags</span>.</span>NO_REWRITE</span>;</span>
</span></span></span>		else</span> {</span>
</span></span></span></span>			boolean</span> success =</span> false</span></span>;</span>
</span></span></span></span>			for</span>(</span>Object</span> p :</span> patches.</span>keys</span>(</span>)</span></span>)</span></span>
</span></span></span></span>				for</span>(</span>Method</span> m :</span> patches.</span>get</span>(</span>p)</span></span>)</span></span>
</span></span></span></span>					success =</span> success ||</span> processInjector</span>(</span>classNode,</span> p,</span> m)</span></span></span>;</span>
</span></span></span></span>			return</span> success ?</span> ComputeFlags</span>.</span>COMPUTE_FRAMES</span> :</span> ComputeFlags</span>.</span>NO_REWRITE</span>;</span> 
</span></span></span></span>		}</span></span>
</span></span></span>	}</span></span> else</span> return</span> ComputeFlags</span>.</span>NO_REWRITE</span>;</span>
</span></span>}</span></span>
</span></code></pre>
Explaining what this code does in detail would probably take more than reading it. I'm about to explain the methods, so read those and then go back and read this thing by yourself.</p>
ComputeFlags</code> is a ModLauncher thing: you return a different value of it depending on what you changed, for efficiency. Honestly, I wasn't really sure at this stage, so I only used the two extremes: COMPUTE_FRAMES</code> tells it that it needs to rewrite everything, and NO_REWRITE</code> that I did no change.</p>
Of course, many of the methods called there were made by yours truly.</p>
private</span> Set</span><</span>Method</span>></span></span> getInjectorsInPatch</span>(</span>Class</span><</span>?</span>></span></span> patch)</span></span> {</span>
</span></span>	return</span> Arrays</span>.</span>stream</span>(</span>patch.</span>getDeclaredMethods</span>(</span>)</span></span>)</span></span>
</span></span>			.</span>filter</span>(</span>m</span></span> -></span> m.</span>isAnnotationPresent</span>(</span>Inject</span>.</span>class</span>)</span></span></span>)</span></span>
</span></span>			.</span>collect</span>(</span>Collectors</span>.</span>toSet</span>(</span>)</span></span>)</span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
This does exactly</em> what the name suggests. It uses the already explained isAnnotationPresent()</code> method to figure out which of the Class methods have the @Inject</code> annotation and returns them as a Set</code>. Simple enough.</p>
public</span> static</span> String</span> descriptorBuilder</span>(</span>Class</span><</span>?</span>></span></span> returnType,</span> Class</span><</span>?</span>></span></span>[]</span> parameters)</span></span> {</span>
</span></span>	StringBuilder</span> desc =</span> new</span> StringBuilder</span>(</span>"</span>("</span></span>)</span></span></span></span>;</span>
</span></span>	for</span>(</span>Class</span><</span>?</span>></span></span> p :</span> parameters)</span></span>
</span></span>		desc.</span>append</span>(</span>Type</span>.</span>getDescriptor</span>(</span>p)</span></span>)</span></span>;</span>
</span></span>	desc.</span>append</span>(</span>"</span>)"</span></span>)</span></span>;</span>
</span></span>	desc.</span>append</span>(</span>Type</span>.</span>getDescriptor</span>(</span>returnType)</span></span>)</span></span>;</span>
</span></span>	return</span> desc.</span>toString</span>(</span>)</span></span>;</span>
</span></span>}</span></span>
</span></code></pre>
Simply builds a "method descriptor" for a certain method, given its return type and parameters. A descriptor looks something like [[Ljava/lang/Object;</code>, but if you really want to understand what it is, read the ASM guide I linked before.</p>
private</span> boolean</span> processInjector</span>(</span>ClassNode</span> target,</span> Object</span> patch,</span> Method</span> injector)</span></span> {</span>
</span></span>	//</span>get relevant method from target
</span></span></span>	Optional</span><</span>MethodNode</span>></span></span> targetMethod =</span>
</span></span></span>		target.</span>methods
</span></span></span>			.</span>stream</span>(</span>)</span></span>
</span></span></span>			.</span>filter</span>(</span>m</span></span> -></span> {</span>
</span></span></span></span></span></span>				Inject</span> a =</span> injector.</span>getAnnotation</span>(</span>Inject</span>.</span>class</span>)</span></span></span>;</span>
</span></span></span></span></span></span>				return</span> m.</span>name.</span>equals</span>(</span>a.</span>methodName</span>(</span>)</span></span>)</span></span> &&</span> m.</span>desc.</span>equals</span>(</span>descriptorBuilder</span>(</span>a.</span>returnType</span>(</span>)</span></span>,</span> a.</span>parameters</span>(</span>)</span></span>)</span></span>)</span></span>;</span>
</span></span></span></span></span></span>			}</span></span></span>)</span></span>
</span></span></span>			.</span>findAny</span>(</span>)</span></span></span>;</span> //</span>there can literally only be one so this is safe and more efficient than findFirst
</span></span></span>
</span></span>	try</span> {</span>
</span></span></span>		if</span>(</span>!</span>targetMethod.</span>isPresent</span>(</span>)</span></span>)</span></span>
</span></span></span>			throw</span> new</span> NoSuchMethodException</span>(</span>)</span></span></span>;</span>
</span></span></span>		injector.</span>invoke</span>(</span>patch,</span> targetMethod.</span>get</span>(</span>)</span></span>)</span></span>;</span>
</span></span></span>			LOGGER</span>.</span>info</span>(</span>
</span></span></span></span>			"</span>Completed transformation task {} for {}::{}"</span></span>,</span>
</span></span></span></span>			injector.</span>getAnnotation</span>(</span>Inject</span>.</span>class</span>)</span></span>.</span>description</span>(</span>)</span></span>,</span>
</span></span></span></span>			target.</span>name,</span>
</span></span></span></span>			targetMethod.</span>get</span>(</span>)</span></span>.</span>name
</span></span></span></span>		)</span></span>;</span>
</span></span></span>
</span></span></span>		return</span> true</span>;</span>
</span></span></span>
</span></span></span>	}</span></span> catch</span> </span>(</span>NoSuchMethodException</span> |</span> InvocationTargetException</span> |</span> IllegalAccessException</span> e</span>)</span></span></span> {</span>
</span></span></span>		if</span> (</span>e instanceof</span> NoSuchMethodException</span>)</span></span> {</span>
</span></span></span></span>			LOGGER</span>.</span>error</span>(</span>
</span></span></span></span></span>				"</span>{} while attempting to find method {}::{} in task {}. This should never happen."</span></span>,</span>
</span></span></span></span></span>				e,</span>
</span></span></span></span></span>				target.</span>name,</span>
</span></span></span></span></span>				injector.</span>getAnnotation</span>(</span>Inject</span>.</span>class</span>)</span></span>.</span>methodName</span>(</span>)</span></span>,</span>
</span></span></span></span></span>				injector.</span>getAnnotation</span>(</span>Inject</span>.</span>class</span>)</span></span>.</span>description</span>(</span>)</span></span>
</span></span></span></span></span>			)</span></span>;</span>
</span></span></span></span>		}</span></span> else</span> {</span>
</span></span></span></span>			Throwable</span> cause;</span>
</span></span></span></span>			if</span>(</span>e instanceof</span> InvocationTargetException</span>)</span></span>
</span></span></span></span>				cause =</span> e.</span>getCause</span>(</span>)</span></span></span>;</span>
</span></span></span></span>			else</span> cause =</span> e</span>;</span>
</span></span></span></span>			LOGGER</span>.</span>error</span>(</span>
</span></span></span></span></span>				"</span>{} thrown from {}::{} for task with description {}"</span></span>,</span>
</span></span></span></span></span>				cause,</span>
</span></span></span></span></span>				target.</span>name,</span>
</span></span></span></span></span>				targetMethod.</span>get</span>(</span>)</span></span>.</span>name,</span>
</span></span></span></span></span>				injector.</span>getAnnotation</span>(</span>Inject</span>.</span>class</span>)</span></span>.</span>description</span>(</span>)</span></span>
</span></span></span></span></span>			)</span></span>;</span>
</span></span></span></span>		}</span></span>
</span></span></span>		return</span> false</span>;</span>
</span></span></span>	}</span></span>
</span></span>}</span></span>
</span></code></pre>
This is where the magic happens: it processes the given Class, finds the target method, and applies the patch.</p>
And... that's it (or so I thought)! Time to write a simple test patch:</p>
package</span> ftbsc.</span>bscv.</span>asm.</span>patches</span></span></span>;</span>
</span>
</span>import</span> ftbsc</span></span>.</span>bscv</span>.</span>asm</span>.</span>api</span>.</span>annotations</span>.</span>Inject</span></span></span>;</span>
</span>import</span> ftbsc</span></span>.</span>bscv</span>.</span>asm</span>.</span>api</span>.</span>annotations</span>.</span>Patch</span></span></span>;</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>Opcodes</span></span></span>;</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>tree</span>.</span>InsnList</span></span></span>;</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>tree</span>.</span>InsnNode</span></span></span>;</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>tree</span>.</span>MethodNode</span></span></span>;</span>
</span>import</span> net</span></span>.</span>minecraft</span>.</span>client</span>.</span>Minecraft</span></span></span>;</span>
</span>
</span>@</span></span>Patch</span></span>(</span>Minecraft</span>.</span>class</span>)</span></span></span>
</span>public</span> class</span> TestPatch</span></span> implements</span> Opcodes</span> </span>{</span>
</span></span></span></span>
</span></span></span></span>	@</span></span>Inject</span></span>(</span>methodName</span> =</span> "</span>tick"</span></span>,</span> returnType</span> =</span> void.</span>class</span>,</span> parameters</span> =</span> {</span>}</span></span>,</span> description</span> =</span> "</span>Test injection!"</span></span>)</span></span></span>
</span></span></span></span>	public</span> void</span> inject</span></span>(</span>MethodNode</span> main</span>)</span></span></span> {</span></span></span></span>
</span></span></span></span></span></span>		InsnList</span> insnList =</span> new</span> InsnList</span>(</span>)</span></span></span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		insnList.</span>add</span>(</span>new</span> InsnNode</span>(</span>POP</span>)</span></span></span>)</span></span>;</span>
</span></span></span></span></span></span>		main.</span>instructions.</span>insert</span>(</span>insnList)</span></span>;</span>
</span></span></span></span></span></span>	}</span></span></span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
This stupid patch crashes Minecraft on its first tick. It's very handy to figure out whether it's working: crashes due to NegativeArraySizeExceptions aren't common. And... didn't work. It crashed, but not because of it: it was a ClassNotFoundException.</p>
I did somethings very stupid which I noticed immediately. Can you spot it? It's here in the patch. I'll give you three seconds. Three, two, one... I can't do Minecraft.class</code> because we are patching before that class is put into the classpath</em>. Grumbling, I minorly altered the code so that it would use the a String</code> containing the fully qualified name.</p>
Once again: close, but no cigar. It didn't crash, but didn't work either. It took me a while to figure this other one out, but eventually I did. And it wasn't good news: our entire approach was deeply flawed. I learned that handlesClass()</code> and processClassWithFlags()</code> are called one after the other for each patch</strong>. So, by the time net.minecraft.client.Minecraft</code> was loaded, our patch was not yet in the HashMultimap</code> containing them!</p>
By the way, I'd been keeping the other guy documented about my progress. He kept saying "MVP"... at first I thought he was cheering me on, but eventually I realised he meant "Minimum Viable Product", not "Most Valuable Player". He was pushing me to get it working ASAP. Well, this was a big issue, but there was</em> a quick and dirty way to fix it.</p>
I wrote a static method called in the constructor of our Loader - so that it would come before it starts receiving patches:</p>
private</span> static</span> void loadPatchesPozzed</span>(</span>)</span></span> {</span>
</span></span>	try</span> {</span>
</span></span></span>		ClassPath</span>.</span>from</span>(</span>BoSCoVicinoLoader</span>.</span>class</span>.</span>getClassLoader</span>(</span>)</span></span>)</span></span>
</span></span></span>			.</span>getAllClasses</span>(</span>)</span></span>
</span></span></span>			.</span>stream</span>(</span>)</span></span>
</span></span></span>			.</span>filter</span>(</span>ci</span></span> -></span> {</span>
</span></span></span></span></span></span>				try</span> {</span>
</span></span></span></span></span></span></span>					return</span> hasAnnotation</span>(</span>ci.</span>getName</span>(</span>)</span></span>)</span></span>;</span>
</span></span></span></span></span></span></span>				}</span></span> catch</span></span>(</span>IOException</span> e</span>)</span></span></span> {</span>
</span></span></span></span></span></span></span>					throw</span> new</span> RuntimeException</span>(</span>e)</span></span></span>;</span>
</span></span></span></span></span></span></span>				}</span></span>
</span></span></span></span></span></span>			}</span></span></span>)</span></span>
</span></span></span>			.</span>map</span>(</span>ClassPath</span>.</span>ClassInfo</span>::</span>load</span>)</span></span>
</span></span></span>			.</span>forEach</span>(</span>patch</span></span> -></span> {</span>
</span></span></span></span></span></span>				patchClasses.</span>put</span>(</span>patch.</span>getAnnotation</span>(</span>Patch</span>.</span>class</span>)</span></span>.</span>value</span>(</span>)</span></span>,</span> patch)</span></span>;</span>
</span></span></span></span></span></span>				LOGGER</span>.</span>info</span>(</span>"</span>Found patch class {}"</span></span>,</span> patch.</span>getName</span>(</span>)</span></span>)</span></span>;</span>
</span></span></span></span></span></span>			}</span></span></span>)</span></span>;</span>
</span></span></span>	}</span></span> catch</span></span>(</span>IOException</span> e</span>)</span></span></span> {</span>
</span></span></span>		e.</span>printStackTrace</span>(</span>)</span></span>;</span>
</span></span></span>	}</span></span>
</span></span>}</span></span>
</span></code></pre>
Aaaand... nope. This issue drove me crazy, but eventually I figured it out: in Guava 21, the version bundled with forge, the ClassPath</code> object is marked with @Beta</code>. I must've missed the convention at which they changed the definition of "Beta" from "experimental" to "doesn't really work at all". I "solved" by pasting the newer, fixed version of ClassPath into our JAR. I really wanted to see if all the stuff I wrote worked properly.</p>
And... it didn't. Rather, it kind of</em> did. It didn't work when I built it, but it did when I tested it with ForgeGradle's runClient</code> task. Why? runClient doesn't reobfuscate. Apparently, methods are passed with their Searge names. I dwelved deep into Mixin code, failed to use their stuff, and then turned to Forge. However, ObfuscationReflectionHelper.remapName()</code> didn't work either.</p>
I called it a day, but first updated the co-developer about my progress. I told him that probably Forge does bundle the mapping csv in its JAR, so we could realistically receive it with addResources()</code>, another method of the ILaunchPlugin</code> interface.</p>
The rewrite</h3>
The next day I didn't do much, and the other guy took over. He spent the whole day researching it, and eventually figured it out: I was right in saying that addResources()</code> was our way out of this mess, but not in the way I thought. Apparently, that thing also passes us all the Forge JARs: therefore, we could use it to receive our patches. My quick-and-dirty fix was no longer needed.</p>
The obfuscation problem remained unsolved, however, so we opted - for now - to write descriptors and obf name by hand. He deleted most of what I wrote, and rewrote it in a simpler, slimmer way. He likes fors more than Streams, unfortunately, but I suppose that makes the code more readable for those that don't know Java. I don't really see what people that don't know Java could gain from reading our Java plugin for a Java loader in a Java game, but whatever.</p>
I digress. His new system, though slightly uncomfortable for the developer, worked decently enough. Every patch is now a service of its own: you must register the patch in the META-INF as a service implementing our IInjector</code> interface. We plan to mitigate the unfortunate side effects of this approach with a Gradle plugin or something like that, but we haven't come around to it yet.</del> Meet Lillero-processor</strong></a>, capable of mitigating the considerable amount of boilerplate code needed to run this.</p>
All that was left now was to split the loader from the mod. We called our new creature Lillero</strong> - lll</code> for short - keeping in theme with our other names. Don't worry: you're not ignorant if you don't get it, you're just not an Italian born around the turn of the millennium. You can take a look at its code here</a>.</p>
The more perceptive among you may have noticed that something's missing. And you are correct: we split it into three, not two. After some debating, we figured that we should distribute the "library part" - at the time only the IInjector</code> - separately from the plugin and client, so that both may implement it as a dependency without bringing in extra stuff. Admire our library - stripped of Javadocs for space constraints:</p>
package</span> ftbsc.</span>lll</span></span></span>;</span>
</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>tree</span>.</span>ClassNode</span></span></span>;</span>
</span>import</span> org</span></span>.</span>objectweb</span>.</span>asm</span>.</span>tree</span>.</span>MethodNode</span></span></span>;</span>
</span>
</span>public</span> interface</span> IInjector</span></span> {</span>
</span></span></span></span>	String</span> name</span></span>(</span>)</span></span></span></span>;</span>
</span></span></span></span>
</span></span></span></span>	default</span> String</span> reason</span></span>(</span>)</span></span></span> {</span></span></span></span> return</span> "</span>No reason specified"</span></span>;</span> }</span></span></span>
</span></span></span></span>
</span></span></span></span>	String</span> targetClass</span></span>(</span>)</span></span></span></span>;</span>
</span></span></span></span>
</span></span></span></span>	String</span> methodName</span></span>(</span>)</span></span></span></span>;</span>
</span></span></span></span>
</span></span></span></span>	String</span> methodDesc</span></span>(</span>)</span></span></span></span>;</span>
</span></span></span></span>
</span></span></span></span>	void</span> inject</span></span>(</span>ClassNode</span> clazz</span>,</span> MethodNode</span> method</span>)</span></span></span></span>;</span>
</span></span></span></span>}</span></span></span></span>
</span></code></pre>
The Helpers</h3>
Patching in itself can, at times, be slightly uncomfortable: with such a low-level language, you often find yourself working with parts that can and should be automated. Working on our ForgeHax fork, we'd been cuddled by the gigantic suite of helpers that the original developer created. We need</em> helpers here, so I got to work on writing them.</p>
I suppose this is as good a time as ever to credit fr1kin, the developer of ForgeHax. I really did write these helpers from scratch, but they ended up looking very similar to an upgraded version of ForgeHax's own. Call it force of habit, I guess. Anyway, enough premises. At the time I'm writing this, the helper counts three exceptions - which I'm not going to cover, they do nothing special - and four helper classes.</p>
The crown jewel is the PatternMatcher</a>: a class, featuring a fancy builder, capable of finding specific sequences of opcodes. Or also not-specific ones. It's very versatile. And it does reverse lookups - from the end of the method, rather than from the beginning.</p>
What does it return? It returns an InsnSequence</a>. It's an extension of InsnList</a> that does a bunch of fancy tricks. Not sure how useful they are going to be to us or others, but they were pretty fun to code.</p>
Then come the StackUtils</a>, a collection of static methods that can do stuff like instantiating objects and creating new local variables in the ASM code. This is perhaps the part most reminiscing of fr1kin's code; though, to be fair, there are only so many ways to achieve such simple tasks.</p>
Finally, the DescriptorBuilder</a>, like the name suggests, tries to spare us the hassle of writing descriptors by hand.</p>
Surprisingly, I seem to have gotten these right on my first try: we tested (some of) them after finishing this, and they worked just fine.</p>
And... that's it, for now. I'll probably make a follow-up if/when we come around to solving the obfuscation problem. But until then, I hope this was helpful to you.</p>
Conclusions</h2>
Although highly experimental, our ASM patching API is now in a somewhat usable state. You can find detailed instructions by checking the README of lillero</a> and lillero-loader</a>. Do note that, while we will keep the old JARs on our maven repo, until they hit version 1.0.0 they are going to be subject to frequent, and probably unannounced, changes.</p>
As soon as it's a bit more stable, we'll put it on GitHub too, so you all can do some pull requests to help us improve. Well, I know that's unrealistic, but a man can dream...</del></p>
They're now on GitHub: lillero</a> and lillero-loader</a>.</p>


Lillero
2023-01-19T18:30:00+01:00
Lillero is a Java bytecode patching framework built on top of the better known ASM</a> library. It enables anyone to patch any Java program in multiple spots with relative ease, avoiding boilerplate code and repetitive tasks as much as possible.</p>
The Lillero (or lll</code> for short) ecosystem is made up of multiple components:</p>

The Library</a> (javadoc</a>)</li>
The Processor</a> (javadoc</a>)</li>
The Loader</a> (javadoc</a>)

The Mixin Loader</a> (javadoc</a>)</li>
</ul>
</li>
The Mapper</a> (javadoc</a>)</li>
The Mapping Writer</a> (javadoc</a>)</li>
The Gradle plugin</a></li>
</ul>
Finally, you can read the Book</a>, a (work in progress) guide to the Lillero/ASM ecosystem, and to JVM bytecode patching in general.</p>


BoSCoVicino
2022-01-19T18:30:00+01:00
A Minecraft (Java) utility mod, which was the initial project from whom Lillero branched out. It's a group effort with the others over at ftbsc</a>. I myself mostly worked on the plumbing, rather than the actual utilities.</p>
You can find the main project hub on our cgit here</a>.</p>

  
  
</div>
zaaarf.foo

ZipDist

jni-toolbox

codemp

A new home

GEB

To kill a boilerplate - a dev diary

Conclusions</h2> Honestly, writing this was actually fun. It's just a shame that the documentation was that sparse - I spent far more time looking up stuff than actually writing code.</p>

OpenVic

Don't do coremods - a dev diary

Lillero

BoSCoVicino
