I named it after flux paste used in soldering.
https://github.com/kvthweatt/Flux
Here's reversing bits:
```
#import "standard.fx";
using standard::io::console;
def main() -> int { byte x = 55;
x[0``7] = x[7``0];
println(int(x));
return 0;```
You can take bit slices of bit slices as well like `[x``y][a``b]`
Flux has seamless FFI with C, everything is stack allocated by default including pointers, and everything is zero initialized by default. You can opt-in to uninitialized declaration like:
`int x = noinit;`
You can also assign arbitrary bytes to a function pointer, and if its valid machine code for your arch, you can execute that function. Example:
```
#import "standard.fx";
def main() -> int { byte[] some_bytecode = [0x48, 0x31, 0xC0, 0xC3]; // xor rax,rax ; ret
def{}\* fp()->void = @some_bytecode;
fp();
return 0;```
Flux has macros, and contracts, and the ability to put contracts on operators:
```
#import "standard.fx";
using standard::io::console;
contract NonZero(a,b) { assert(a != 0, "a must be nonzero"); assert(b != 0, "b must be nonzero"); };
operator(int x, i32 y)[+] -> int : NonZero(a,b) { return x+y; };
def main() -> int { 0 + 4; // runtime error
return 0;```
C:
```
len_block[0] = (byte)((aad_bits >> 56) & 0xFF);
len_block[1] = (byte)((aad_bits >> 48) & 0xFF);
len_block[2] = (byte)((aad_bits >> 40) & 0xFF);
len_block[3] = (byte)((aad_bits >> 32) & 0xFF);
len_block[4] = (byte)((aad_bits >> 24) & 0xFF);
len_block[5] = (byte)((aad_bits >> 16) & 0xFF);
len_block[6] = (byte)((aad_bits >> 8) & 0xFF);
len_block[7] = (byte)( aad_bits & 0xFF);
len_block[8] = (byte)((cipher_bits >> 56) & 0xFF);
len_block[9] = (byte)((cipher_bits >> 48) & 0xFF);
len_block[10] = (byte)((cipher_bits >> 40) & 0xFF);
len_block[11] = (byte)((cipher_bits >> 32) & 0xFF);
len_block[12] = (byte)((cipher_bits >> 24) & 0xFF);
len_block[13] = (byte)((cipher_bits >> 16) & 0xFF);
len_block[14] = (byte)((cipher_bits >> 8) & 0xFF);
len_block[15] = (byte)( cipher_bits & 0xFF);
```
Flux equivalent
```
len_block[0..7] = (byte[8])(u64)aad_bits;
len_block[8..15] = (byte[8])(u64)cipher_bits;
```
Reworking a loop:
```
for (i = 0; i < 4; i++) { hash[i] = (byte)((ctx.state[0] >> (24 - i * 8)) & 0xFF);
hash[i + 4] = (byte)((ctx.state[1] >> (24 - i \* 8)) & 0xFF);
hash[i + 8] = (byte)((ctx.state[2] >> (24 - i \* 8)) & 0xFF);
hash[i + 12] = (byte)((ctx.state[3] >> (24 - i \* 8)) & 0xFF);
hash[i + 16] = (byte)((ctx.state[4] >> (24 - i \* 8)) & 0xFF);
hash[i + 20] = (byte)((ctx.state[5] >> (24 - i \* 8)) & 0xFF);
hash[i + 24] = (byte)((ctx.state[6] >> (24 - i \* 8)) & 0xFF);
hash[i + 28] = (byte)((ctx.state[7] >> (24 - i \* 8)) & 0xFF);```
Turns into:
```
hash[0..3] = (byte[4])ctx.state[0];
hash[4..7] = (byte[4])ctx.state[1];
hash[8..11] = (byte[4])ctx.state[2];
hash[12..15] = (byte[4])ctx.state[3];
hash[16..19] = (byte[4])ctx.state[4];
hash[20..23] = (byte[4])ctx.state[5];
hash[24..27] = (byte[4])ctx.state[6];
hash[28..31] = (byte[4])ctx.state[7];
```
Would love to take questions and see if anyone finds it useful for anything.
0 comments