#func-swap
swap functions!

This crate is a macro that allows for you to define a function which can be
hotswapped at runtime with another function (of the same symbol). The swap
is memory safe even in concurrent systems. The over head is just a pointer
load, and an `if != 0` jump at the start of your function (on AMD64/ARMv8).
On older arm there is a load memory barrier on call this are the cheapest
barriers generally.  

Replacing a function does trigger a full `Ordering::SeqCst` memory barrier
to ensure that all future calls will see the new function.

To use this crate include

```
[dependencies]
func_swap = "0.0.1"
lazy_static = "0.2.*"
```

Example Usage:

```rust
#[macro_use]
extern crate func_swap;
#[macro_use]
extern crate lazy_static;

//define the add function so it is replaceable
modfunc!(replace,FP, add(x: u64, y: u64) => u64{
	x + y
});
assert!( add(5u64,2u64) == 7u64);

//define a completely different function
fn not_addition(x: u64, y: u64) -> u64 {
	(x*x)+y
}

//swap the values
replace(not_addition);
assert!( add(5u64,2u64) == 27u64);
```

To demystify the macro:

```
modfunc!(
	SWAP_FUNCTION: ident,		//define a function to swap functions
	FUNCTION_POINTER: ident,	//define a constant, this name will really shouldn't be used
	SWAPPABLE: ident		//define the main function
	( var:type, var2:type)		//args
	type OR (type,type,...)		//return values
	{
		//body of your function
	});
```

##Question and Answer:

###Can I use generics?

No-ish. Function signatures need to be concrete and known at compile time.
You likely can get away with TraitObjects. But I haven't tested this. YYMV

###Can I capture values?

No. This is not a lambda expression this is defining a static function.

###Can I swap with functions that I load via dynamic linking?

Yes. But use this with care. When you unload the library some flags will
invalidate the existing function pointers. Which may cause the function
to call into un-allocated virtual memory... leading to a SEGFAULT. 

If you unload a function ensure you set the value to NULL. `unsafe{mem::transmute(0usize)`. This will restore default behavior.

###What ABI is used by default?

The `extern "Rust"` ABI is used. It should be noted this is non-stable. So
if you are dynamically linking use SO's/DLL's generated with the same
revision of the Rust-Compiler.

###Can I use non-Rust ABI's?

Yes. If you start the macro with `@ABI:` The first argument is an `expr` of
the ABI. This looks like:

```rust
modfunc!(ABI: "C", swap_function, functionptrname, function(args: yada)
```

This feature is no tested heavily YMMV. It also should be noted the 
default function will remain a native function.