Added 'n' => "\r\n" filter.

Filter in write_linux (maybe should be in write.go?)
Spinrite better use of bytes.Buffer.

door/door.go

@@ -44,9 +44,12 @@ const DEBUG_OUTPUT bool = false
 
 // Right now these are strings.  Should they be []byte ?
 
-const SavePos = "\x1b[s"              // Save Cursor Position
-const RestorePos = "\x1b[u"           // Restore Cursor Position
-const CRNL = "\r\n"                   // BBS Line Ending
+const SavePos = "\x1b[s"    // Save Cursor Position
+const RestorePos = "\x1b[u" // Restore Cursor Position
+// const CRNL = "\r\n"                   // BBS Line Ending
+
+const CRNL = "\n"
+
 const Clrscr = "\x1b[0m\x1b[2J\x1b[H" // Clear screen, home cursor
 const HideCursor = "\x1b[?25l"        // Hide Cursor
 const ShowCursor = "\x1b[?25h"        // Show Cursor

door/spinrite.go

@@ -220,8 +220,8 @@ func SpinRiteMsgInit(width uint8, length uint8, color string, messages []string)
 	return result
 }
 
-func (sr *SpinRiteMsg) Output() string {
-	var result string
+func (sr *SpinRiteMsg) Output() []byte {
+	sr.output.Reset()
 
 	sr.Calculate()
 	if sr.Next && sr.Index == 0 {
@@ -294,12 +294,19 @@ func (sr *SpinRiteMsg) Output() string {
 		}
 	*/
 
+	sr.output.WriteString(sr.Color)
+
 	if Unicode {
-		result = string(sr.OutputR)
+		for _, r := range sr.OutputR {
+			sr.output.WriteRune(r)
+		}
+		// result = string(sr.OutputR)
 	} else {
-		result = string(sr.OutputB)
+		sr.output.Write(sr.OutputB)
+		// result = string(sr.OutputB)
 	}
 	sr.Index++
 
-	return sr.Color + result
+	// return sr.Color + result
+	return sr.output.Bytes()
 }

door/write_linux.go

@@ -11,26 +11,69 @@ import (
 // This assumes that d.writerMutex is locked.
 
 type OSWriter struct {
-	Mutex  sync.Mutex // Writer mutex
-	Closed bool
-	Handle int
+	Mutex              sync.Mutex // Writer mutex
+	Closed             bool
+	Handle             int
+	TranslateNL        bool
+	TranslateToUnicode bool
+	nlBuffer           *bytes.Buffer
+	uniBuffer          *bytes.Buffer
 }
 
 func (ow *OSWriter) Init(d *Door) {
 	ow.Closed = false
 	ow.Handle = d.Config.Comm_handle
+	ow.TranslateNL = true // Yes, translate NL => CR+NL
+	ow.nlBuffer = &bytes.Buffer{}
+}
+
+func (ow *OSWriter) CP437toUnicode(output []byte) []byte {
+	if ow.uniBuffer == nil {
+		ow.uniBuffer = &bytes.Buffer{}
+	}
+	return ow.uniBuffer.Bytes()
+}
+
+func (ow *OSWriter) NewLines(output []byte) []byte {
+	var pos, nextpos int
+	ow.nlBuffer.Reset()
+
+	for pos != -1 {
+		nextpos = bytes.Index(output[pos:], []byte{'\n'})
+		if nextpos != -1 {
+			nextpos += pos
+			// Something to do
+			ow.nlBuffer.Write(output[pos:nextpos])
+			nextpos++
+			pos = nextpos
+			ow.nlBuffer.Write([]byte("\r\n"))
+		} else {
+			ow.nlBuffer.Write(output[pos:])
+			pos = nextpos // -1
+		}
+	}
+	// log.Printf(">> %q\n", ow.nlBuffer.Bytes())
+	return ow.nlBuffer.Bytes()
 }
 
 // The low-lever writer function
 func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
+	var buff []byte = buffer
+
 	if DEBUG_DOOR {
 		if ow.Mutex.TryLock() {
 			log.Panic("OSWrite: mutex was NOT locked.")
 		}
 	}
 
-	n, err := syscall.Write(ow.Handle, buffer)
-	if (err != nil) || (n != len(buffer)) {
+	// Filters (!)
+
+	if ow.TranslateNL {
+		buff = ow.NewLines(buff)
+	}
+
+	n, err := syscall.Write(ow.Handle, buff)
+	if (err != nil) || (n != len(buff)) {
 		if !ow.Closed {
 			ow.Closed = true
 			// Don't need to close reader, it will close itself.
@@ -47,8 +90,8 @@ func (ow *OSWriter) Write(buffer []byte) (int, error) {
 		return 0, ErrDisconnected
 	}
 
-	var output bytes.Buffer
-	output.Write(buffer)
+	// var output bytes.Buffer
+	// output.Write(buffer)
 	// Where should this be done?  (I think in here)
 	// TO FIX: TO DO:
 	/*
@@ -59,7 +102,7 @@ func (ow *OSWriter) Write(buffer []byte) (int, error) {
 			d.UpdateLastColor(output, &d.LastColor)
 		}
 	*/
-	return ow.OSWrite(output.Bytes())
+	return ow.OSWrite(buffer)
 }
 
 func (ow *OSWriter) Stop() {