Added primcall instruction

marginally faster, will allow special handling of primitives.

Author: boynton

code.go

@@ -42,6 +42,7 @@ const (
 	opcodeVector // 15
 	opcodeStruct
 	opcodeUndefGlobal
+	opcodePrimCall
 )
 
 var symOpClosure = intern("closure")
@@ -54,20 +55,21 @@ var symOpJump = intern("jump")
 var symOpJumpFalse = intern("jumpfalse")
 var symOpCall = intern("call")
 var symOpTailCall = intern("tailcall")
-var symOpReturn =	intern("return")
-var symOpPop =	intern("pop")
+var symOpPrimCall = intern("primcall")
+var symOpReturn = intern("return")
+var symOpPop = intern("pop")
 var symOpDefGlobal = intern("defglobal")
 var symOpUndefGlobal = intern("undefglobal")
 var symOpDefMacro = intern("defmacro")
 var symOpUse = intern("use")
 
 // Code - compiled Ell bytecode
 type Code struct {
-	name           string
-	ops            []int
-	argc           int
-	defaults       []LAny
-	keys           []LAny
+	name     string
+	ops      []int
+	argc     int
+	defaults []LAny
+	keys     []LAny
 }
 
 func newCode(argc int, defaults []LAny, keys []LAny, name string) *Code {
@@ -148,7 +150,7 @@ func (code *Code) signature() string {
 	}
 	//the following has no type info
 	tmp := ""
-	for i:=0; i<code.argc; i++ {
+	for i := 0; i < code.argc; i++ {
 		tmp += " <any>"
 	}
 	if code.defaults != nil {
@@ -197,31 +199,27 @@ func (code *Code) decompileInto(buf *bytes.Buffer, indent string, pretty bool) {
 	for offset < max {
 		switch code.ops[offset] {
 		case opcodeLiteral:
-			//fmt.Printf("%sL%03d:\t(literal %d)  \t; %v\n", indent, offset, code.ops[offset+1], constants[code.ops[offset+1]])
 			buf.WriteString(prefix + "(literal " + write(constants[code.ops[offset+1]]) + ")")
 			offset += 2
 		case opcodeDefGlobal:
-			//fmt.Printf("%sL%03d:\t(global %v)\n", indent, offset, constants[code.ops[offset+1]])
 			buf.WriteString(prefix + "(defglobal " + write(constants[code.ops[offset+1]]) + ")")
 			offset += 2
 		case opcodeCall:
-			//fmt.Printf("%sL%03d:\t(call %d)\n", indent, offset, code.ops[offset+1])
 			buf.WriteString(prefix + "(call " + strconv.Itoa(code.ops[offset+1]) + ")")
 			offset += 2
 		case opcodeTailCall:
-			//fmt.Printf("%s%03d:\t(tailcall %d)\n", indent, offset, code.ops[offset+1])
 			buf.WriteString(prefix + "(tailcall " + strconv.Itoa(code.ops[offset+1]) + ")")
 			offset += 2
+		case opcodePrimCall:
+			buf.WriteString(prefix + "(primcall " + strconv.Itoa(code.ops[offset+1]) + " " + primitives[code.ops[offset+2]].name + ")")
+			offset += 3
 		case opcodePop:
-			//fmt.Printf("%sL%03d:\t(pop)\n", indent, offset)
 			buf.WriteString(prefix + "(pop)")
 			offset++
 		case opcodeReturn:
-			//fmt.Printf("%sL%03d:\t(return)\n", indent, offset)
 			buf.WriteString(prefix + "(return)")
 			offset++
 		case opcodeClosure:
-			//fmt.Printf("%sL%03d:\t(closure %v)\n", indent, offset, code.ops[offset+1])
 			buf.WriteString(prefix + "(closure")
 			if pretty {
 				buf.WriteString("\n")
@@ -236,31 +234,24 @@ func (code *Code) decompileInto(buf *bytes.Buffer, indent string, pretty bool) {
 			buf.WriteString(")")
 			offset += 2
 		case opcodeLocal:
-			//fmt.Printf("%sL%03d:\t(local %d %d)\n", indent, offset, code.ops[offset+1], code.ops[offset+2])
 			buf.WriteString(prefix + "(local " + strconv.Itoa(code.ops[offset+1]) + " " + strconv.Itoa(code.ops[offset+2]) + ")")
 			offset += 3
 		case opcodeGlobal:
-			//fmt.Printf("%sL%03d:\t(global %v)\n", indent, offset, constants[code.ops[offset+1]])
 			buf.WriteString(prefix + "(global " + write(constants[code.ops[offset+1]]) + ")")
 			offset += 2
 		case opcodeUndefGlobal:
-			//fmt.Printf("%sL%03d:\t(unglobal %v)\n", indent, offset, constants[code.ops[offset+1]])
 			buf.WriteString(prefix + "(undefglobal " + write(constants[code.ops[offset+1]]) + ")")
 			offset += 2
 		case opcodeDefMacro:
-			//fmt.Printf("%sL%03d:\t(defmacro%6d ; %v)\n", indent, offset, code.ops[offset+1], constants[code.ops[offset+1]])
 			buf.WriteString(prefix + "(defmacro " + write(constants[code.ops[offset+1]]) + ")")
 			offset += 2
 		case opcodeSetLocal:
-			//Println("%sL%03d:\t(setlocal %d %d)\n", indent, offset, code.ops[offset+1], code.ops[offset+2])
 			buf.WriteString(prefix + "(setlocal " + strconv.Itoa(code.ops[offset+1]) + " " + strconv.Itoa(code.ops[offset+2]) + ")")
 			offset += 3
 		case opcodeJumpFalse:
-			//fmt.Printf("%sL%03d:\t(jumpfalse %d)\t; L%03d\n", indent, offset, code.ops[offset+1], code.ops[offset+1] + offset)
 			buf.WriteString(prefix + "(jumpfalse " + strconv.Itoa(code.ops[offset+1]) + ")")
 			offset += 2
 		case opcodeJump:
-			//fmt.Printf("%sL%03d:\t(jump %d)    \t; L%03d\n", indent, offset, code.ops[offset+1], code.ops[offset+1] + offset)
 			buf.WriteString(prefix + "(jump " + strconv.Itoa(code.ops[offset+1]) + ")")
 			offset += 2
 		case opcodeVector:
@@ -363,7 +354,11 @@ func (code *Code) loadOps(lst LAny) error {
 			}
 			code.emitSetLocal(i, j)
 		case symOpGlobal:
-			code.emitGlobal(cadr(instr))
+			if sym, ok := cadr(instr).(*LSymbol); ok {
+				code.emitGlobal(sym)
+			} else {
+				return Error(symOpGlobal, " argument 1 not a symbol: ", cadr(instr))
+			}
 		case symOpUndefGlobal:
 			code.emitUndefGlobal(cadr(instr))
 		case symOpJump:
@@ -413,9 +408,9 @@ func (code *Code) emitLiteral(val LAny) {
 	code.ops = append(code.ops, putConstant(val))
 }
 
-func (code *Code) emitGlobal(sym LAny) {
+func (code *Code) emitGlobal(sym *LSymbol) {
 	code.ops = append(code.ops, opcodeGlobal)
-	code.ops = append(code.ops, putConstant(sym))
+	code.ops = append(code.ops, sym.tag)
 }
 func (code *Code) emitCall(argc int) {
 	code.ops = append(code.ops, opcodeCall)
@@ -428,6 +423,11 @@ func (code *Code) emitTailCall(argc int) {
 	code.ops = append(code.ops, opcodeTailCall)
 	code.ops = append(code.ops, argc)
 }
+func (code *Code) emitPrimCall(prim *LPrimitive, argc int) {
+	code.ops = append(code.ops, opcodePrimCall)
+	code.ops = append(code.ops, prim.idx)
+	code.ops = append(code.ops, argc)
+}
 func (code *Code) emitPop() {
 	code.ops = append(code.ops, opcodePop)
 }

compiler.go

@@ -63,7 +63,7 @@ func compileExpr(code *Code, env *LList, expr LAny, isTail bool, ignoreResult bo
 		if i, j, ok := calculateLocation(expr, env); ok {
 			code.emitLocal(i, j)
 		} else {
-			code.emitGlobal(expr)
+			code.emitGlobal(expr.(*LSymbol))
 		}
 		if ignoreResult {
 			code.emitPop()
@@ -383,6 +383,19 @@ func compileFuncall(code *Code, env *LList, fn LAny, args *LList, isTail bool, i
 	if err != nil {
 		return err
 	}
+	fval := global(fn)
+	if fval != nil && true {
+		switch fprim := fval.(type) {
+		case *LPrimitive:
+			code.emitPrimCall(fprim, argc)
+			if ignoreResult {
+				code.emitPop()
+			} else if isTail {
+				code.emitReturn()
+			}
+			return nil
+		}
+	}
 	err = compileExpr(code, env, fn, false, false, context)
 	if err != nil {
 		return err

ell.go

@@ -81,11 +81,11 @@ func initEnvironment() {
 	defineFunction("concat", ellConcat, "(<list>*) <list>")
 	defineFunction("reverse", ellReverse, "(<list>) <list>")
 	defineFunction("flatten", ellFlatten, "(<list>) <list>")
-	defineFunction("set-car!", ellSetCarBang, "(<list> <any>) <null>") //mutate!
+	defineFunction("set-car!", ellSetCarBang, "(<list> <any>) <null>")  //mutate!
 	defineFunction("set-cdr!", ellSetCdrBang, "(<list> <list>) <null>") //mutate!
 
 	defineFunction("vector?", ellVectorP, "(<any>) <boolean>")
-	defineFunction("to-vector", ellToVector, "(<any>) <vector>")	
+	defineFunction("to-vector", ellToVector, "(<any>) <vector>")
 	defineFunction("vector", ellVector, "(<any>*) <vector>")
 	defineFunction("make-vector", ellMakeVector, "(<number> <any>) <vector>")
 	defineFunction("vector-set!", ellVectorSetBang, "(<vector> <number> <any>) <null>") //mutate!
@@ -358,7 +358,7 @@ func ellNewline(argv []LAny, argc int) (LAny, error) {
 		//todo: add the optional output argument like scheme
 		return nil, ArgcError("newline", "0", argc)
 	}
-	fmt.Printf("\n")
+	fmt.Println("")
 	return Null, nil
 }
 
@@ -834,14 +834,16 @@ func ellString(argv []LAny, argc int) (LAny, error) {
 
 func ellCar(argv []LAny, argc int) (LAny, error) {
 	if argc == 1 {
-		return safeCar(argv[0])
+		//		return safeCar(argv[0])
+		return car(argv[0]), nil
 	}
 	return nil, ArgcError("car", "1", argc)
 }
 
 func ellCdr(argv []LAny, argc int) (LAny, error) {
 	if argc == 1 {
-		return safeCdr(argv[0])
+		//		return safeCdr(argv[0])
+		return cdr(argv[0]), nil
 	}
 	return nil, ArgcError("cdr", "1", argc)
 }

module.go

@@ -24,7 +24,9 @@ import (
 var constantsMap = make(map[LAny]int, 0)
 var constants = make([]LAny, 0, 1000)
 var globals = make([]*binding, 0, 1000)
+var globalsMap = make(map[*LSymbol]int, 0)
 var macroMap = make(map[LAny]*macro, 0)
+var primitives = make([]*LPrimitive, 0, 1000)
 
 func checkInterrupt() bool {
 	if interrupts != nil {
@@ -51,19 +53,20 @@ func define(name string, obj LAny) {
 func defineFunction(name string, fun primitive, signature string) {
 	sym := intern(name)
 	if global(sym) != nil {
-		println("*** Warning: redefining ", name)
+		println("*** Warning: redefining ", name, " with a primitive")
 	}
-	prim := LPrimitive{name, fun, signature}
-	defGlobal(sym, &prim)
+
+	prim := newPrimitive(name, fun, signature)
+	defGlobal(sym, prim)
 }
 
 func defineMacro(name string, fun primitive) {
 	sym := intern(name)
 	if getMacro(sym) != nil {
 		println("*** Warning: redefining macro ", name, " -> ", getMacro(sym))
 	}
-	prim := LPrimitive{name, fun, "(<any>)"}
-	defMacro(sym, &prim)
+	prim := newPrimitive(name, fun, "(<any>)")
+	defMacro(sym, prim)
 }
 
 func getKeywords() []LAny {
@@ -93,31 +96,50 @@ func getGlobals() []LAny {
 	return syms
 }
 
-func global(sym LAny) LAny {
-	s := sym.(*LSymbol)
-	if s.tag >= len(globals) {
-		return nil
+func globalValue(tag int) LAny {
+	if tag < len(globals) {
+		tmp := globals[tag]
+		if tmp != nil {
+			return tmp.val
+		}
+	}
+	return nil
+}
+
+//used to report errors, doesn't need to be fast
+func globalName(tag int) string {
+	for k, v := range symtab {
+		if v.tag == tag {
+			return k
+		}
 	}
-	tmp := globals[s.tag]
-	if tmp == nil {
+	return "?"
+}
+
+func global(obj LAny) LAny {
+	sym, ok := obj.(*LSymbol)
+	if !ok || sym.tag < 0 || sym.tag >= len(globals) {
 		return nil
 	}
-	return tmp.val
+	return globalValue(sym.tag)
 }
 
 type binding struct {
-	sym LAny
+	sym *LSymbol
 	val LAny
 }
 
 func defGlobal(sym LAny, val LAny) {
-	s := sym.(*LSymbol)
+	s, ok := sym.(*LSymbol)
+	if !ok {
+		panic("defGlobal with a non-symbol first argument")
+	}
 	if s.tag >= len(globals) {
-		gLAny := make([]*binding, s.tag+100)
-		copy(gLAny, globals)
-		globals = gLAny
+		glob := make([]*binding, s.tag+100)
+		copy(glob, globals)
+		globals = glob
 	}
-	b := binding{sym, val}
+	b := binding{s, val}
 	globals[s.tag] = &b
 	delete(macroMap, sym)
 }