├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── assemble.py
├── disassemble.py
├── main.c
├── nanac.h
├── nanac_builtins.c
├── nanac_vm.c
├── test
    ├── example.asm
    └── example.tst
├── test_main.c
└── tocfile.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.bin
2 | *.o
3 | *.exe
4 | *.pyc
5 | *.a
6 | test/*.out
7 | test/*.exe.tst


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017 Harry Roberts
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CFLAGS = -Wall -Wextra -DNANAC_TRACE -std=c89 -pedantic
 2 | 
 3 | ifdef RELEASE
 4 | OPTFLAGS = -fuse-linker-plugin -flto -O2 -fdata-sections -ffunction-sections -Wl,--gc-sections
 5 | endif
 6 | 
 7 | all: nanac.exe test
 8 | 
 9 | .PHONY: test
10 | test: nanac.exe $(patsubst %.asm,%.test,$(wildcard test/*.asm))
11 | 
12 | libnanac.a: nanac_vm.o nanac_builtins.o
13 | 	$(AR) r $@ $+
14 | 
15 | %.o: %.c
16 | 	$(CC) $(CFLAGS) $(OPTFLAGS) -o $@ -c $<
17 | 
18 | nanac.exe: main.o libnanac.a
19 | 	$(CC) $(CFLAGS) $(OPTFLAGS) -o $@ $< -L. -lnanac
20 | 
21 | clean:
22 | 	rm -f *.o *.bin *.exe *.pyc *.a test/*.bin test/*.c test/*.out test/*.exe test/*.exe.tst
23 | 
24 | %.bin: %.asm
25 | 	./assemble.py $<
26 | 	@echo ""
27 | 
28 | test/%.out: test/%.bin
29 | 	./nanac.exe $< > $@
30 | 
31 | test/%.c: test/%.bin tocfile.py
32 | 	./tocfile.py $< > $@
33 | 
34 | test/%.exe.out: test/%.exe
35 | 	./$< | cut -f 1 -d ' ' > test/$*.exe.out
36 | 
37 | test/%.exe.tst: test/%.tst
38 | 	cat test/$*.tst | cut -f 1 -d ' ' > test/$*.exe.tst
39 | 
40 | test/%.exe: test/%.c test/%.out
41 | 	$(CC) $(CFLAGS) $(OPTFLAGS) -I. -o $@ $< nanac_vm.c test_main.c
42 | 
43 | test/%.exe.diff: test/%.exe.tst test/%.exe.out
44 | 	diff test/$*.exe.tst test/$*.exe.out
45 | 
46 | test/%.test: test/%.diff test/%.exe.diff
47 | 	@echo "Done"
48 | 
49 | test/%.diff: test/%.out
50 | 	diff test/$*.tst $<
51 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Nanac
  2 | 
  3 | Nanac is a tiny C virtual machine, with a small Python two-pass assembler. The portable microcode VM is under 200 lines of C and is fully modular, which allows modules to be added at fruntime or compile-time without changing the assembler or core VM code.
  4 | 
  5 | ### Features
  6 | 
  7 |  * 256 registers, no stack, 16bit address space
  8 |  * Register windows for subroutines
  9 |  * Easy and quick to modify and experiment
 10 |  * Typeless registers, `void*`, for extensibility
 11 |  * No heap allocation in VM core
 12 |  * Microcontroller friendly
 13 |  * Clean portable C89 / ANSI-C code
 14 |  * Auto-updating (dis)assembler
 15 |  * Bytecode to C translator
 16 |  * Highly modular (can even add opcodes at runtime)
 17 | 
 18 | 
 19 | ## Example.asm
 20 | 
 21 | ```asm
 22 | $ZERO 0   # Friendly names for registers
 23 | $ONE 1
 24 | 
 25 | :start  jmp to :main
 26 | :exit   jmp die
 27 | :main
 28 |     reg mov $ZERO $ONE
 29 |     reg swp $ONE $ZERO
 30 |     cnd neq $ZERO $ONE
 31 |     jmp to :exit
 32 | 
 33 | :end
 34 |     cnd eq $ZERO $ONE
 35 |     jmp to :exit
 36 | ```
 37 | 
 38 | When executing it will generate a trace:
 39 | 
 40 | ```asm
 41 | @0    jmp to 2 0
 42 | @2    reg mov 0 1
 43 | @3    reg swp 1 0
 44 | @4    cnd neq 0 1
 45 | @6    cnd eq 0 1
 46 | @7    jmp to 1 0
 47 | @1    jmp die 0 0
 48 | ```
 49 | 
 50 | The assembler will generate a listing:
 51 | 
 52 | ```asm
 53 | 00000200 @0    jmp to :main   # test/example.asm:5
 54 | 00010000 @1    jmp die    # test/example.asm:6
 55 | 02000001 @2    reg mov $ZERO $ONE  # test/example.asm:8
 56 | 02020100 @3    reg swp $ONE $ZERO  # test/example.asm:9
 57 | 01010001 @4    cnd neq $ZERO $ONE  # test/example.asm:10
 58 | 00000100 @5    jmp to :exit   # test/example.asm:11
 59 | 01000001 @6    cnd eq $ZERO $ONE  # test/example.asm:14
 60 | 00000100 @7    jmp to :exit   # test/example.asm:15
 61 | ```
 62 | 
 63 | 
 64 | ## Using and Extending
 65 | 
 66 | The builtins and vm are contained in `libnanac.a` and `nanac.h` which can be
 67 | included in projects as a git submodule. Build with:
 68 | 
 69 | ```
 70 | git submodule add https://github.com/HarryR/nanac
 71 | cc -o myproject.exe -Inanac myproject.c -Lnanac -lnanac
 72 | ```
 73 | 
 74 | ### Implementing a native command
 75 | 
 76 | All commands have the same interface, they are passed the CPU context pointer and
 77 | two 8 bit values from the data half of the opcode. Each opcode is 4 bytes, two
 78 | indicating the module and command, then two arbitrary arguments.
 79 | 
 80 | Access registers through `nanac_reg_get` and `nanac_reg_set`, all registers are
 81 | a union type called `nanac_reg_t`.
 82 | 
 83 | ```c
 84 | int reg_mov( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 85 | {
 86 |     nanac_reg_set(cpu, arga, nanac_reg_get(cpu, argb));
 87 |     return NANAC_OK;
 88 | } 
 89 | ```
 90 | 
 91 | ### Registering a native module
 92 | 
 93 | ```c
 94 | int jmp_to( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 95 | {
 96 |     // ...
 97 |     return NANAC_OK
 98 | }
 99 | 
100 | static const nanac_cmd_t _cmds_jmp[4] = {
101 |     {"to", &jmp_to},
102 |     {"die", &jmp_die},
103 |     {"sub", &jmp_sub},
104 |     {"ret", &jmp_ret},
105 | };
106 | nanac_mods_add(mods, "jmp", 4, _cmds_jmp);
107 | ```
108 | 
109 | ### Example host program
110 | 
111 | ```c
112 | int main( int argc, char **argv )
113 | {
114 |     struct nanac_mods_s mods;
115 |     struct nanac_s ctx;
116 |     int ret;
117 | 
118 |     nanac_mods_init(&mods);         /* setup standard built-in modules + commands */
119 |     nanac_mods_builtins(&mods);
120 |     
121 |     nanac_init(&ctx, &mods);        /* initialise context/CPU with the modules */
122 | 
123 |     if( load_file(&ctx, argv[1]) )  /* load bytecode file into ctx.ops */
124 |     {
125 |         ret = nanac_run(&ctx);
126 |         if( ctx.ops )
127 |             free(ctx.ops);  /* free loaded file */
128 |     }
129 | 
130 |     return ret;
131 | }
132 | ```
133 | 
134 | 
135 | ## Opcodes and Instructions
136 | 
137 |  The machine uses 32bit operations encoded as 4 independent bytes:
138 | 
139 |  * module ID `uint8`
140 |  * cmd ID `uint8`
141 |  * arg A `uint8`
142 |  * arg B `uint`
143 | 
144 | New operations are registered as modules containing commands in your programs source code,
145 | the module and cmd IDs, when new modules are added the assembler & disassembler automatically update their instructions.
146 | 
147 | There are `2^8` registers, each is a native sized `void*` pointer.
148 | 
149 | There can be up to `2^16` operations (256 kilobytes of code), the instruction pointer `eip` is 16bit.
150 | 
151 | Basic Modules:
152 | 
153 |  * `jmp` - Jumps and subroutines
154 |  * `cnd` - Conditionally execute the next opcode
155 |  * `reg` - Register manipulation
156 | 
157 | Other modules must be implemented by the user.
158 | 
159 | ### `jmp` module
160 | 
161 |  * `to :label` - Immediate jump to an absolute address
162 |  * `die` - Terminate program
163 |  * `sub :label` - Enter sub-routine, allowing for `ret` to return
164 |  * `ret $A $B` - Load opcode from register A, reduce register window by B, run temporary opcode
165 | 
166 | 
167 | ### `cnd` module
168 | 
169 |  * `eq $A $B` - If $A and $B are equal, execute next instruction
170 |  * `neq $A $B` - If $A and $B aren't the same, execute next instruction
171 |  * `nil $A $B` - f either $A or $B are uninitialised (`NULL`), execute next instruction
172 |  * `nz $A $B` - If either $A or $B are *not* uninitialised (`NULL`), execute next instruction
173 | 
174 | ### `reg` module
175 | 
176 |  * `swp $A $B` - Swap register B with register A
177 |  * `mov $A $B` - Copy register B to register A
178 |  * `crl $A $B` - Reset registers A and B to an uninitialised state (e.g. `NULL`)
179 |  * `win $A $B` - Increment register window by $A, decrement by $B


--------------------------------------------------------------------------------
/assemble.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | from __future__ import print_function
  3 | import sys
  4 | import re
  5 | import struct
  6 | import os
  7 | 
  8 | 
  9 | RX_LINE = re.compile(r"""
 10 | ^
 11 | (
 12 | 	(
 13 | 	 ((?P<label>:[a-zA-Z0-9]+))?
 14 | 	 (\s*\b
 15 | 		(?P<mod>[a-z]+)\s+
 16 | 		(?P<cmd>[a-z]+)
 17 | 		(\s+
 18 | 			(?P<arga>[:\$]?[a-zA-Z0-9]+)
 19 | 			(\s+
 20 | 				(?P<argb>\$?[a-zA-Z0-9]+)
 21 | 			)?
 22 | 		)?
 23 | 	 )?
 24 | 	)
 25 | 	|((?P<var>\$[a-zA-Z0-9]+)\s+(?P<val>[0-9]+))	
 26 | )?
 27 | (\s*\#.*)?
 28 | $
 29 | """, re.VERBOSE)
 30 | 
 31 | 
 32 | def parse_instructions():
 33 | 	ops = os.popen("./nanac.exe -X").read()
 34 | 	out = dict()
 35 | 	for line in ops.split("\n"):
 36 | 		line = line.strip()
 37 | 		if not line:
 38 | 			continue
 39 | 		line = line.split()
 40 | 		out[(line[2], line[3])] = (int(line[0],16), int(line[1],16))
 41 | 	return out
 42 | 
 43 | 
 44 | class Opcode(object):
 45 | 	def __init__(self, mod, cmd, arga, argb, source=None):
 46 | 		self.eip = None
 47 | 		self.source = source
 48 | 		self.mod = mod
 49 | 		self.cmd = cmd
 50 | 		self.arga = arga
 51 | 		self.argb = argb
 52 | 
 53 | 	def __str__(self):
 54 | 		return "@%-04X %s %s %s %s  # %s:%s" % (
 55 | 			self.eip, self.mod, self.cmd,
 56 | 			self.arga if self.arga else "", self.argb if self.argb else "",
 57 | 			self.source[0], self.source[1]
 58 | 			)
 59 | 
 60 | 	def resolve(self, asm):
 61 | 		mod, cmd = asm.ins[(self.mod, self.cmd)]
 62 | 
 63 | 		arga = self.arga
 64 | 		argb = 0
 65 | 		if arga is None:
 66 | 			arga = 0
 67 | 		else:
 68 | 			if isinstance(arga, str):
 69 | 				if arga[0] == ':':
 70 | 					arga = asm.labels[arga].eip
 71 | 				elif arga[0] == '$':
 72 | 					arga = asm.vars[arga]
 73 | 			arga = int(arga)
 74 | 
 75 | 			argb = self.argb
 76 | 			if argb is None:
 77 | 				argb = 0
 78 | 			else:
 79 | 				if isinstance(argb, str):
 80 | 					if argb[0] == '$':
 81 | 						argb = asm.vars[argb]
 82 | 				argb = int(argb)
 83 | 
 84 | 		return mod, cmd, arga, argb
 85 | 
 86 | 
 87 | class Assembler(object):
 88 | 	def __init__(self, instructions):
 89 | 		self.labels = dict()
 90 | 		self.vars = dict()
 91 | 		self.ir = []
 92 | 		self.ops = None
 93 | 		self.ins = instructions
 94 | 		self.newlabel = None
 95 | 
 96 | 	def assemble(self, line, filename=None, fileno=None):
 97 | 		match = RX_LINE.match(line)
 98 | 		if not match:
 99 | 			raise RuntimeError("Parse error in %s:%d - %s" % (
100 | 				filename, fileno, line))
101 | 		match = match.groupdict()
102 | 		if match['var']:
103 | 			self.vars[match['var']] = int(match['val'])
104 | 		if match['label']:
105 | 			self.newlabel = match['label']
106 | 		if match['mod']:
107 | 			mod, cmd = match['mod'], match['cmd']			
108 | 			arga = match['arga']
109 | 			argb = match['argb']
110 | 			opcode = Opcode(mod, cmd, arga, argb, source=(filename, fileno))
111 | 			if self.newlabel:
112 | 				self.labels[self.newlabel] = opcode
113 | 				self.newlabel = None
114 | 			self.ir.append(opcode)
115 | 
116 | 	def compile(self):
117 | 		for eip, op in enumerate(self.ir):
118 | 			op.eip = eip
119 | 		self.ops = []
120 | 		for op in self.ir:
121 | 			bytecode = op.resolve(self)
122 | 			print(("%02X%02X%02X%02X " % bytecode) + str(op))
123 | 			self.ops.append(bytecode)
124 | 
125 | 	def assemble_file(self, handle):
126 | 		for idx, line in enumerate(handle):
127 | 			self.assemble(line, filename=handle.name, fileno=idx)
128 | 
129 | 	def write_bytecode(self, handle):
130 | 		if self.ops is None:
131 | 			raise RuntimeError("No opcodes to be written")
132 | 		eip = 0
133 | 		for mod, cmd, arga, argb in self.ops:
134 | 			handle.write(struct.pack("<BBBB", mod, cmd, arga, argb))
135 | 			eip += 1
136 | 
137 | 
138 | def main():
139 | 	instructions = parse_instructions()
140 | 	for filename in sys.argv[1:]:
141 | 		out_filename = os.path.splitext(filename)[0] + ".bin"
142 | 		asm = Assembler(instructions)
143 | 		print("\n# " + out_filename)
144 | 		with open(filename) as handle:
145 | 			asm.assemble_file(handle)
146 | 		asm.compile()
147 | 		with open(out_filename, "wb") as handle:
148 | 			asm.write_bytecode(handle)
149 | 
150 | 
151 | 
152 | if __name__ == "__main__":
153 | 	main()


--------------------------------------------------------------------------------
/disassemble.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | from __future__ import print_function
 3 | import sys
 4 | import re
 5 | import struct
 6 | import os
 7 | 
 8 | 
 9 | def parse_instructions():
10 | 	ops = os.popen("./nanac.exe -X").read()
11 | 	out = dict()
12 | 	for line in ops.split("\n"):
13 | 		line = line.strip()
14 | 		if not line:
15 | 			continue
16 | 		line = line.split()
17 | 		names = (line[2], line[3])
18 | 		nums = (int(line[0],16), int(line[1],16))
19 | 		out[nums] = names
20 | 	return out
21 | 
22 | 
23 | def main():
24 | 	instructions = parse_instructions()
25 | 	for filename in sys.argv[1:]:
26 | 		with open(filename, "rb") as handle:
27 | 			print("\n# " + filename)
28 | 			offset = 0
29 | 			while True:
30 | 				data = handle.read(4)
31 | 				if not data:
32 | 					break
33 | 				mod, cmd, arga, argb = ord(data[0]), ord(data[1]), ord(data[2]), ord(data[3])
34 | 				modstr, cmdstr = '?'+str(mod), '?'+str(cmd)
35 | 				if (mod,cmd) in instructions:
36 | 					modstr, cmdstr = instructions[(mod,cmd)]
37 | 				asmstr = "%s %s %X %X" % (modstr, cmdstr, arga, argb)
38 | 				print("%02X%02X%02X%02X @%-4X  %s" % (mod, cmd, arga, argb, offset, asmstr))
39 | 				offset += 1
40 | 
41 | 
42 | if __name__ == "__main__":
43 | 	main()
44 | 


--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
  1 | #include "nanac.h"
  2 | 
  3 | #include <stdio.h>
  4 | #include <stdlib.h>
  5 | 
  6 | 
  7 | static void load_file (struct nanac_s *cpu, const char *filename)
  8 | {
  9 |     FILE *fp;
 10 |     long lSize;
 11 |     char *buffer;
 12 | 
 13 |     fp = fopen ( filename , "rb" );
 14 |     if( !fp )
 15 |     {
 16 |         perror(filename);
 17 |         exit(1);
 18 |     }
 19 | 
 20 |     fseek( fp, 0L, SEEK_END);
 21 |     lSize = ftell( fp );
 22 |     rewind( fp );
 23 | 
 24 |     if( (lSize < 4) || (lSize % 4) )
 25 |     {
 26 |         fclose(fp);
 27 |         fputs("invalid size",stderr);
 28 |         exit(1);
 29 |     }
 30 | 
 31 |     /* allocate memory for entire content */
 32 |     buffer = calloc( 1, lSize+1 );
 33 |     if( !buffer )
 34 |     {
 35 |         fclose(fp);
 36 |         fputs("memory alloc fails",stderr);
 37 |         exit(1);
 38 |     }
 39 | 
 40 |     /* copy the file into the buffer */
 41 |     if( 1 != fread( buffer, lSize, 1, fp) )
 42 |     {
 43 |         fclose(fp);
 44 |         free(buffer);
 45 |         fputs("entire read fails",stderr);
 46 |         exit(1);
 47 |     }
 48 | 
 49 |     /* do your work here, buffer is a string contains the whole text */
 50 |     cpu->ops = (struct nanac_op_s*)buffer;
 51 |     cpu->ops_sz = lSize / 4;
 52 |     fclose(fp);
 53 | }
 54 | 
 55 | 
 56 | static int print_mods (struct nanac_mods_s *mods)
 57 | {
 58 |     struct nanac_mod_s *mod;
 59 |     unsigned char mod_idx;
 60 |     unsigned char cmd_idx;
 61 | 
 62 |     for( mod_idx = 0; mod_idx < mods->cnt; mod_idx++ )
 63 |     {
 64 |         mod = &mods->idx[mod_idx];
 65 | 
 66 |         for( cmd_idx = 0; cmd_idx < mod->cmds_len; cmd_idx++ )
 67 |         {
 68 |             printf("%02X %02X %s %s\n", mod_idx, cmd_idx, mod->name,
 69 |                 mod->cmds[cmd_idx].name);
 70 |         }
 71 |     }
 72 |     return 0;
 73 | }
 74 | 
 75 | 
 76 | static int print_help (char *name)
 77 | {
 78 |     fprintf(stderr, "Usage: %s [-tX] [file.bin ...]\n", name);
 79 |     fprintf(stderr, "  -t   Trace opcodes at runtime\n");
 80 |     fprintf(stderr, "  -X   Display opcode hex reference\n");
 81 |     return 10;
 82 | }
 83 | 
 84 | 
 85 | int main( int argc, char **argv )
 86 | {
 87 |     int flag_trace = 0;
 88 |     int i = 1;
 89 |     struct nanac_mods_s mods;
 90 |     struct nanac_s ctx;
 91 | 
 92 |     nanac_mods_init(&mods);
 93 |     nanac_mods_builtins(&mods);
 94 | 
 95 |     if( argc < 2 )
 96 |     {
 97 |         return print_help(argv[0]);
 98 |     }
 99 | 
100 |     if( argv[1][0] == '-' )
101 |     {
102 |         char *flags_ptr = &argv[1][1];
103 |         i = 2;
104 |         while( *flags_ptr != 0 )
105 |         {
106 |             switch( *flags_ptr ) {
107 |             case 't':
108 |                 flag_trace++;
109 |                 break;
110 |             case 'X':
111 |                 return print_mods(&mods);
112 |             default:
113 |                 fprintf(stderr, "error: invalid option %c\n", *flags_ptr);
114 |                 return print_help(argv[0]);
115 |             }
116 |             flags_ptr++;
117 |         }
118 |     }
119 | 
120 |     for( ; i < argc; i++ )
121 |     {
122 |         nanac_init(&ctx, &mods);
123 |         load_file(&ctx, argv[i]);
124 |         nanac_run(&ctx);
125 | 
126 |         if( ctx.ops )
127 |         {
128 |             free(ctx.ops);
129 |         }
130 |     }
131 | 
132 |     return 0;
133 | }


--------------------------------------------------------------------------------
/nanac.h:
--------------------------------------------------------------------------------
 1 | #ifndef NANAC_H_
 2 | #define NANAC_H_
 3 | 
 4 | #ifndef NANAC_SETTING_MAXREGS
 5 | #define NANAC_SETTING_MAXREGS 0xFF
 6 | #endif
 7 | 
 8 | #ifndef NANAC_SETTING_MAXCALLS
 9 | #define NANAC_SETTING_MAXCALLS 0xFF
10 | #endif
11 | 
12 | #define NANAC_OK 0
13 | #define NANAC_NO_EPILOGUE 1
14 | #define NANAC_ERROR_DIE (-1)
15 | #define NANAC_ERROR_REGWIN_OVERFLOW (-101)
16 | #define NANAC_ERROR_REGWIN_UNDERFLOW (-102)
17 | #define NANAC_ERROR_STEP_NOMOD (-201)
18 | #define NANAC_ERROR_STEP_NOCMD (-202)
19 | #define NANAC_ERROR_STEP_BADOP (-203)
20 | #define NANAC_ERROR_SUBRET_OVERFLOW (-301)
21 | #define NANAC_ERROR_SUBRET_UNDERFLOW (-302)
22 | 
23 | 
24 | struct nanac_s;
25 | 
26 | struct nanac_op_s {
27 | 	unsigned char mod;
28 | 	unsigned char cmd;
29 | 	unsigned char arga;
30 | 	unsigned char argb;
31 | };
32 | 
33 | 
34 | struct nanac_reg_s {
35 | 	void *ptr;
36 | };
37 | 
38 | 
39 | struct nanac_cmd_s {
40 | 	const char *name;
41 | 	int (*run)( struct nanac_s *cpu, unsigned char arga, unsigned char argb );
42 | };
43 | 
44 | 
45 | struct nanac_mod_s {
46 | 	const char *name;
47 | 	unsigned char cmds_len;
48 | 	const struct nanac_cmd_s *cmds;
49 | };
50 | 
51 | 
52 | struct nanac_mods_s {
53 | 	struct nanac_mod_s idx[0xFF];
54 | 	unsigned char cnt;
55 | };
56 | 
57 | 
58 | struct nanac_s {
59 | 	struct nanac_op_s *ops;
60 | 	unsigned short ops_sz;
61 | 	unsigned short eip;
62 | 	unsigned short call_stack[0xFF];
63 | 	unsigned char call_depth;
64 | 	struct nanac_reg_s regs[0xFF];
65 | 	unsigned char regs_win;
66 | 	struct nanac_mods_s *mods;
67 | };
68 | 
69 | #define nanac_uint16(arga, argb) ( ((arga)&0xFF) | (((argb)&0xFF)<<8) )
70 | 
71 | 
72 | void nanac_mods_init( struct nanac_mods_s *mods );
73 | 
74 | int nanac_mods_add( struct nanac_mods_s *mods, const char *name, const unsigned char cmds_len, const struct nanac_cmd_s *cmds );
75 | 
76 | void nanac_init( struct nanac_s *cpu, struct nanac_mods_s *mods );
77 | 
78 | const struct nanac_op_s *nanac_op( const struct nanac_s *cpu, const unsigned short eip );
79 | 
80 | int nanac_step_epilogue( struct nanac_s *cpu, int ret );
81 | 
82 | int nanac_step( struct nanac_s *cpu, const struct nanac_op_s *op );
83 | 
84 | int nanac_run( struct nanac_s *cpu );
85 | 
86 | struct nanac_reg_s nanac_reg_get(const struct nanac_s *cpu, const unsigned char reg);
87 | 
88 | void nanac_reg_set(struct nanac_s *cpu, const unsigned char reg, const struct nanac_reg_s val);
89 | 
90 | void nanac_mods_builtins ( struct nanac_mods_s *mods );
91 | 
92 | /* ifdef NANAC_H_ */
93 | #endif
94 | 


--------------------------------------------------------------------------------
/nanac_builtins.c:
--------------------------------------------------------------------------------
  1 | #include "nanac.h"
  2 | 
  3 | 
  4 | int reg_swp( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
  5 | {
  6 | 	struct nanac_reg_s tmp = nanac_reg_get(cpu, arga);
  7 | 	nanac_reg_set(cpu, arga, nanac_reg_get(cpu, argb));
  8 | 	nanac_reg_set(cpu, argb, tmp);
  9 | 	return NANAC_OK;
 10 | }
 11 | 
 12 | 
 13 | int reg_mov( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 14 | {
 15 | 	nanac_reg_set(cpu, arga, nanac_reg_get(cpu, argb));
 16 | 	return NANAC_OK;
 17 | } 
 18 | 
 19 | 
 20 | int reg_clr( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 21 | {
 22 | 	static const struct nanac_reg_s zero = {0};
 23 | 	nanac_reg_set(cpu, arga, zero);
 24 | 	nanac_reg_set(cpu, argb, zero);
 25 | 	return NANAC_OK;
 26 | }
 27 | 
 28 | 
 29 | int reg_win( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 30 | {
 31 | 	if( (cpu->regs_win + arga) > NANAC_SETTING_MAXREGS )
 32 | 		return NANAC_ERROR_REGWIN_OVERFLOW;
 33 | 
 34 | 	if( (cpu->regs_win - argb) < 0 )
 35 | 		return NANAC_ERROR_REGWIN_UNDERFLOW;
 36 | 
 37 | 	cpu->regs_win += arga;
 38 | 	cpu->regs_win -= argb;
 39 | 	return NANAC_OK;
 40 | }
 41 | 
 42 | 
 43 | int jmp_to( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 44 | {
 45 | 	cpu->eip = nanac_uint16(arga, argb);
 46 | 	return NANAC_NO_EPILOGUE;
 47 | }
 48 | 
 49 | 
 50 | int jmp_sub( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 51 | {
 52 | 	if( cpu->call_depth >= NANAC_SETTING_MAXCALLS )
 53 | 		return NANAC_ERROR_SUBRET_OVERFLOW;
 54 | 
 55 | 	/* Save EIP in call stack */
 56 | 	cpu->call_stack[cpu->call_depth] = (cpu->eip + 1);
 57 | 	cpu->call_depth += 1;
 58 | 
 59 | 	return jmp_to(cpu, arga, argb);
 60 | }
 61 | 
 62 | 
 63 | int jmp_ret( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 64 | {
 65 | 	if( cpu->call_depth <= 0 )
 66 | 		return NANAC_ERROR_SUBRET_UNDERFLOW;
 67 | 
 68 | 	/* Restore EIP from call stack */
 69 | 	cpu->call_depth -= 1;
 70 | 	cpu->eip = cpu->call_stack[cpu->call_depth];
 71 | 
 72 | 	return reg_win(cpu, arga, argb);
 73 | }
 74 | 
 75 | 
 76 | int jmp_die( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 77 | {
 78 | 	(void)cpu;	/* unused */
 79 | 	(void)arga;	/* unused */
 80 | 	(void)argb;	/* unused */
 81 | 	return NANAC_ERROR_DIE;
 82 | }
 83 | 
 84 | 
 85 | int cnd_common( struct nanac_s *cpu, int success )
 86 | {
 87 | 	/* Skip next opcode if conditional not successful */
 88 | 	if( ! success )
 89 | 		cpu->eip += 1;
 90 | 
 91 | 	return NANAC_OK;
 92 | }
 93 | 
 94 | 
 95 | int cnd_eq( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
 96 | {
 97 | 	return cnd_common( cpu, nanac_reg_get(cpu, arga).ptr == nanac_reg_get(cpu, argb).ptr );
 98 | }
 99 | 
100 | 
101 | int cnd_neq( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
102 | {
103 | 	return cnd_common( cpu, nanac_reg_get(cpu, arga).ptr != nanac_reg_get(cpu, argb).ptr );
104 | }
105 | 
106 | 
107 | int cnd_nil( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
108 | {
109 | 	return cnd_common( cpu, 0 == nanac_reg_get(cpu, arga).ptr || 0 == nanac_reg_get(cpu, argb).ptr );
110 | }
111 | 
112 | 
113 | int cnd_nz( struct nanac_s *cpu, unsigned char arga, unsigned char argb )
114 | {
115 | 	return cnd_common( cpu, 0 != nanac_reg_get(cpu, arga).ptr || 0 != nanac_reg_get(cpu, argb).ptr );
116 | }
117 | 
118 | 
119 | void nanac_mods_builtins ( struct nanac_mods_s *mods )
120 | {
121 | 	static const struct nanac_cmd_s _cmds_jmp[4] = {
122 | 		{"to", &jmp_to},
123 | 		{"die", &jmp_die},
124 | 		{"sub", &jmp_sub},
125 | 		{"ret", &jmp_ret}
126 | 	};
127 | 
128 | 	static const struct nanac_cmd_s _cmds_cnd[4] = {
129 | 		{"eq", &cnd_eq},
130 | 		{"neq", &cnd_neq},
131 | 		{"nil", &cnd_nil},
132 | 		{"nz", &cnd_nz}
133 | 	};
134 | 
135 | 	static const struct nanac_cmd_s _cmds_reg[4] = {
136 | 		{"mov", &reg_mov},
137 | 		{"clr", &reg_clr},
138 | 		{"swp", &reg_swp},
139 | 		{"win", &reg_win}
140 | 	};
141 | 
142 | 	nanac_mods_add(mods, "jmp", 4, _cmds_jmp);
143 | 	nanac_mods_add(mods, "cnd", 4, _cmds_cnd);
144 | 	nanac_mods_add(mods, "reg", 4, _cmds_reg);
145 | }
146 | 


--------------------------------------------------------------------------------
/nanac_vm.c:
--------------------------------------------------------------------------------
  1 | #include "nanac.h"
  2 | #include <string.h>
  3 | #include <stdio.h>
  4 | 
  5 | 
  6 | void nanac_init( struct nanac_s *cpu, struct nanac_mods_s *mods )
  7 | {
  8 | 	memset(cpu, 0, sizeof(*cpu));
  9 | 	cpu->mods = mods;
 10 | }
 11 | 
 12 | 
 13 | void nanac_mods_init( struct nanac_mods_s *mods )
 14 | {
 15 | 	memset(mods, 0, sizeof(*mods));
 16 | }
 17 | 
 18 | 
 19 | int nanac_mods_add( struct nanac_mods_s *mods, const char *name, const unsigned char cmds_len, const struct nanac_cmd_s *cmds )
 20 | {
 21 | 	struct nanac_mod_s *mod;
 22 | 
 23 | 	/* Constrained by uint8 */
 24 | 	if( mods->cnt >= 0xFF )
 25 | 		return 0;
 26 | 
 27 | 	mod = &mods->idx[mods->cnt++];
 28 | 	mod->name = name;
 29 | 	mod->cmds_len = cmds_len;
 30 | 	mod->cmds = cmds;
 31 | 
 32 | 	return 1;
 33 | }
 34 | 
 35 | 
 36 | #define FLAG_VALID(cpu, offset) (offset < (8*sizeof(cpu->flags)))
 37 | 
 38 | 
 39 | const struct nanac_op_s *nanac_op( const struct nanac_s *cpu, const unsigned short eip )
 40 | {
 41 | 	if( eip < cpu->ops_sz )
 42 | 		return &cpu->ops[eip];
 43 | 
 44 | 	return NULL;
 45 | }
 46 | 
 47 | 
 48 | struct nanac_reg_s nanac_reg_get(const struct nanac_s *cpu, const unsigned char reg)
 49 | {
 50 | 	return cpu->regs[(unsigned char)(cpu->regs_win + reg)];
 51 | }
 52 | 
 53 | 
 54 | void nanac_reg_set(struct nanac_s *cpu, const unsigned char reg, const struct nanac_reg_s val)
 55 | {
 56 | 	cpu->regs[(unsigned char)(cpu->regs_win + reg)] = val;
 57 | }
 58 | 
 59 | 
 60 | int nanac_step_epilogue( struct nanac_s *cpu, int ret )
 61 | {
 62 | 	if( ret == NANAC_OK )
 63 | 		cpu->eip += 1;
 64 | 
 65 | 	return ret;
 66 | }
 67 | 
 68 | 
 69 | int nanac_step( struct nanac_s *cpu, const struct nanac_op_s *op )
 70 | {
 71 | 	const struct nanac_mod_s *mod = &cpu->mods->idx[op->mod];
 72 | 	const struct nanac_cmd_s *cmd;
 73 | 
 74 | 	if( ! mod )
 75 | 		return NANAC_ERROR_STEP_NOMOD;
 76 | 
 77 | 	if( op->cmd >= mod->cmds_len )
 78 | 		return NANAC_ERROR_STEP_NOCMD;
 79 | 
 80 | 	cmd = &mod->cmds[op->cmd];
 81 | 
 82 | #ifdef NANAC_TRACE
 83 | 	printf("@%-4X %s %s %d %d\n", cpu->eip, mod->name, cmd->name, op->arga, op->argb);
 84 | #endif
 85 | 
 86 | 	return nanac_step_epilogue(cpu, cmd->run(cpu, op->arga, op->argb));
 87 | }
 88 | 
 89 | 
 90 | int nanac_run( struct nanac_s *cpu )
 91 | {
 92 | 	int escape = 0;
 93 | 
 94 | 	while( escape >= 0 )
 95 | 	{
 96 | 		const struct nanac_op_s *op = nanac_op( cpu, cpu->eip );
 97 | 
 98 | 		if( ! op ) {
 99 | 			escape = NANAC_ERROR_STEP_BADOP;
100 | 			break;
101 | 		}
102 | 
103 | 		escape = nanac_step( cpu, op );
104 | 	}
105 | 
106 | 	return escape;
107 | }
108 | 


--------------------------------------------------------------------------------
/test/example.asm:
--------------------------------------------------------------------------------
 1 | # Example
 2 | 
 3 | $ZERO 0   # Friendly names for registers
 4 | $ONE 1
 5 | 
 6 | :start	jmp to :main
 7 | :exit	jmp die
 8 | :main
 9 | 	reg mov $ZERO $ONE
10 | 	reg swp $ONE $ZERO
11 | 	cnd neq $ZERO $ONE
12 | 	jmp to :exit
13 | 
14 | :end
15 | 	cnd eq $ZERO $ONE
16 | 	jmp to :exit
17 | 


--------------------------------------------------------------------------------
/test/example.tst:
--------------------------------------------------------------------------------
1 | @0    jmp to 2 0
2 | @2    reg mov 0 1
3 | @3    reg swp 1 0
4 | @4    cnd neq 0 1
5 | @6    cnd eq 0 1
6 | @7    jmp to 1 0
7 | @1    jmp die 0 0
8 | 


--------------------------------------------------------------------------------
/test_main.c:
--------------------------------------------------------------------------------
 1 | #include "nanac.h"
 2 | 
 3 | int native_nanac (struct nanac_s *cpu);
 4 | 
 5 | int main( int argc, char **argv )
 6 | {
 7 |     struct nanac_s ctx;
 8 | 
 9 | 	(void)argc;
10 | 	(void)argv;
11 | 
12 |     nanac_init(&ctx, 0);
13 |     return native_nanac(&ctx);
14 | }
15 | 


--------------------------------------------------------------------------------
/tocfile.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | from __future__ import print_function
 3 | import sys
 4 | import re
 5 | import struct
 6 | import os
 7 | import random
 8 | 
 9 | 
10 | def parse_instructions():
11 | 	ops = os.popen("./nanac.exe -X").read()
12 | 	out = dict()
13 | 	for line in ops.split("\n"):
14 | 		line = line.strip()
15 | 		if not line:
16 | 			continue
17 | 		line = line.split()
18 | 		names = (line[2], line[3])
19 | 		nums = (int(line[0],16), int(line[1],16))
20 | 		out[nums] = names
21 | 	return out
22 | 
23 | 
24 | def main():
25 | 	instructions = parse_instructions()
26 | 	offset = 0
27 | 	print("""
28 | #include <stdio.h>
29 | #include "nanac_builtins.c"
30 | int native_nanac (struct nanac_s *cpu) {
31 | 	int escape = 0;
32 | 	while( escape >= 0 ) {
33 | 		escape = 0;
34 | #ifdef NANAC_TRACE
35 | 		printf("@%d\\n", cpu->eip);
36 | #endif
37 | 		switch( cpu->eip ) {
38 | 	""")
39 | 	for filename in sys.argv[1:]:
40 | 		with open(filename, "rb") as handle:
41 | 			cases = []
42 | 			print("/* " + filename + " */")
43 | 			while True:
44 | 				data = handle.read(4)
45 | 				if not data:
46 | 					break
47 | 				mod, cmd, arga, argb = ord(data[0]), ord(data[1]), ord(data[2]), ord(data[3])
48 | 				modstr, cmdstr = '?'+str(mod), '?'+str(cmd)
49 | 				if (mod,cmd) in instructions:
50 | 					modstr, cmdstr = instructions[(mod,cmd)]
51 | 				asmstr = "%s %s %X %X" % (modstr, cmdstr, arga, argb)
52 | 				cases.append("\n".join([
53 | 					"\t\t\tcase %d: /* %02X%02X%02X%02X %s */" % (
54 | 						offset, mod, cmd, arga, argb, asmstr),
55 | 					"\t\t\t\tescape = %s_%s(cpu, %d, %d);" % (modstr, cmdstr, arga, argb),
56 | 					"\t\t\t\tbreak;"
57 | 				]))
58 | 				offset += 1
59 | 			random.shuffle(cases)
60 | 			print("\n".join(cases))
61 | 	print("""			default: escape = -666; break;
62 | 		}
63 | 		escape = nanac_step_epilogue(cpu, escape);
64 | 	}
65 | 	return escape;
66 | }
67 | 	""")
68 | 
69 | 
70 | if __name__ == "__main__":
71 | 	main()
72 | 


--------------------------------------------------------------------------------