Saturday, 15 August 2015

AbstractCode released

Hey guys,

Long time no post I know, but I came back with a release of a project I've been working on for quite a while already.

AbstractCode is an open source compiler front-end that allows you to set up a compiler, interpreter or analyser for code written in any programming language, using a consistent type system.

Primarily the goal of this project was to provide a centralised type system and robust parser engine for LiteDevelop, my open source Integrated Development Environment (IDE), to make certain features like good provision of suggestions, detection of syntax errors, and refactory of source code, possible.

Currently it only supports C# code, but it shouldn't be very hard to add other languages like VB.NET because of the convenient way of defining languages.

Also the error checking is not as great yet, but hopefully that will come in the future!

Test application showing parsed C# code.
Test application showing resolution of expressions.

Check it out on the github repository at

Saturday, 28 February 2015

AsmResolver v2.0 going live

Hello all!

Today I'd like to announce I have committed and uploaded the newer version of AsmResolver. This includes all updates I have been talking in my previous posts. It is no where near finished, but I felt like it has reached a stage to be able to be released into the public.

If you want, take a look at it and fork the project ;). I have included a readme with a quick startup guide.

If you still desire to use the old version of AsmResolver, I created a second branch of the project still containing the old code. You can access it at the following link:


Sunday, 15 February 2015

AsmResolver - X86 disassembler engine

What is up guys,

A short post for today. I'd like to share with you that AsmResolver now has a revamped x86 disassembler engine. So far I have added support for almost all single byte opcodes as mentioned here.

Source to disassemble an application.
Left: AsmResolver - Right: CFF Explorer
I'll be making a commit to github soon (hopefully :D)

Friday, 6 February 2015

Importing member references and writing MSIL

Hey guys,

Today I'd like to tell you that I just completed the basic mechanism of the MSIL Assembler and the member importer. Using macros like the function ImportMember, it is possible to import member references by providing a System.Reflection object, such as an instance of a MethodInfo. This way there is no need anymore to create all the references yourself.

The following code creates a new method and writes some code to print out the number 1337. It is still required to set some magic numbers, but those will be gone soon.

I'll be uploading the first commit soon to a new branch of the github repository soon. So why don't you star the repository immediately :p ?

Anyhow, that's all for this post. 

Monday, 2 February 2015

A working application produced by AsmResolver

Hey guys,

Finally, after hours of thinking and writing lots of code, I managed to get to a very important milestone. Today, AsmResolver has rebuilt his very first application! Right now it only supports very simplistic assemblies, but after I have done some extra tweaking and optimisations, AsmResolver will be able to build the more complex ones as well.

Using the following code, we can add meta data to the application, such as type references, method definitions and more.

That's all for the time-being. See ya!

Tuesday, 27 January 2015

A fresh start

Hi everyone.

After months of not releasing anything, I finally decided to post something again on my blog, even though this will be a rather short message. I am here to show you a sneak peek of my current project. Can you guess what application is getting revamped ?

I hope this time the project will have proper writing capabilities ;)
See ya !

Sunday, 24 August 2014

AbstractCode - New compiler front-end

Hey guys,

It's been a while, I know, and the reason for that is that I've been working on something rather big and ambitious for a while again.

Today I present you AbstractCode, a compiler front-end framework. This framework allows you to parse source codes written in C# (and VB.NET, however its development is way behind the C# parser), and access it through a so called Abstract Syntax Tree or AST for short. Furthermore, this will allow you to resolve member references specified in the code, such as type or variable references. It will also detect some of the syntax errors as well as some deeper analysis such as ambiguity and unknown identifiers. When the AST is acquired from the input source code, it is possible to add and remove members to the tree or modify them. Last but not least, after applying modifications to the AST, it is possible to write formatted C# and VB code from it again.

Below are some screenshots of the test application I quickly made. The left side is where the input code should be typed in, and the TreeView at the right represents the AST that is being generated from the source.

 When we try to resolve an identifier, such as the "Console" word in the example below, we get an instance of a ResolveResult class that gives us information about the identifier.

 It also works with local variables and members defined in the source itself. Below an example of the resolution of the identifiers x and MyObject in the MyMethod method which are both declared in the source.

This engine can be used for deep analysis of source codes, give suggestions like IntelliSense of Visual Studio, or refactor the code by renaming symbols or improving the source code by adding some modifications. In the end this is going to be integrated within LiteDevelop, in order to have a more powerful code editor.

Let me know what you guys think of it.