hexo 0.6.2

Tiny binary writer utility, just enough for you
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# Hexo | 10110

![Crates.io Total Downloads](https://img.shields.io/crates/v/hexo?label=version)
![Crates.io Total Downloads](https://img.shields.io/crates/d/hexo?logo=rust&label=crates.io%20downloads)
![GitHub top language](https://img.shields.io/github/languages/top/lexa-diky/hexo?logo=rust)

![Crates.io License](https://img.shields.io/crates/l/hexo?logo=apache)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/lexa-diky/hexo/build?branch=main&logo=github)

Tiny binary writer utility, just enough for you

## Installation

```bash
cargo install hexo
```

## CLI

### build

Takes `source` file in hexo format and compiles it to binary file `output`

```bash
hexo build --source <path to source> --output <path to output>
```

### watch

Takes `source` file in hexo format and compiles it to binary file `output`. Will recompile on `source` file change

```bash
hexo watch --source <path to source> --output <path to output>
```


## Syntax

### Emitter

To emit a byte use glyph '>' fallowed by byte value:

```hexo
> 0a // by default numbers are interpreted as hexadecimal, will emit decimal 10
> 'HelloWorld' // will emit utf-8 bytes of 'HelloWorld' string
> 10x22 // you can specifiy arbitrary radix in range 2..36, will emit decimal 22
```

### Constants

To declare a constant use glyph '$' fallowed by constant name and value:

```hexo
$ class_name 'HelloWorld'
```

Then you can use it as if you used hex or binary string by prefixing it with '$':

```hexo
> $class_name
```

### Declaring Functions

You can declare arbitrary functions using glyph '#' fallowed by function name and body:

```hexo
# class_declaration {
  > 0100
  > #len($0)
  > $0
}
```

Function arguments are referenced by their index: `$0`, `$1`, `$2`, ...

### Calling Functions

To call a function use glyph '#' fallowed by function name and arguments:

```hexo
> #len('HelloWorld') // will emit length of 'HelloWorld' in bytes (0a)
> #pad_left(0x2, 0a) // will emit '00 0a'
> #pad_right(0x2, 0a) // will emit '0a 00'
```

### Example

Let's write _'HelloWorld'_ Java class bytecode:

```hexo
$ class_name 'HelloWorld'
$ object_superclass_name 'java/lang/Object'

# class_declaration {
  > 0100
  > #len($0)
  > $0
}

> cafe babe // Magic number

> 0000 0034 // Java Bytecode version
> 0005 // Constant pool size
> 0700 02 // Class at index 2

> #class_declaration($class_name)
> 0700 04 // Class at index 4
> #class_declaration($object_superclass_name)

> 0021 // Supper public
> 0001 0003 // Class pointers
> 0000 0000 0000 0000 // No interfaces, fields, methods, attributes
```