Create your own programming language (I)

After writing the first article on how to create your own operating system, someone told me that if I could do an article on how to create a programming language. At first I did not pay much attention, but now and in other ways I have learned much more about the creation of programming languages. So let's do a basic programming language, easily embeddable in other programs and that works with a virtual machine that we will also design. Today we have to make the most basic virtual machine.

You are probably wondering: A virtual machine? But isn't that very difficult and does it also slow down the programs? " In contrast, a simple virtual machine is very simple and relatively fast. I have chosen Rust as a language for the virtual machine. But what is it Rust?

Rust installs in Linux In a simple way. However, there is no official parcel. Users of Ubuntu you can add these two PPA: ppa: hansjorg / rust  y ppa: cmrx64 / cargo, users of Arch can use AUR (cargo-git is the package that installs everything). The rest can use:

curl -s https://static.rust-lang.org/rustup.sh | sudo sh

How does a virtual machine work?

If you know how the assembler world works it is exactly the same, with the stack or the stack. If not, I'll explain it to you. Let's imagine the following code:

print 2 + 3

The computer does not understand what 2 + 3 means, nor does it know what order to follow. Computers work with batteries or stacks in which data is accumulated and continuously extracted. That code in our virtual machine should look something like this:

PUSH 2 PUSH 3 ADD PRINT

Basically we would put the 2 on the stack on top, the 3 as well. ADD would pull (i.e. remove it from the stack and get its value) the last 2 items on the stack and add the result to the top of the stack. PRINT would take the last item on the stack and use it to display it to us. Now let's do that in Rust.

We must first define a language for the byte code, we could use an existing one like the one in Java or CLR of .NET / Mono, but we are going to create a more basic one.

https://gist.github.com/a01de8904fd39a442c20

We use hexadecimal notation for each instruction. On high we have put # [deriving (FromPrimitive)], is a peculiarity of Rust and it will help us later to be able to compare the enumeration with bytes directly.

Now we must make a function that executes each of those instructions. For this we must read a byte and compare it with the instructions that we have in the enumeration. If you find any that exist, you must execute your action.

https://gist.github.com/8950ce212a2de2f397f9

We do that to read each byte individually and to execute them:

https://gist.github.com/12e24a1f0dd65e4cd65d

As you can see, we differentiate if we were given the PUSH command (our INTEGER command) before, the next byte will be completely taken to the stack. There we are using two functions that I have not taught you, self.pop () y self.push (), which are obviously in charge of handling the stack.

https://gist.github.com/54147f853a8a2b8c01d9

They are not very complex, but the pop function has error detection mechanisms. In fact, in Rust, if we remove those mechanisms it would give us a compilation error. Now we simply have to call in a program Perin (our virtual machine) and execute a bytecode.

https://gist.github.com/99b1ab461318b3a644d0

That bytecode can be read from a file, but here for simplicity I have stored it in a variable. If we execute it, it will give us the expected result:

Perin v0.1 Perin VM executes FlopFlip bytecode Starting PerinVM instance PerinVM v0.1.0 Integer value 5

All code is available at GitHub under the Apache License 2.0: https://github.com/AdrianArroyoCalle/perin. To compile they must have Job installed and put:

charge build && ./target/main

In the next chapter we will see more about our programming language.