input_linux.go 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514
  1. package door
  2. import (
  3. "bufio"
  4. "bytes"
  5. "io"
  6. "log"
  7. "strings"
  8. "syscall"
  9. "time"
  10. "unicode"
  11. )
  12. var ReaderInterval = time.Duration(200) * time.Millisecond
  13. var ReaderTimeval syscall.Timeval = syscall.Timeval{Sec: 0, Usec: 200}
  14. // Output a nice string representation of the rune buffer.
  15. func extended_output(buffer []rune) string {
  16. var output string = string(buffer)
  17. output = strings.Replace(output, "\x1b", "^[", -1)
  18. return output
  19. }
  20. // syscall.FdSet clear all
  21. func clearAll(fdSetPtr *syscall.FdSet) {
  22. for index := range (*fdSetPtr).Bits {
  23. (*fdSetPtr).Bits[index] = 0
  24. }
  25. }
  26. // syscall.FdSet set fd
  27. func set(fdSetPtr *syscall.FdSet, fd int) {
  28. (*fdSetPtr).Bits[fd/64] |= 1 << uint64(fd%64)
  29. }
  30. func RuneToInt8(r rune) int8 {
  31. return int8(r)
  32. }
  33. const READ_SIZE = 16 // Size of read buffer
  34. var readerBuffer []rune
  35. // Translate these extended codes into these Extended values.
  36. var extendedKeys map[string]Extended = map[string]Extended{
  37. "[A": UP_ARROW,
  38. "[B": DOWN_ARROW,
  39. "[C": RIGHT_ARROW,
  40. "[D": LEFT_ARROW,
  41. "[H": HOME,
  42. "[F": END, // terminal
  43. "[K": END,
  44. "[V": PAGE_UP,
  45. "[U": PAGE_DOWN,
  46. "[@": INSERT,
  47. "[2~": INSERT, // terminal
  48. "[3~": DELETE, // terminal
  49. "[5~": PAGE_UP, // terminal
  50. "[6~": PAGE_DOWN, // terminal
  51. "[15~": F5, // terminal
  52. "[17~": F6, // terminal
  53. "[18~": F7, // terminal
  54. "[19~": F8, // terminal
  55. "[20~": F9, // terminal
  56. "[21~": F10, // terminal
  57. "[23~": F11,
  58. "[24~": F12, // terminal
  59. "OP": F1,
  60. "OQ": F2,
  61. "OR": F3,
  62. "OS": F4, // syncterm "[1" = F1,F2,F3, and F4)
  63. "Ot": F5, // syncterm
  64. }
  65. func process(d *Door, newRune bool) {
  66. // This is like GetKey
  67. var rlen int
  68. var r, r2 rune
  69. var has2 bool
  70. var done bool = false
  71. for !done {
  72. rlen = len(readerBuffer)
  73. if rlen == 0 {
  74. // Nothing to do here
  75. return
  76. }
  77. log.Println("rlen:", rlen, "readerBuffer:", readerBuffer, "newRune:", newRune)
  78. r = readerBuffer[0]
  79. if rlen >= 2 {
  80. r2 = readerBuffer[1]
  81. has2 = true
  82. } else {
  83. r2 = unicode.ReplacementChar
  84. has2 = false
  85. }
  86. // if !has2 and !newRune, then we're "done" (received everything,
  87. // and there's nothing else coming...)
  88. // fyneterm CR
  89. if r == '\x0a' {
  90. if !has2 && !newRune {
  91. ArrayPop(&readerBuffer, 1)
  92. d.readerChannel <- ReaderData{R: '\x0d', Ex: NOP, Err: nil}
  93. return
  94. }
  95. if has2 {
  96. ArrayPop(&readerBuffer, 1)
  97. if r2 == '\x00' || r2 == '\x0a' {
  98. ArrayPop(&readerBuffer, 1)
  99. }
  100. d.readerChannel <- ReaderData{R: '\x0d', Ex: NOP, Err: nil}
  101. } else {
  102. // We don't have a 2nd rune, and we haven't timed out.
  103. return
  104. }
  105. continue
  106. }
  107. // We get 0x0d, 0x00, or 0x0d 0x0a from syncterm
  108. if r == '\x0d' {
  109. if !has2 && !newRune {
  110. ArrayPop(&readerBuffer, 1)
  111. d.readerChannel <- ReaderData{R: r, Ex: NOP, Err: nil}
  112. return
  113. }
  114. if has2 {
  115. ArrayPop(&readerBuffer, 1)
  116. if r2 == '\x00' || r2 == '\x0a' {
  117. ArrayPop(&readerBuffer, 1)
  118. }
  119. d.readerChannel <- ReaderData{R: r, Ex: NOP, Err: nil}
  120. } else {
  121. return
  122. }
  123. continue
  124. }
  125. if r == '\x00' {
  126. // Possibly doorway mode - deprecated?
  127. // syncterm does support this.
  128. if !has2 && !newRune {
  129. // timeout
  130. ArrayPop(&readerBuffer, 1)
  131. d.readerChannel <- ReaderData{R: r, Ex: NOP, Err: nil}
  132. return
  133. }
  134. if has2 {
  135. ArrayPop(&readerBuffer, 2)
  136. switch r2 {
  137. case '\x50':
  138. d.readerChannel <- ReaderData{0, DOWN_ARROW, nil}
  139. case '\x48':
  140. d.readerChannel <- ReaderData{0, UP_ARROW, nil}
  141. case '\x4b':
  142. d.readerChannel <- ReaderData{0, LEFT_ARROW, nil}
  143. case 0x4d:
  144. d.readerChannel <- ReaderData{0, RIGHT_ARROW, nil}
  145. case 0x47:
  146. d.readerChannel <- ReaderData{0, HOME, nil}
  147. case 0x4f:
  148. d.readerChannel <- ReaderData{0, END, nil}
  149. case 0x49:
  150. d.readerChannel <- ReaderData{0, PAGE_UP, nil}
  151. case 0x51:
  152. d.readerChannel <- ReaderData{0, PAGE_DOWN, nil}
  153. case 0x3b:
  154. d.readerChannel <- ReaderData{0, F1, nil}
  155. case 0x3c:
  156. d.readerChannel <- ReaderData{0, F2, nil}
  157. case 0x3d:
  158. d.readerChannel <- ReaderData{0, F3, nil}
  159. case 0x3e:
  160. d.readerChannel <- ReaderData{0, F4, nil}
  161. case 0x3f:
  162. d.readerChannel <- ReaderData{0, F5, nil}
  163. case 0x40:
  164. d.readerChannel <- ReaderData{0, F6, nil}
  165. case 0x41:
  166. d.readerChannel <- ReaderData{0, F7, nil}
  167. case 0x42:
  168. d.readerChannel <- ReaderData{0, F8, nil}
  169. case 0x43:
  170. d.readerChannel <- ReaderData{0, F9, nil}
  171. case 0x44:
  172. d.readerChannel <- ReaderData{0, F10, nil}
  173. case 0x45:
  174. d.readerChannel <- ReaderData{0, F11, nil}
  175. case 0x46:
  176. d.readerChannel <- ReaderData{0, F12, nil}
  177. case 0x52:
  178. d.readerChannel <- ReaderData{0, INSERT, nil}
  179. case 0x53:
  180. d.readerChannel <- ReaderData{0, DELETE, nil}
  181. default:
  182. log.Printf("ERROR Doorway mode: 0x00 %x\n", r2)
  183. d.readerChannel <- ReaderData{0, UNKNOWN, nil}
  184. }
  185. } else {
  186. return
  187. }
  188. continue
  189. } // end doorway mode
  190. if r == '\x1b' {
  191. // Escape key, or ?
  192. // This is a little harder, since we don't know how many we need.
  193. if !has2 && !newRune {
  194. ArrayPop(&readerBuffer, 1)
  195. d.readerChannel <- ReaderData{r, NOP, nil}
  196. return
  197. }
  198. if has2 {
  199. // We at least have the 2nd one...
  200. if r2 == '\x1b' {
  201. ArrayPop(&readerBuffer, 1)
  202. d.readerChannel <- ReaderData{r, NOP, nil}
  203. continue
  204. }
  205. // Can't distinguish between \x1bO and \x1bOP (F1)
  206. /*
  207. if unicode.IsLetter(r2) {
  208. // ALT-KEY
  209. if unicode.IsLower(r2) {
  210. ArrayPop(&readerBuffer, 2)
  211. ex := Extended(int(ALT_a) + int(r2-'a'))
  212. d.readerChannel <- ReaderData{0, ex, nil}
  213. } else {
  214. // Must be upper
  215. ArrayPop(&readerBuffer, 2)
  216. ex := Extended(int(ALT_A) + int(r2-'A'))
  217. d.readerChannel <- ReaderData{0, ex, nil}
  218. }
  219. continue
  220. }
  221. */
  222. var extended []rune = make([]rune, 0, 10)
  223. extended = append(extended, r2)
  224. var extlen = 2 // Length of codes to remove on successful match.
  225. var pos = 2 // Where we get the next rune from
  226. var isMouse bool = false
  227. var found bool = false
  228. log.Println(pos, readerBuffer)
  229. for pos < rlen {
  230. r2 = readerBuffer[pos]
  231. pos++
  232. extlen++
  233. extended = append(extended, r2)
  234. log.Println("0x1b LOOP pos:", pos, "extlen:", extlen, "extended:", string(extended))
  235. ext, has := extendedKeys[string(extended)]
  236. if has {
  237. // Found it!
  238. log.Println("Found Extended Match:", ext.String())
  239. ArrayPop(&readerBuffer, extlen)
  240. d.readerChannel <- ReaderData{0, ext, nil}
  241. found = true
  242. break
  243. }
  244. // Mouse codes can also contain letters.
  245. if !isMouse && unicode.IsLetter(r2) {
  246. // end of extended code, unless mouse!
  247. log.Println("not mouse, is letter...")
  248. if string(extended) == "[M" {
  249. isMouse = true
  250. } else {
  251. break
  252. }
  253. }
  254. if isMouse && len(extended) == 5 {
  255. break
  256. }
  257. }
  258. if found {
  259. continue
  260. }
  261. log.Println("POS:", pos, "EXLEN:", extlen, "Extended:", extended, "readerBuffer:", readerBuffer)
  262. log.Printf("(possible) Extended Code: [%s]", extended_output(extended))
  263. var exString string = string(extended)
  264. if strings.HasPrefix(exString, "[M") && len(extended) == 5 {
  265. // Yes, "valid"
  266. ArrayPop(&readerBuffer, extlen)
  267. // Mouse Extended - input zero based (I add +1 to X, Y, and button)
  268. var mouse Mouse = Mouse{Button: RuneToInt8(extended[2]) - ' ' + 1,
  269. X: RuneToInt8(extended[3]) - '!' + 1,
  270. Y: RuneToInt8(extended[4]) - '!' + 1}
  271. d.mcMutex.Lock()
  272. d.LastMouse = append(d.LastMouse, mouse)
  273. d.mcMutex.Unlock()
  274. log.Println("Mouse:", mouse)
  275. d.readerChannel <- ReaderData{0, MOUSE, nil}
  276. continue
  277. }
  278. if strings.HasSuffix(exString, "R") {
  279. // yes, "valid"
  280. ArrayPop(&readerBuffer, extlen)
  281. // Cursor Position information (or Shift-F3)
  282. var cursor CursorPos
  283. // ^[[1;1R^[[2;3r^[[41;173R
  284. // Y;X
  285. exString = exString[1 : len(exString)-1] // Remove [ and R
  286. pos := SplitToInt(exString, ";")
  287. if len(pos) == 2 {
  288. cursor.X = pos[1]
  289. cursor.Y = pos[0]
  290. d.mcMutex.Lock()
  291. d.LastCursor = append(d.LastCursor, cursor)
  292. d.mcMutex.Unlock()
  293. log.Println("Cursor Pos:", cursor)
  294. d.readerChannel <- ReaderData{0, CURSOR, nil}
  295. continue
  296. } else {
  297. log.Println("ERROR Cursor Pos:", extended)
  298. d.readerChannel <- ReaderData{0, UNKNOWN, nil}
  299. continue
  300. }
  301. }
  302. // Ok, this LOOKS like something invalid...
  303. if !newRune {
  304. // Yes, this is invalid.
  305. ArrayPop(&readerBuffer, extlen)
  306. log.Println("ERROR Extended:", extended)
  307. d.readerChannel <- ReaderData{0, UNKNOWN, nil}
  308. } else {
  309. log.Println("(Possibly) invalid extended:", extended)
  310. return
  311. }
  312. } else {
  313. return
  314. }
  315. continue
  316. }
  317. ArrayPop(&readerBuffer, 1)
  318. d.readerChannel <- ReaderData{r, NOP, nil}
  319. continue
  320. }
  321. }
  322. // go routine Reader for input
  323. // This "times out" every ReaderTimeval
  324. func Reader(d *Door) {
  325. // I need non-blocking reads here.
  326. readerBuffer = make([]rune, 0, READ_SIZE*2)
  327. defer func() {
  328. log.Printf("~Reader\n")
  329. if d.ReaderCanClose {
  330. d.wg.Done()
  331. }
  332. }()
  333. defer func() {
  334. if err := recover(); err != nil {
  335. log.Printf("Reader: %#v\n", err)
  336. }
  337. }()
  338. var fdset syscall.FdSet
  339. var readbuffer [READ_SIZE]byte
  340. var runebuffer bytes.Buffer
  341. var runeread = bufio.NewReaderSize(&runebuffer, 1)
  342. for {
  343. clearAll(&fdset)
  344. set(&fdset, d.READFD)
  345. v, err := syscall.Select(d.READFD+1, &fdset, nil, nil, &ReaderTimeval)
  346. if err == syscall.EINTR {
  347. continue
  348. }
  349. // log.Printf("Select: %#v / %#v\n", v, err)
  350. if v == -1 {
  351. log.Printf("Reader ERR: %#v\n", err)
  352. d.readerMutex.Lock()
  353. if !d.ReaderClosed {
  354. d.ReaderClosed = true
  355. close(d.readerChannel)
  356. }
  357. return
  358. }
  359. if v == 0 {
  360. // timeout
  361. process(d, false)
  362. continue
  363. }
  364. // The buffer used here must have len & cap to size you want to read.
  365. // use [BUFF_SIZE]byte for readone
  366. r, err := syscall.Read(d.READFD, readbuffer[:])
  367. if r == -1 {
  368. log.Println("syscall.Read -1 (closed)")
  369. d.readerMutex.Lock()
  370. defer d.readerMutex.Unlock()
  371. if !d.ReaderClosed {
  372. d.ReaderClosed = true
  373. d.Disconnected = true
  374. close(d.readerChannel)
  375. }
  376. return
  377. }
  378. if r == 0 {
  379. log.Printf("Select said ready, but: %#v %#v\n", r, err)
  380. d.readerMutex.Lock()
  381. defer d.readerMutex.Unlock()
  382. if !d.ReaderClosed {
  383. d.ReaderClosed = true
  384. d.Disconnected = true
  385. close(d.readerChannel)
  386. }
  387. return
  388. }
  389. if DEBUG_INPUT {
  390. log.Printf("Reader << %d, %#v\n", r, readbuffer[:r])
  391. }
  392. runebuffer.Write(readbuffer[:r])
  393. var input rune
  394. // Is this unicode?
  395. err = nil
  396. for err == nil {
  397. //RuneRead:
  398. input, _, err = runeread.ReadRune()
  399. if err == io.EOF {
  400. break // continue
  401. }
  402. if err != nil {
  403. log.Printf("ReadRune: %#v\n", err)
  404. // errors EOF
  405. break // continue // break for loop
  406. }
  407. if input == unicode.ReplacementChar {
  408. runeread.UnreadRune()
  409. b, _ := runeread.ReadByte()
  410. if DEBUG_INPUT {
  411. log.Printf("Reader (byte) >> %x\n", b)
  412. }
  413. readerBuffer = append(readerBuffer, rune(b))
  414. // d.readerChannel <- rune(b)
  415. } else {
  416. if DEBUG_INPUT {
  417. log.Printf("Reader >> %x\n", input)
  418. }
  419. readerBuffer = append(readerBuffer, input)
  420. // d.readerChannel <- input
  421. }
  422. // process(d, true)
  423. } // goto RuneRead
  424. process(d, true)
  425. // buffer = append(buffer, readone[0])
  426. /*
  427. Take2:
  428. input, size = utf8.DecodeRune(buffer)
  429. if input != utf8.RuneError {
  430. d.readerChannel <- input
  431. for size > 0 {
  432. ArrayDelete(&buffer, 0)
  433. size--
  434. }
  435. if len(buffer) > 0 {
  436. goto Take2
  437. }
  438. timeoutCount = 0
  439. } else {
  440. // Not a valid rune
  441. continue
  442. }
  443. */
  444. // d.readerChannel <- rune(buffer[0])
  445. }
  446. }