Separate lispy from mpcinterface

Author: sunzenshen

mpcinterface/lispy.go renamed to lispy/lispy.go

@@ -1,34 +1,36 @@
-package mpcinterface
+package lispy
 
 import (
 	"errors"
 	"fmt"
 	"math/big"
 	"strconv"
 	"strings"
+
+	mpc "github.com/sunzenshen/golispy/mpcinterface"
 )
 
 // Lispy is a collection of the Lispy parser definitions
 type Lispy struct {
-	numberParser, operatorParser, exprParser, lispyParser MpcParser
+	numberParser, operatorParser, exprParser, lispyParser mpc.MpcParser
 }
 
 // CleanLispy is used after parsers initiated by InitLispy are not longer to be used
 func CleanLispy(l Lispy) {
-	MpcCleanup(l.numberParser, l.operatorParser, l.exprParser, l.lispyParser)
+	mpc.MpcCleanup(l.numberParser, l.operatorParser, l.exprParser, l.lispyParser)
 }
 
 // Eval translates an AST into the final result of the represented instructions
-func Eval(tree MpcAst) int64 {
-	if strings.Contains(getTag(tree), "number") {
-		num, _ := strconv.ParseInt(getContents(tree), 10, 0)
+func Eval(tree mpc.MpcAst) int64 {
+	if strings.Contains(mpc.GetTag(tree), "number") {
+		num, _ := strconv.ParseInt(mpc.GetContents(tree), 10, 0)
 		return num
 	}
-	op := getOperator(tree)
-	x := Eval(getChild(tree, 2))
+	op := mpc.GetOperator(tree)
+	x := Eval(mpc.GetChild(tree, 2))
 	i := 3
-	for strings.Contains(getTag(getChild(tree, i)), "expr") {
-		x = evalOp(x, op, Eval(getChild(tree, i)))
+	for strings.Contains(mpc.GetTag(mpc.GetChild(tree, i)), "expr") {
+		x = evalOp(x, op, Eval(mpc.GetChild(tree, i)))
 		i++
 	}
 	return x
@@ -60,17 +62,17 @@ func evalOp(x int64, op string, y int64) int64 {
 
 // InitLispy returns the parsers for the Lispy language definition
 func InitLispy() Lispy {
-	number := mpcNew("number")
-	operator := mpcNew("operator")
-	expr := mpcNew("expr")
-	lispy := mpcNew("lispy")
+	number := mpc.MpcNew("number")
+	operator := mpc.MpcNew("operator")
+	expr := mpc.MpcNew("expr")
+	lispy := mpc.MpcNew("lispy")
 	language := "" +
 		"number : /-?[0-9]+/                                                  ; " +
 		"operator :   '+'   |   '-'   |   '*'   |   '/'   |   '%'   |   '^'     " +
 		"         | \"add\" | \"sub\" | \"mul\" | \"div\" | \"mod\" | \"pow\" ; " +
 		"expr     : <number> | '(' <operator> <expr>+ ')'                     ; " +
 		"lispy    : /^/ <operator> <expr>+ /$/                                ; "
-	MpcaLang(language, number, operator, expr, lispy)
+	mpc.MpcaLang(language, number, operator, expr, lispy)
 	parserSet := Lispy{}
 	parserSet.numberParser = number
 	parserSet.operatorParser = operator
@@ -81,21 +83,21 @@ func InitLispy() Lispy {
 
 // PrintAst prints the AST of a Lispy expression.
 func (l *Lispy) PrintAst(input string) {
-	PrintAst(input, l.lispyParser)
+	mpc.PrintAst(input, l.lispyParser)
 }
 
 // ReadEval takes a string, tries to interpret it in Lispy
 func (l *Lispy) ReadEval(input string, printErrors bool) (int64, error) {
-	r, err := MpcParse(input, l.lispyParser)
+	r, err := mpc.MpcParse(input, l.lispyParser)
 	if err != nil {
 		if printErrors {
-			MpcErrPrint(&r)
+			mpc.MpcErrPrint(&r)
 		}
-		MpcErrDelete(&r)
+		mpc.MpcErrDelete(&r)
 		return 0, errors.New("mpc: ReadEval call to MpcParse failed")
 	}
-	defer MpcAstDelete(&r)
-	return Eval(GetOutput(&r)), nil
+	defer mpc.MpcAstDelete(&r)
+	return Eval(mpc.GetOutput(&r)), nil
 }
 
 // ReadEvalPrint takes a string, tries to interpret it in Lispy, or returns an parsing error

mpcinterface/lispy_test.go renamed to lispy/lispy_test.go

@@ -1,10 +1,10 @@
-package mpcinterface
+package lispy
 
 import "testing"
 
 func TestValidIntegerMath(t *testing.T) {
-	lispy := InitLispy()
-	defer CleanLispy(lispy)
+	l := InitLispy()
+	defer CleanLispy(l)
 
 	cases := []struct {
 		input string
@@ -36,7 +36,7 @@ func TestValidIntegerMath(t *testing.T) {
 		{"- (* 10 10) (+ 1 1 1)", 97},
 	}
 	for _, c := range cases {
-		got, err := lispy.ReadEval(c.input, false)
+		got, err := l.ReadEval(c.input, false)
 		if err != nil {
 			t.Errorf("ReadEval could not parse the following input: \"%s\"", c.input)
 		} else if got != c.want {

mpcinterface/mpc_interface.go

@@ -17,24 +17,28 @@ type MpcParser *C.struct_mpc_parser_t
 // MpcResult is a union that returns either an output or error
 type MpcResult C.mpc_result_t
 
-func getChild(node MpcAst, index int) MpcAst {
+// GetChild accesses the child at a specific index in MpcAst
+func GetChild(node MpcAst, index int) MpcAst {
 	return C.get_child(node, C.int(index))
 }
 
-func getContents(node MpcAst) string {
+// GetContents accesses the contents of an MpcAst
+func GetContents(node MpcAst) string {
 	return C.GoString(node.contents)
 }
 
-func getOperator(node MpcAst) string {
-	return getContents(getChild(node, 1))
+// GetOperator accesses a MpcAst's child node representing an operator
+func GetOperator(node MpcAst) string {
+	return GetContents(GetChild(node, 1))
 }
 
 // GetOutput accesses the output field of an input MpcResult
 func GetOutput(result *C.mpc_result_t) MpcAst {
 	return C.get_output(result)
 }
 
-func getTag(node MpcAst) string {
+// GetTag accesses the tag field of an MpcAst
+func GetTag(node MpcAst) string {
 	return C.GoString(node.tag)
 }
 
@@ -59,7 +63,8 @@ func MpcCleanup(parser1 MpcParser, parser2 MpcParser, parser3 MpcParser, parser4
 	C.mpc_cleanup_if(C.int(4), parser1, parser2, parser3, parser4)
 }
 
-func mpcNew(name string) MpcParser {
+// MpcNew returns a pointer to an initiated mpc parser
+func MpcNew(name string) MpcParser {
 	cName := C.CString(name)
 	defer C.free(unsafe.Pointer(cName))
 	return C.mpc_new(cName)

prompt.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/sunzenshen/golispy/mpcinterface"
+	"github.com/sunzenshen/golispy/lispy"
 )
 
 func main() {
@@ -15,8 +15,8 @@ func main() {
 	// For reading lines of user input
 	scanner := bufio.NewScanner(os.Stdin)
 
-	lispy := mpcinterface.InitLispy()
-	defer mpcinterface.CleanLispy(lispy)
+	l := lispy.InitLispy()
+	defer lispy.CleanLispy(l)
 
 	for {
 		// Prompt
@@ -25,6 +25,6 @@ func main() {
 		scanner.Scan()
 		input := scanner.Text()
 		// Echo input back to user
-		lispy.ReadEvalPrint(input)
+		l.ReadEvalPrint(input)
 	}
 }