JASM is an extension of Tomasz's "Assembling JVM bytecode". Features: Minimal macros to create classes, methods, variables, if statements, imports, etc, and this is only the beginning. Includes: 3 examples/templates with .BAT scripts.



Download: Click Here

Console:


JFrame Application:


Applet:

Whoa. Programming in Java bytecode.
This is seriously awesome

i think this is kinda cool!

I am not familiar with the Java execution environment. Is there a benefit to installing the JDK, or is the JRE sufficient? ...seems to work, but maybe I should also install the JDK?

The JDK has documentation of the class libraries, a lot of source code, and a Java compiler. If you don't need any of those, don't bother

Oh, might be one other difference - on Windows, the JRE didn't use to include the server version of the JIT, only the client... they have quite different optimization goals. This is why you'd see benchmark differences between Java on Windows vs. Linux, because server JIT is default on *u*x. Dunno what the situation is now, but iirc the JDK always included both.

JDK is used to compile Java apps from source.
JRE is used only to run Java apps.

I just take a look at the batch files and it seems that JRE is sufficient, because the bytecode generation is done by FASM, and not by Java compiler itself.

WHY JASM?

* Syntax is customizable, extendable
* Understanding of bytecode which can be executed in hardware by some CPUs (example: ARM Jazelle technology)
* Universal translation to/from X86/ARM/Bytecode, portability in every direction
* Easy alternative to writing bytecode directly
* Fast processing. FASM+IDE is a magnitude faster than javac+Eclipse/Netbeans/etc (JCreator is the only IDE I like).
* For smaller OSs to make a JVM emulator

Learning Java Bytecode

* Oracle's Official .CLASS Specification
* All Java Bytecode Instructions - Wikipedia
* "Mastering Java Bytecode with ASM" .PDF animated slideshows. By Anton Arhipov. His teachings are straight forward and easy to understand
* Jasmine Bytecode Assembler. Oldest, first Java Assembler.

Instructional Videos:

* JVM Bytecode for Dummies (and the Rest of Us Too).
* Mastering Java Bytecode with ASM. Anton Arhipov

Disassemble Bytecode

Try my Java Disassembler package. Click DISASSEMBLE.JS.

Usage: In FILENAME.TXT, just replace the first line MAIN with the NAME of your .class (case-sensitive, no .ext) then click DISASSEMBLE.JS. JavaScript will silently run DISASSEMBLE.BAT (no console), get FILENAME.TXT, try to detect JDK directory, run javac silently to output FILE.TXT, then it displays disassembly in text editor. MAIN.BAT is like a mini-library used by other .BAT files. COMPILE.BAT will use javac to compile MAIN.java (standard) to MAIN.class then run it after. RUN.JS/RUN.BAT just executes.

JASM 2-DO List:

It will take time to do all of this by myself:

* #1. Automatic constant pool, names, numbers and literal text, forward references (somehow). Prevent redefinition and duplication of non-unique values/entries. In the meantime, users must manually create all class/field/method names and indices.

* #2. Type recognition and safety. It should store types/sizes/etc internally and use appropriate instructions

* Error checking. Extremely important. If a macro fails to detect syntax errors, it will generate incorrect code without warning, or even worse, no code at all or the error messages may be totally misleading. An example is a HL IF/LOOP block that always executes once. When this occurs, chances are, macro did not produce code, failed match with no verification. New "syntax" and "verify" keywords to minimize this.

* Names of parameters and locals. In standard bytecode, you refer to locals and parameters by index #. One trick is to create a numeric constant that = index. Example: Replace iload 3 with n=3 then iload n. From here on, n = index #3 until it's reassigned. See APPLICATION.ASM > Font f

* Members and local variables. Example: int a=1, char b='Z', String c='Future JASM'

* Method calls with parameters. Example: aload f | iconst_1 | call JFrame.setVisible() should be replaced with just: f.setVisible(1) Type must be known first. Instance is the invisible first parameter. Example: g.drawString("X", 8, 16) = call Graphics.drawString(g, "X", 8, 16)

* HL assignments and arithmetic: . a=b ; JVM stack-based architecture would make it easy to convert infix expressions with its predefined stack, arithmetic and unlimited "registers".

* HL blocks: .if/.else/.while/.for/.loop/.repeat.

* Imports should be easier and more versatile. Example: import JFrame:setTitle(String)(void), JFrame:setVisible(int)(void).

With these improvements, JASM could realistically be used for serious development with the option to write pure bytecode inside asm-enda (asm {}) block. Preview of what JASM could be:



JASM may be a way for FASM programmers to finally get paid by making Java applications for the Android market (if anyone could find documentation on the internals of .APK).

What if we convert FASM to bytecode? Just the preprocessor+directives, not the actual assembler. Someday, I'd like to create a "Pocket Assembler" + IDE that supports X86+ARM+Bytecode + emulator. Then a HL compiler that generates code for any custom CPUs+OSs. In theory, one could be programming on an Android phone/tablet for WinX/Linux/X360/PS3/etc and vice versa.

TmX wrote: Yes, that's the beauty of it

FASM is the most efficient, powerful preprocessor that I've ever seen, 1,000s of times faster and smaller than M$ compilers (though I wish FASM had a way to load/save/run external files, fsave would be opposite of file 'my.bmp'. Then we could eliminate these .BATs).

A common misconception is that FASM is all about writing X86 assembler. It's not. We don't really need the assembler aspect of FASM that converts instructions, only the preprocessor + directives, that runs before (and while) assembly. We can use db/dw/dd/etc to define unrecognized CPU instructions and OS file formats.

[ Post removed by author. ]

a sort of macro based assembler can be interresting.



in fact, we don't need a compiler with a build in instruction set. but a compiler than accepts a macro include, and let the user write code based only on macros defined before.

the syntax of the operands and the tricks to declare/exploit address is the interresting part of fasm.

Quick logo sketch (5 minutes):

and of course my awesome DNS filter.




HMM. Really ?

Zymic (zxq.net) servers went down again So, all of my images and downloads disappear until they restore. Wait about 1-4 days. A server from my own PC (I32 netbook) is impossible because I don't have my own internet service (use neighbor's and nearby WIFI modems).

is that writing java in assembly this is awesome tho i have never tried to understand java anyway thank you

I can't download, could you give a new address??

Wait until he pays his bills. Or you can simply donate $100 to my PayPal account.

Hi uart777,
is there a Linux version of your environment?

It is possible to make a version for all OS so?

I think the problem is the "CASE INSENSITIVE" methods including files....

Many thanks

Anyone try this with .Net byte code yet?

At any rate, nice project here uart. This stuff should be interesting.

uart, excuse me for the answer. I would like to know how to import other classes and how to import and use their methods. I can not, I would like to know how it can be done. Would you help me? Thank you. (I'm a newbie, I ask idiotic questions by nature).