lljvm | Low Level Java Virtual Machine | Compiler library

I am creating a virtual machine (VM) for an embedded device that runs both C and Java code by compiling both to bytecode. Now I am trying to automate compiling and flashing C applications (Java already works).

A big manual part is taking a .c file and getting it to a format the VM understands. Currently, it works as follows:

1. Boot up a Docker Container while pointing it towards where the .c file is and giving myself bash

   ~$ docker run -i -v /home/git/bytecode_manipulation:/c_files -t lljvm_work /bin/bash

2. Use the configured lljvm-cc tool of the container to convert the .c file while producing a jasmin file (an intermediate for converting to bytecode)

   docker_container$ lljvm-cc test_c_srv.c -o test_c_srv -g3

3. Exit the docker container and run a python script which converts the .j jasmin file to a .uj jasmin file, converts the .uj file to a .class file and puts it in a good folder

   ~$ ./script_j_to_uj.py test_c_srv.j test_srv.uj

I'd like to automate this in a Makefile. Currently, I have a recipe in my makefile that generates .class files for the Java apps, then scoops up all .class files (from either C or Java apps). processes them somewhat further into .raw_ujc files and generates a list of then. Ideally, this would now also generate .class files for the C apps. The recipe:

I'm writing a python script that takes a text file and should produce another text file with certain lines minimally changed.

I keep getting stuck and would appreciate some assistance.

The intention is that from the commandline I can run:

I am developing an OS for embedded devices that runs bytecode. Basically, a micro JVM. In the process of doing so, I am able to compile and run Java applications to bytecode(ish) and flash that on, for instance, an Atmega1284P.

Now I've added support for C applications: I compile and process it using several tools and with some manual editing I eventually get bytecode that runs on my OS. The process is very cumbersome and heavy and I would like to automate it.

Currently, I am using makefiles for automatic compilation and flashing of the Java applications & OS to devices.

All steps, roughly, for a C application are as follows and consist of consecutive manual steps:

(1) Use Docker to run a Linux container with lljvm that compiles a .c file to a .class file (see also https://github.com/davidar/lljvm/tree/master)

(2) convert this c.class file to a jasmin file (https://github.com/davidar/jasmin) using the ClassFileAnalyzer tool (http://classfileanalyzer.javaseiten.de/)

(3) manually edit this jasmin file in a text editor by replacing/adjusting some strings

(4) convert the modified jasmin file to a .class file again using jasmin

(5) put this .class file in a folder where the rest of my makefiles (the ones that already make and deploy the OS and class files from Java apps) can take over.

Current options seem to be just keep using makefiles but this is a bit unwieldly (I already have 5 different makefiles and this would further extend that chain). I've also read a bit about scons. In essence, I'm wondering which are some recommended tools or a good approach for complicated builds.

I have two example class files, one from an example Java app and one from an example C app (compiled to bytecode using LLJVM).

Looking at their outputs, I can see through javap -c -p that for initializing the (static) fields, the Java app shows the following block:

I'm trying to compile under MinGW-64 lljvm, a not-so-big program. But I am stuck on an error that is driving me nuts.

The code is as follows:

backend.h