golang linted.

door/door.go

@@ -123,8 +123,6 @@ type Door struct {
 	ReaderClosed   bool            // Reader close
 	readerChannel  chan ReaderData // Reading from the User
 	readerMutex    sync.Mutex      // Reader close mutex
-	readerFile     *os.File        // fd to File
-	runereader     *bufio.Reader   // Rune Reader
 	ReaderCanClose bool            // We can close the reader (in tests)
 	WriterClosed   bool            // Writer closed
 	writerChannel  chan string     // Writing to the User
@@ -250,7 +248,7 @@ func (d *Door) ReadDropfile(filename string) {
 		d.READFD = 0
 		d.WRITEFD = 1
 		// RAW MODE
-		d.tio_default, err = term.MakeRaw(d.READFD)
+		d.tio_default, _ = term.MakeRaw(d.READFD)
 	} else if d.Config.Comm_type == 2 {
 		d.READFD = d.Config.Comm_handle
 		d.WRITEFD = d.Config.Comm_handle

door/input.go

@@ -17,274 +17,6 @@ var ErrDisconnected error = fmt.Errorf("Disconnected")
 
 var DefaultTimeout time.Duration = time.Duration(60) * time.Second
 
-/*
-// ReadRune fails on IAC AYT => unicode.ReplacementChar X 2
-
-// getch -> ReadRune  Low Level
-func (d *Door) ReadRune() (rune, error) {
-	var r rune
-
-	if d.ReaderClosed {
-		return r, ErrDisconnected
-	}
-
-	for {
-		select {
-		case r = <-d.readerChannel:
-			return r, nil
-		case <-time.After(ReaderInterval):
-			return r, ErrTimeout
-		}
-	}
-}
-
-func (d *Door) RunePushback(r rune) {
-	d.Pushback.Push(r)
-}
-
-// getkey_or_pushback -> ReadRunePushback()
-func (d *Door) ReadRunePushback() (rune, error) {
-	if !d.Pushback.Empty() {
-		if DEBUG_INPUT {
-			log.Println("Read From PushBack")
-		}
-		return d.Pushback.Pop(), nil
-	}
-	return d.ReadRune()
-}
-
-func RuneToInt8(r rune) int8 {
-	return int8(r)
-}
-
-// Confusion - It's possible to return a null rune
-// that we received.  So it's a little sloppy having
-// to check Extended == NOP.  :(
-
-// High Level function - returns rune or extended
-
-func (d *Door) GetKey() (rune, Extended, error) {
-	var r, r2 rune
-	var err, err2 error
-	var ex Extended
-
-	if d.ReaderClosed {
-		return r, ex, ErrDisconnected
-	}
-
-	// if bio.Disconnected() {
-	//	return r, ex, DisconnectedError
-	// }
-
-	r, err = d.ReadRunePushback()
-
-	if err != nil {
-		return r, ex, err
-	}
-
-	// fyneterm CR
-	if r == '\x0a' {
-		r2, err2 = d.ReadRunePushback()
-		if err2 == nil {
-			// Not an error
-			if r2 != '\x00' && r2 != '\x0a' {
-				// Wasn't 0x00 or 0x0a
-				d.RunePushback(r2)
-			}
-		}
-		return '\x0d', ex, nil
-	}
-
-	// We get 0x0d, 0x00, or 0x0d 0x0a from syncterm
-	if r == '\x0d' {
-		r2, err2 = d.ReadRunePushback()
-		if err2 == nil {
-			// Not an error
-			if r2 != '\x00' && r2 != '\x0a' {
-				// Wasn't 0x00 or 0x0a
-				d.RunePushback(r2)
-			}
-		}
-		return r, ex, nil
-	}
-
-	if r == '\x00' {
-		// Possibly doorway mode - deprecated?
-		// syncterm does support this, so it isn't entirely dead (NNY!)
-		r2, _ = d.ReadRunePushback()
-
-		r = rune(0)
-
-		switch r2 {
-		case '\x50':
-			return r, DOWN_ARROW, nil
-		case '\x48':
-			return r, UP_ARROW, nil
-		case '\x4b':
-			return r, LEFT_ARROW, nil
-		case 0x4d:
-			return r, RIGHT_ARROW, nil
-		case 0x47:
-			return r, HOME, nil
-		case 0x4f:
-			return r, END, nil
-		case 0x49:
-			return r, PAGE_UP, nil
-		case 0x51:
-			return r, PAGE_DOWN, nil
-		case 0x3b:
-			return r, F1, nil
-		case 0x3c:
-			return r, F2, nil
-		case 0x3d:
-			return r, F3, nil
-		case 0x3e:
-			return r, F4, nil
-		case 0x3f:
-			return r, F5, nil
-		case 0x40:
-			return r, F6, nil
-		case 0x41:
-			return r, F7, nil
-		case 0x42:
-			return r, F8, nil
-		case 0x43:
-			return r, F9, nil
-		case 0x44:
-			return r, F10, nil
-
-		case 0x45:
-			return r, F11, nil
-		case 0x46:
-			return r, F12, nil
-
-		case 0x52:
-			return r, INSERT, nil
-		case 0x53:
-			return r, DELETE, nil
-		default:
-			log.Printf("ERROR Doorway mode: 0x00 %x\n", r2)
-			return r, UNKNOWN, nil
-		}
-	} // End doorway
-
-	if r == '\x1b' {
-		// Escape key?
-		r2, err2 = d.ReadRunePushback()
-		if err2 != nil {
-			// Just escape key
-			return r, ex, nil
-		}
-
-		if r2 == '\x1b' {
-			d.RunePushback(r2)
-			return r, ex, nil
-		}
-
-		if unicode.IsLetter(r2) {
-			// ALT-KEY
-			if unicode.IsLower(r2) {
-				// Lower case
-				ex = Extended(int(ALT_a) + int(r2-'a'))
-				return r, ex, nil
-			} else {
-				// Upper case
-				ex = Extended(int(ALT_A) + int(r2-'A'))
-				return r, ex, nil
-			}
-		}
-
-		var extended []rune = make([]rune, 0, 10)
-		extended = append(extended, r2)
-		// extended[0] = r2
-
-		var IsMouse bool = false
-
-		r2, err2 = d.ReadRunePushback()
-		for err2 == nil {
-			if r2 == '\x1b' {
-				// This is the end of the extended code.
-				d.RunePushback(r2)
-				break
-			}
-			extended = append(extended, r2)
-
-			ext, has := extendedKeys[string(extended)]
-			if has {
-				// Found it!  Return extended code.
-				return rune(0), ext, nil
-			}
-
-			// Mouse codes can also contain letters.
-			if !IsMouse && unicode.IsLetter(r2) {
-				// The end of the extended code
-				// Unless this is Mouse!
-				if string(extended) == "[M" {
-					IsMouse = true
-				} else {
-					break
-				}
-			}
-
-			if IsMouse && len(extended) == 5 {
-				break
-			}
-
-			r2, err2 = d.ReadRunePushback()
-		}
-
-		log.Printf("Extended Code: [%s]", extended_output(extended))
-
-		var exString string = string(extended)
-		if strings.HasPrefix(exString, "[M") && len(extended) == 5 {
-			// Mouse Extended - input zero based (I add +1 to X, Y, and button)
-			var mouse Mouse = Mouse{Button: RuneToInt8(extended[2]) - ' ' + 1,
-				X: RuneToInt8(extended[3]) - '!' + 1,
-				Y: RuneToInt8(extended[4]) - '!' + 1}
-
-			d.mcMutex.Lock()
-			defer d.mcMutex.Unlock()
-			d.LastMouse = append(d.LastMouse, mouse)
-			log.Println("Mouse:", mouse)
-			return rune(0), MOUSE, nil
-		}
-
-		if strings.HasSuffix(exString, "R") {
-			// Cursor Position information
-			var cursor CursorPos
-			// ^[[1;1R^[[2;3R^[[41;173R
-
-			// Y;X
-			exString = exString[1 : len(exString)-1] // Remove [ and R
-			pos := SplitToInt(exString, ";")
-			if len(pos) == 2 {
-				cursor.X = pos[1]
-				cursor.Y = pos[0]
-				d.mcMutex.Lock()
-				defer d.mcMutex.Unlock()
-				d.LastCursor = append(d.LastCursor, cursor)
-				log.Println("Cursor Pos:", cursor)
-				return rune(0), CURSOR, nil
-			} else {
-				log.Println("ERROR Cursor:", extended)
-				return rune(0), UNKNOWN, nil
-			}
-
-		}
-		if exString == "\x1b" {
-			return extended[0], Extended(0), nil
-		}
-
-		log.Println("ERROR Extended:", extended)
-		return rune(0), UNKNOWN, nil
-	}
-
-	return r, ex, nil
-}
-
-*/
-// "[1":   XKEY_UNKNOWN, // Syncterm is lost, could be F1..F5?
-
 func (d *Door) WaitKey(timeout time.Duration) (rune, Extended, error) {
 	/*
 		d.readerMutex.Lock()
@@ -316,55 +48,6 @@ func (d *Door) WaitKey(timeout time.Duration) (rune, Extended, error) {
 	}
 }
 
-/*
-// port over WaitKey
-func (d *Door) WaitKey(timeout time.Duration) (rune, Extended, error) {
-	// disconnected test
-
-	d.readerMutex.Lock()
-	if d.ReaderClosed {
-		d.readerMutex.Unlock()
-		return rune(0), Extended(0), ErrDisconnected
-	}
-	d.readerMutex.Unlock()
-
-	if !d.Pushback.Empty() {
-		log.Println("WaitKey: Pushback ! empty.")
-		r, ex, e := d.GetKey()
-		if DEBUG_INPUT {
-			log.Println("WaitKey:", r, ex, e)
-		}
-		// return bio.GetKey()
-		return r, ex, e
-	}
-
-	// expiration := time.NewTicker(timeout)
-	// defer expiration.Stop()
-
-	select {
-	case r, ok := <-d.readerChannel:
-		if ok {
-			// Is this blocking? Ignoring expiration?
-			d.RunePushback(r)
-			log.Printf("readerChannel %#v ...\n", r)
-			r, ex, e := d.GetKey()
-			if DEBUG_INPUT {
-				log.Println("WaitKey:", r, ex, e)
-			}
-			// return bio.GetKey()
-			return r, ex, e
-		} else {
-			log.Println("WaitKey: Disconnected")
-			// Reader has closed.
-			// Disconnected = true
-			return rune(0), Extended(0), ErrDisconnected
-		}
-	case <-time.After(timeout):
-		return rune(0), Extended(0), ErrTimeout
-	}
-}
-*/
-
 // Outputs spaces and backspaces
 // If you have set a background color, this shows the input area.
 func DisplayInput(max int) string {
@@ -442,11 +125,5 @@ func (d *Door) GetOneOf(possible string) rune {
 			// return upper case rune
 			return r
 		}
-		/*
-			c = strings.IndexRune(possible, r)
-			if c != -1 {
-				return c
-			}
-		*/
 	}
 }

door/input_linux.go

@@ -12,7 +12,7 @@ import (
 )
 
 var ReaderInterval = time.Duration(200) * time.Millisecond
-var ReaderTimeval syscall.Timeval = syscall.Timeval{0, 200}
+var ReaderTimeval syscall.Timeval = syscall.Timeval{Sec: 0, Usec: 200}
 
 // Output a nice string representation of the rune buffer.
 func extended_output(buffer []rune) string {