first commit

Author: felipensp

.gitignore

@@ -0,0 +1,2 @@
+vvm
+

README.md

@@ -0,0 +1,3 @@
+# VVM
+
+Experimental Register-based Virtual Machine for V Programming Language

cjson.v

@@ -0,0 +1,114 @@
+module main
+
+import json
+
+struct UseJson {
+	x int
+}
+
+fn suppress_json_warning() {
+	json.encode(UseJson{})
+}
+
+// struct C.cJSON {}
+fn C.cJSON_CreateObject() &C.cJSON
+
+fn C.cJSON_CreateArray() &C.cJSON
+
+// fn C.cJSON_CreateBool(bool) &C.cJSON
+fn C.cJSON_CreateTrue() &C.cJSON
+
+fn C.cJSON_CreateFalse() &C.cJSON
+
+fn C.cJSON_CreateNull() &C.cJSON
+
+// fn C.cJSON_CreateNumber() &C.cJSON
+// fn C.cJSON_CreateString() &C.cJSON
+fn C.cJSON_CreateRaw(&u8) &C.cJSON
+
+fn C.cJSON_IsInvalid(voidptr) bool
+
+fn C.cJSON_IsFalse(voidptr) bool
+
+// fn C.cJSON_IsTrue(voidptr) bool
+fn C.cJSON_IsBool(voidptr) bool
+
+fn C.cJSON_IsNull(voidptr) bool
+
+fn C.cJSON_IsNumber(voidptr) bool
+
+fn C.cJSON_IsString(voidptr) bool
+
+fn C.cJSON_IsArray(voidptr) bool
+
+fn C.cJSON_IsObject(voidptr) bool
+
+fn C.cJSON_IsRaw(voidptr) bool
+
+fn C.cJSON_AddItemToObject(voidptr, &u8, voidptr)
+
+fn C.cJSON_AddItemToArray(voidptr, voidptr)
+
+fn C.cJSON_Delete(voidptr)
+
+fn C.cJSON_Print(voidptr) &u8
+
+@[inline]
+fn create_object() &C.cJSON {
+	return C.cJSON_CreateObject()
+}
+
+@[inline]
+fn create_array() &C.cJSON {
+	return C.cJSON_CreateArray()
+}
+
+@[inline]
+fn create_string(val string) &C.cJSON {
+	return C.cJSON_CreateString(val.str)
+}
+
+@[inline]
+fn create_number(val f64) &C.cJSON {
+	return C.cJSON_CreateNumber(val)
+}
+
+@[inline]
+fn create_bool(val bool) &C.cJSON {
+	return C.cJSON_CreateBool(val)
+}
+
+@[inline]
+fn create_true() &C.cJSON {
+	return C.cJSON_CreateTrue()
+}
+
+@[inline]
+fn create_false() &C.cJSON {
+	return C.cJSON_CreateFalse()
+}
+
+@[inline]
+fn create_null() &C.cJSON {
+	return C.cJSON_CreateNull()
+}
+
+@[inline]
+fn delete(b voidptr) {
+	C.cJSON_Delete(b)
+}
+
+@[inline]
+fn add_item_to_object(obj &C.cJSON, key string, item &C.cJSON) {
+	C.cJSON_AddItemToObject(obj, key.str, item)
+}
+
+@[inline]
+fn add_item_to_array(obj &C.cJSON, item &C.cJSON) {
+	C.cJSON_AddItemToArray(obj, item)
+}
+
+fn json_print(json_ &C.cJSON) string {
+	s := C.cJSON_Print(json_)
+	return unsafe { tos3(s) }
+}

ir/ir.v

