holy crap, I had it so wrong before

good god, the original implementation was just... wrong.  Soooo, so
fucking wrong I can't even fathom it.

tcp_connections.go

@@ -7,7 +7,6 @@ import (
 	"github.com/jordanorelli/skeam/cm"
 	"io"
 	"net"
-	"strings"
 )
 
 const MAX_SEXP_LINES = 40
@@ -15,97 +14,25 @@ const MAX_SEXP_LINES = 40
 var manager = cm.New()
 var errSexpTooLong = errors.New("error: sexp is too long")
 
-func depth(s string) int {
+type tcpInterpreter struct {
-	n := 0
+	fout   io.Writer        // buffered file-like output stream
-	for _, r := range s {
+	ferr   io.Writer        // buffered file-like error stream
-		switch r {
+	tokens chan token       // tokens returns from the lexer
-		case '(':
+	values chan interface{} // values returned from the interpreter
-			n += 1
+	errors chan error       // errors returned from the interpreter
-		case ')':
-			n -= 1
-		case ';':
-			return n
-		}
-	}
-	return n
-}
-
-func tcpInterpreter(conn net.Conn, userinput chan string, out chan interface{}, errors chan error) {
-	lines := make([]string, 0, MAX_SEXP_LINES)
-	currentDepth := 0
-	addLine := func(line string) error {
-		if len(lines) >= MAX_SEXP_LINES {
-			return errSexpTooLong
-		}
-		lines = append(lines, line+"\n")
-		return nil
-	}
-	errorMode := false
-	skipLine := func(line string) {
-		currentDepth += depth(line)
-		if currentDepth == 0 {
-			errorMode = false
-		}
-	}
-	s := make(chan string)
-	go func() {
-		for program := range s {
-			tokens := make(chan token, 32)
-			go lexs(program, tokens)
-			evalall(tokens, out, errors, universe)
-		}
-	}()
-	go func() {
-		for v := range out {
-			fmt.Fprintln(conn, v)
-		}
-	}()
-	for {
-		select {
-		case err := <-errors:
-			fmt.Fprintf(conn, "error: %v\n", err)
-		case line := <-userinput:
-			if errorMode {
-				skipLine(line)
-				break
-			}
-			lineDepth := depth(line)
-			currentDepth += lineDepth
-
-			if currentDepth < 0 {
-				lines = lines[:0]
-				currentDepth = 0
-				break
-			}
-
-			if len(lines) == 0 && lineDepth == 0 {
-				s <- line + "\n"
-				break
-			}
-
-			if err := addLine(line); err != nil {
-				errorMode = true
-				lines = lines[:0]
-				currentDepth = 0
-				break
-			}
-
-			if currentDepth == 0 {
-				program := strings.Join(append(lines, "\n"), " ")
-				lines = lines[:0]
-				s <- program
-			}
-		}
-	}
 }
 
 func runTCPServer() {
-	ln, err := net.Listen("tcp", *tcpAddr)
+	addr, err := net.ResolveTCPAddr("tcp", *tcpAddr)
+	if err != nil {
+		die(err.Error())
+	}
+	ln, err := net.ListenTCP("tcp", addr)
 	if err != nil {
 		die(err.Error())
 	}
 	for {
-		conn, err := ln.Accept()
+		conn, err := ln.AcceptTCP()
 		if err != nil {
 			printErrorMsg(err.Error())
 			continue
@@ -114,28 +41,43 @@ func runTCPServer() {
 	}
 }
 
-func startConnection(conn net.Conn, m *cm.Manager) {
+func newTcpInterpreter() *tcpInterpreter {
-	m.Add(conn)
+	return &tcpInterpreter{
-	defer m.Remove(conn)
+		tokens: make(chan token),
-
+		values: make(chan interface{}),
-	out, errors := make(chan interface{}), make(chan error)
+		errors: make(chan error),
-	userinput := make(chan string)
+	}
-
+}
-	go tcpInterpreter(conn, userinput, out, errors)
 
-	r := bufio.NewReader(conn)
+func (t *tcpInterpreter) send() {
 	for {
-		line, _, err := r.ReadLine()
+		select {
-		switch err {
+		case v := <-t.values:
-		case nil:
+			if _, err := fmt.Fprintln(t.fout, v); err != nil {
-			break
+				fmt.Println("can't write out to client: ", err)
-		case io.EOF:
+			}
-			io.WriteString(conn, "<eof>")
+		case e := <-t.errors:
-			return
+			if _, err := fmt.Fprintln(t.ferr, e); err != nil {
-		default:
+				fmt.Println("can't write error to client: ", err)
-			printErrorMsg(err.Error())
+			}
-			return
 		}
-		userinput <- string(line)
 	}
 }
+
+func (t *tcpInterpreter) Run(in io.Reader, out, errors io.Writer) {
+	go lex(bufio.NewReader(in), t.tokens)
+
+	t.fout = out
+	t.ferr = errors
+	go t.send()
+
+	evalall(t.tokens, t.values, t.errors, universe)
+}
+
+func startConnection(conn net.Conn, m *cm.Manager) {
+	m.Add(conn)
+	defer m.Remove(conn)
+
+	i := newTcpInterpreter()
+	i.Run(conn, conn, conn)
+}