808 posts
Posted 04 February 2015 - 12:58 PM
Over time, I've made myself involved in many programming language oriented projects on these forums, such as JVML-JIT, LuaLua, ClamShell, and LASM. I feel sufficiently prepared with a knowledge of grammar and compiler design that I'm taking the plunge and writing my own language from scratch. I've been slowly collecting ideas for a while but it's all very loose.
- Focus on modern style. I've recently started to love Haskell. The ideas it has are fantastic. But it can be extremely difficult to use. I am going to make my language a little bit Swift-esque in this regard. There will be good support for the pure style, while also supporting the imperative style in most OOP languages. The main ideas being the distinction between pure and impure functions that Haskell and Swift both lack, and the collaboration between algebraic data types and object oriented data types.
- VM with language independence in mind. I'm going to be making a VM that's designed to inhabit 3rd party languages. So it will be using a precompiled bytecode format like Java. It will also feature a comprehensive memory model allowing the use of either a built in GC, stack allocated values, and manual heap management with optional custom allocators. The VM will also accept dynamic typing, unlike the language I will be writing for it. A bytecode file is slightly inspired by Lua's bytecode, except flattening nested function declarations instead of nesting them in bytecode. The idea is that a bytecode file represents a list of functions. A function has a prototype name, and expects to be instantiated with its upvalues. So something like this pseudo code:
pure func overlyComplexAdd(a: Int, b: Int) -> Int {
return (() => b + a)() // Create a closure and tail call it
}
impure func main(args: [String]) -> () {
let n = overlyComplexAdd(14, 6)
}
overlyComplexAdd:
nArgs: 2
nUpvalues: 0
code: [ // asm
closure 2 "overlyComplexAdd$0" 0 1 // create a new instance of the closure declared in overlyComplexAdd,
// 0 and 1 representing registers on the vm stack to use as upvalues,
// which in this case are the arguments a and b.
// 2 representing the stack index to store the closure in
tailcall 2 0 // special call instruction for tail call optimization
// 2 is the register of the closure, 0 is the number of arguments
]
overlyComplexAdd$0:
nArgs: 0
nUpvalues: 2
code: [
add 2 0 1 // add the upvalues in 0 and 1 and store the result in 2
return 2
]
main:
nArgs: 1
nUpvalues: 0
code: [
loadc 1 14
loadc 2 6
callstatic 1 "overlyComplexAdd" 2 // special call instruction for calling functions with no upvalues without using a closure
// 1 is the register to store the return in as well as the register
// that arguments start at,
// 2 is the number of arguments
]