@@ -0,0 +1,142 @@
+module ir
+
+import v.ast
+import v.pref
+import v.parser
+import strings
+
+pub enum Ins {
+	module_
+	print_
+	call_
+}
+
+type Operand = int | string
+
+@[minify]
+struct IR {
+pub:
+	ins Ins
+	op1 Operand
+	op2 Operand
+	res Operand
+}
+
+@[heap]
+pub struct VVMIR {
+pub mut:
+	ir_list []IR
+}
+
+struct Tree {
+	table &ast.Table        = unsafe { nil }
+	pref  &pref.Preferences = unsafe { nil }
+mut:
+	root Node // the root of tree
+}
+
+// tree node
+pub type Node = C.cJSON
+
+// create an object node
+@[inline]
+fn new_object() &Node {
+	return C.cJSON_CreateObject()
+}
+
+fn (mut i VVMIR) gen_module(mod &ast.Module) {
+}
+
+fn (mut i VVMIR) gen_fn_decl(func &ast.FnDecl) {
+	i.gen_stmts(func.stmts)
+}
+
+fn (mut i VVMIR) gen_call(call &ast.CallExpr) {
+	i.ir_list << IR{
+		ins: .call_
+		op1: call.name
+		op2: (call.args[0].expr as ast.StringLiteral).val
+	}
+}
+
+fn (mut i VVMIR) gen_expr(expr &ast.Expr) {
+	match expr {
+		ast.CallExpr { i.gen_call(&expr) }
+		else { dump(expr) }
+	}
+}
+
+fn (mut i VVMIR) gen_return(stmt &ast.Return) {
+	for expr in stmt.exprs {
+		i.gen_expr(&expr)
+	}
+}
+
+fn (mut i VVMIR) gen_stmt(stmt &ast.Stmt) {
+	match stmt {
+		ast.Module {
+			i.gen_module(&stmt)
+		}
+		ast.FnDecl {
+			i.gen_fn_decl(&stmt)
+		}
+		ast.Block {
+			i.gen_stmts(stmt.stmts)
+		}
+		ast.Return {
+			i.gen_return(&stmt)
+		}
+		ast.ExprStmt {
+			i.gen_expr(&stmt.expr)
+		}
+		else {
+			dump(stmt)
+		}
+	}
+}
+
+fn (mut i VVMIR) gen_stmts(stmts []ast.Stmt) {
+	for stmt in stmts {
+		i.gen_stmt(&stmt)
+	}
+}
+
+fn (mut i VVMIR) gen_file(file &ast.File) {
+	i.gen_stmts(file.stmts)
+}
+
+pub fn (mut i VVMIR) parse_file(file string) {
+	mut pref_ := &pref.Preferences{}
+	pref_.fill_with_defaults()
+	pref_.enable_globals = true
+	//
+	mut t := Tree{
+		root: new_object()
+		table: ast.new_table()
+		pref: pref_
+	}
+	// parse file with comment
+	ast_file := parser.parse_file(file, t.table, .parse_comments, t.pref)
+	i.gen_file(ast_file)
+}
+
+fn (op Operand) str() string {
+	if op is string {
+		return 's"${string(op)}"'
+	} else {
+		return 'unused'
+	}
+}
+
+fn (ii IR) str() string {
+	return '${ii.ins:10s} | ${ii.op1:10s} | ${ii.op2:10s} | ${ii.res:10s}'
+}
+
+pub fn (i VVMIR) str() string {
+	eprintln('Collected IR:')
+	mut s := strings.new_builder(100)
+	for item in i.ir_list {
+		s.write_string(item.str())
+	}
+	return s.str()
+}

main.v

@@ -0,0 +1,45 @@
+module main
+
+import vm
+import ir
+import os
+import flag
+
+struct VVMOptions {
+	file   string
+	help   bool
+	debug  bool
+	dumpir bool
+	args   []string
+}
+
+fn main() {
+	mut fp := flag.new_flag_parser(os.args)
+	fp.application('vvm')
+	fp.version('0.0.1a')
+	fp.description('This tool converts the V AST to an IR and executes on its own virtual machine')
+	fp.skip_executable()
+
+	mut opts := &VVMOptions{
+		debug: fp.bool('debug', `d`, false, 'show debug information')
+		dumpir: fp.bool('dumpir', `D`, false, 'dump IR only')
+		file: fp.string('file', `f`, '', 'Input file')
+		help: fp.bool('help', `h`, false, 'show this help message')
+	}
+
+	if opts.help {
+		eprintln(fp.usage())
+	} else if opts.file != '' {
+		mut vvm_ir := ir.VVMIR{}
+		vvm_ir.parse_file(opts.file)
+		if opts.dumpir {
+			eprintln(vvm_ir)
+		} else {
+			mut vvm_vm := vm.VVM{}
+			eprintln(vvm_ir)
+			vvm_vm.run(vvm_ir)
+		}
+	} else {
+		eprintln(fp.usage())
+	}
+}

samples/print.v

@@ -0,0 +1,3 @@
+fn main() {
+	println('foobar')
+}

v.mod

@@ -0,0 +1,7 @@
+Module {
+	name: 'vvm'
+	description: ''
+	version: ''
+	license: ''
+	dependencies: []
+}

vm/vm.v

@@ -0,0 +1,25 @@
+module vm
+
+import ir
+
+@[heap]
+pub struct VVM {
+}
+
+pub fn (v &VVM) run(ir_ &ir.VVMIR) {
+	eprintln('Running:')
+	for i in ir_.ir_list {
+		match i.ins {
+			.call_ {
+				fnc := i.op1 as string
+				match fnc {
+					'println' {
+						println(i.op2 as string)
+					}
+					else {}
+				}
+			}
+			else {}
+		}
+	}
+}