Use larger readerChannel buffer.

door/door.go

@@ -445,7 +445,7 @@ func (d *Door) Init(doorname string) {
 	log.Printf("Loading dropfile %s\n", dropfile)
 	log.Printf("BBS %s, User %s / Handle %s / File %d\n", d.Config.BBSID, d.Config.Real_name, d.Config.Handle, d.Config.Comm_handle)
 
-	d.readerChannel = make(chan rune) // was 8 ?
+	d.readerChannel = make(chan rune, 16) // was 8 ?
 	/*
 		Ok, here's the issue.  This blocks the go reader when this is full.
 		It seems like it would be better to have a channel that receives

door/input_linux.go

@@ -3,6 +3,7 @@ package door
 import (
 	"bufio"
 	"bytes"
+	"io"
 	"log"
 	"syscall"
 	"time"
@@ -24,43 +25,13 @@ func set(fdSetPtr *syscall.FdSet, fd int) {
 	(*fdSetPtr).Bits[fd/64] |= 1 << uint64(fd%64)
 }
 
-/*
-	func main() {
-		var text string = "\x1b\u2415\xff"
-		var buffer []byte = []byte(text)
-		var readbuffer = bytes.NewBuffer(buffer)
-		// bytes.Buffer{}
-		// readbuffer.Write(buffer)
-
-		var runeread = bufio.NewReaderSize(readbuffer, 1)
-
-		//for readbuffer.Len() > 0 {
-		for {
-			r, _, err := runeread.ReadRune()
-			if err != nil {
-				break
-			}
-			if r == unicode.ReplacementChar {
-				runeread.UnreadRune()
-				b, _ := runeread.ReadByte()
-				fmt.Printf("BYTE %#v\n", b)
-			} else {
-				fmt.Printf("%#v\n", r)
-			}
-		}
-*/
-const READ_SIZE = 16
+const READ_SIZE = 16 // Size of read buffer
 
 // go routine Reader for input
 // This "times out" every ReaderTimeval
 func Reader(d *Door) {
 	// I need non-blocking reads here.
 
-	// I'm not really using either of these things.
-
-	// d.readerFile = os.NewFile(uintptr(d.READFD), "Door FD")
-	// d.runereader = bufio.NewReaderSize(d.readerFile, 1)
-
 	defer func() {
 		log.Printf("~Reader\n")
 		if d.ReaderCanClose {
@@ -74,12 +45,9 @@ func Reader(d *Door) {
 	}()
 
 	var fdset syscall.FdSet
-	var readone []byte = make([]byte, READ_SIZE) //make([]byte, 0, READ_SIZE)
-	// read 1 byte
-	var readbuffer bytes.Buffer // NewBuffer(readone)
-	var runeread = bufio.NewReaderSize(&readbuffer, 1)
-
-	// var buffer []byte = make([]byte, 0)  // unicode read buffer
+	var readbuffer [READ_SIZE]byte
+	var runebuffer bytes.Buffer
+	var runeread = bufio.NewReaderSize(&runebuffer, 1)
 
 	for {
 		clearAll(&fdset)
@@ -105,36 +73,14 @@ func Reader(d *Door) {
 
 		if v == 0 {
 			// timeout
-			/*
-				if len(buffer) > 0 {
-					timeoutCount++
-
-					input, size = utf8.DecodeRune(buffer)
-					if input != utf8.RuneError {
-						d.readerChannel <- input
-						for size > 0 {
-							ArrayDelete(&buffer, 0)
-							size--
-						}
-						timeoutCount = 0
-
-					} else {
-						b, _ := ArrayDelete(&buffer, 0)
-						d.readerChannel <- rune(b)
-					}
-				} else {
-					timeoutCount = 0
-				}
-			*/
 			continue
 		}
 
-		log.Println("syscall.Read:", len(readone), cap(readone))
 		// The buffer used here must have len & cap to size you want to read.
-
-		r, err := syscall.Read(d.READFD, readone)
+		// use [BUFF_SIZE]byte for readone
+		r, err := syscall.Read(d.READFD, readbuffer[:])
 		if r == -1 {
-			log.Println("Read -1 (closed)")
+			log.Println("syscall.Read -1 (closed)")
 			d.readerMutex.Lock()
 			defer d.readerMutex.Unlock()
 			if !d.ReaderClosed {
@@ -155,41 +101,44 @@ func Reader(d *Door) {
 			}
 			return
 		}
-		// readone = readone[:r]
 
 		if DEBUG_INPUT {
-			log.Printf("Reader << %d, %#v\n", r, readone[:r])
+			log.Printf("Reader << %d, %#v\n", r, readbuffer[:r])
 		}
 
-		// Is this unicode?
-		readbuffer.Write(readone[:r])
-		// reset
-		// readone = readone[0:0]
-		log.Println("readone:", len(readone), cap(readone))
+		runebuffer.Write(readbuffer[:r])
 		var input rune
 
-	RuneRead:
+		// Is this unicode?
 
-		input, _, err = runeread.ReadRune()
-		if err != nil {
-			log.Printf("ReadRune: %#v\n", err)
-			// errors EOF
-			continue
-		}
-		if input == unicode.ReplacementChar {
-			runeread.UnreadRune()
-			b, _ := runeread.ReadByte()
-			if DEBUG_INPUT {
-				log.Printf("Reader (byte) >> %x\n", b)
+		err = nil
+		for err == nil {
+			//RuneRead:
+
+			input, _, err = runeread.ReadRune()
+
+			if err == io.EOF {
+				continue
 			}
-			d.readerChannel <- rune(b)
-		} else {
-			if DEBUG_INPUT {
-				log.Printf("Reader >> %x\n", input)
+			if err != nil {
+				log.Printf("ReadRune: %#v\n", err)
+				// errors EOF
+				continue // break for loop
 			}
-			d.readerChannel <- input
-		}
-		goto RuneRead
+			if input == unicode.ReplacementChar {
+				runeread.UnreadRune()
+				b, _ := runeread.ReadByte()
+				if DEBUG_INPUT {
+					log.Printf("Reader (byte) >> %x\n", b)
+				}
+				d.readerChannel <- rune(b)
+			} else {
+				if DEBUG_INPUT {
+					log.Printf("Reader >> %x\n", input)
+				}
+				d.readerChannel <- input
+			}
+		} // goto RuneRead
 
 		// buffer = append(buffer, readone[0])