Major refactorisation.

~~~
// Initialize an assembler for the target architecture.
let mut asm: ARMAssembler = Assembler::new();

// Create a function buffer, it will contain the generated code.
let mut function = match function::Function::new(4096) {
  Ok(function) => {function},
  Err(error) => {fail!("{}", error);}
};

// Emit instructions into the buffer, using the assembler.
emit!(&mut asm, &mut function,
  Bind("start")
  Add(r0, r0, Immediate(1), LeaveFlags, AL)
  Cmp(r0, Immediate(42), AL)
  B(Label("start"), NE)
  Mov(pc, Reg(lr), LeaveFlags, AL)
);

// Finalize the code before execution.
asm.finalize(&mut function);

// Call the generated code.
let f: fn(int) -> int = function.get_entry();
assert!(f(21) == 42);
~~~

In a nutshel:

* Instructions

  Instructions no longer take care of emitting themselves. Instead they
  implement an `encode` method, which returns an unsigned value.

* Emit

  The `Emit` trait is dependent upon the assembler. It lets the underlying
  Assembler deal with writing the code into the function and where.

  A new macro `emit!` can be used to emit instructions. As general rule,
  anything that implements the `Emit` trait is seen as an instruction. Even if
  it represents a sequence of instruction or if it justs binds an address to a
  label.

* Assembler:

  The `Assembler` trait is very minimal with just `new`, `bind` and `finalize`.
  The latter takes care of resolving addresses and clearing the instruction
  cache.