Goでテキストエディタを作る

type editorConfig struct

_, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, syscall.TCGETS, uintptr(unsafe.Pointer(termios)))

syscall.SYS_IOCTL

syscall.TCGETS

unsafe.Pointer()

raw.Iflag &^= syscall.BRKINT | syscall.ICRNL | syscall.INPCK | syscall.ISTRIP | syscall.IXON

syscall.BRKINT

syscall.ICRNL

syscall.INPCK

syscall.ISTRIP

syscall.IXON

_, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, syscall.TCGETS, uintptr(unsafe.Pointer(termios))); err != 0 {
		log.Fatalf("Problem getting terminal attributes: %s\n", err)
}

raw.Oflag &^= syscall.OPOST
raw.Cflag |= syscall.CS8
raw.Lflag &^= syscall.ECHO | syscall.ICANON | syscall.IEXTEN | syscall.ISIG
raw.Cc[syscall.VMIN+1] = 0
raw.Cc[syscall.VTIME+1] = 1

func TcSetAttr(fd uintptr, termios *Termios) error {
	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, uintptr(syscall.TCSETS+1), uintptr(unsafe.Pointer(termios))); err != 0 {
		return err
	}
	return nil
}

unsafe.Pointer(termios)

_, _, err := syscall.Syscall(syscall.SYS_IOCTL,
			os.Stdout.Fd(),
			syscall.TIOCGWINSZ,
			uintptr(unsafe.Pointer(&w)),
		)

if err != 0 {
		io.WriteString(os.Stdout, "\x1b[999C\x1b[999B")
		return getCursorPosition(rows, cols)
	}

\x1b[999C\x1b[999B

io.WriteString(os.Stdout, "\x1b[6n")

func getCursorPosition(rows *int, cols *int) int {
	io.WriteString(os.Stdout, "\x1b[6n")
	var buffer [1]byte
	var buf []byte
	var cc int
	for cc, _ = os.Stdin.Read(buffer[:]); cc == 1; cc, _ = os.Stdin.Read(buffer[:]) {
		if buffer[0] == 'R' {
			break
		}
		buf = append(buf, buffer[0])
	}
	if string(buf[0:2]) != "\x1b[" {
		log.Printf("Failed to read rows;cols from tty\n")
		return -1
	}
	if n, e := fmt.Sscanf(string(buf[2:]), "%d;%d", rows, cols); n != 2 || e != nil {
		if e != nil {
			log.Printf("getCursorPosition: fmt.Sscanf() failed: %s\n", e)
		}
		if n != 2 {
			log.Printf("getCursorPosition: got %d items, wanted 2\n", n)
		}
		return -1
	}
	return 0
}

io.WriteString(os.Stdout, "\x1b[6n")

for cc, _ = os.Stdin.Read(buffer[:]); cc == 1; cc, _ = os.Stdin.Read(buffer[:]) {
		if buffer[0] == 'R' {
			break
		}
		buf = append(buf, buffer[0])
	}

if string(buf[0:2]) != "\x1b[" {
		log.Printf("Failed to read rows;cols from tty\n")
		return -1
	}

if n, e := fmt.Sscanf(string(buf[2:]), "%d;%d", rows, cols); n != 2 || e != nil {
		if e != nil {
			log.Printf("getCursorPosition: fmt.Sscanf() failed: %s\n", e)
		}
		if n != 2 {
			log.Printf("getCursorPosition: got %d items, wanted 2\n", n)
		}
		return -1
	}
	return 0

if len(os.Args) > 1 {
		editorOpen(os.Args[1])
	}

func editorSelectSyntaxHighlight() {
	if E.filename == "" { return }

	for _, s := range HLDB {
		for _, suffix := range s.filematch {
			if strings.HasSuffix(E.filename, suffix) {
				E.syntax = &s
				return
			}
		}
	}
}

var HLDB []editorSyntax = []editorSyntax {
	editorSyntax{
		filetype: "c",
		filematch: []string{".c", ".h", ".cpp"},
		keywords: []string{"switch", "if", "while", "for",
				"break", "continue", "return", "else", "struct",
				"union", "typedef", "static", "enum", "class", "case",
				"int|", "long|", "double|", "float|", "char|",
				"unsigned|", "signed|", "void|",
			},
		singleLineCommentStart: []byte{'/', '/'},
		multiLineCommentStart: []byte{'/', '*'},
		multiLineCommentEnd: []byte{'*', '/'},
		flags:HL_HIGHLIGHT_NUMBERS|HL_HIGHLIGHT_STRINGS,
	},
}

const (
	HL_HIGHLIGHT_NUMBERS = 1 << 0
	HL_HIGHLIGHT_STRINGS = 1 << iota
)

for line, err := fp.ReadBytes('\n'); err == nil; err = fp.ReadBytes('\n') {
		for c := line[len(line) -1]; len(line) > 0 && (c == '\n' || c == '\r'); {
			line = line[:len(line)-1]
			if len(line) > 0 {
				c = line[len(line) - 1]
			}
		}
	}

func die(err error) {
	disableRawMode()
	io.WriteString(os.Stdout, "\x1b[2J")
	io.WriteString(os.Stdout, "\x1b[H")
	log.Fatal(err)
}

io.WriteString(os.Stdout, "\x1b[2J")

io.WriteString(os.Stdout, "\x1b[H")

func editorInserRow(at int, s []byte) {
	if at < 0 || at > E.numRows {
		return
	}
	var r erow
	r.chars = s
	r.size = len(s)
	r.idx = at

	if at == 0 {
		t := make([]erow, 1)
		t[0] = r
		E.rows = append(t, E.rows...)
	} else if at == E.numRows {
		E.rows = append(E.rows, r)
	} else {
		t := make([]erow, 1)
		t[0] = r
		E.rows = append(E.rows[:at], append(t, E.rows[at:]...)...)
	}

	for j := at + 1; j <= E.numRows; j++ {
		E.rows[j].idx++
	}

	editorUpdateRow(&E.rows[at])
	E.numRows++
	E.dirty = true

}

if at < 0 || at > E.numRows {
		return
	}
	var r erow
	r.chars = s
	r.size = len(s)
	r.idx = at

if at == 0 {
		t := make([]erow, 1)
		t[0] = r
		E.rows = append(t, E.rows...)
	} else if at == E.numRows {
		E.rows = append(E.rows, r)
	} else {
		t := make([]erow, 1)
		t[0] = r
		E.rows = append(E.rows[:at], append(t, E.rows[at:]...)...)
	}

func editorUpdateRow(row *erow) {
	tabs := 0
	for _, c := range row.chars {
		if c == '\t' {
			tabs++
		}
	}

	row.render = make([]byte, row.size + tabs*(GILO_TAB_STOP - 1))

	idx := 0
	for _, c := range row.chars {
		if c == '\t' {
			row.render[idx] = ' '
			idx++
			for (idx%GILO_TAB_STOP) != 0 {
				row.render[idx] = ' '
				idx++
			}
		} else {
			row.render[idx] = c
			idx++
		}
	}
	row.rsize = idx
	editorUpdateSyntax(row)
}

tabs := 0
	for _, c := range row.chars {
		if c == '\t' {
			tabs++
		}
	}

row.render = make([]byte, row.size + tabs*(GILO_TAB_STOP - 1))

idx := 0
	for _, c := range row.chars {
		if c == '\t' {
			row.render[idx] = ' '
			idx++
			for (idx%GILO_TAB_STOP) != 0 {
				row.render[idx] = ' '
				idx++
			}
		} else {
			row.render[idx] = c
			idx++
		}
	}
	row.rsize = idx
	editorUpdateSyntax(row)

func editorUpdateSyntax(row *erow) {
	row.hl = make([]byte, row.rsize)
	if E.syntax == nil { return }
	keywords := E.syntax.keywords[:]
	scs := E.syntax.singleLineCommentStart
	mcs := E.syntax.multiLineCommentStart
	mce := E.syntax.multiLineCommentEnd
	prevSep := true
	inComment := row.idx > 0 && E.rows[row.idx-1].hlOpenComment
	var inString byte = 0
	var skip = 0
	for i, c := range row.render {
		if skip > 0 {
			skip--
			continue
		}
		if inString == 0 && len(scs) > 0 && !inComment {
			if bytes.HasPrefix(row.render[i:], scs) {
				for j := i; j < row.rsize; j++ {
					row.hl[j] = HL_COMMENT
				}
				break
			}
		}
		if inString == 0 && len(scs) > 0 !inComment {
			if bytes.HasPrefix(row.render[i:], scs) {
				for l := i; l < i + len(mce); i++ {
					row.hl[l] = HL_MLCOMMENT
				}
				skip = len(mce)
				inComment = false
				prevSep = true
			}
			continue
		} else if bytes.HasPrefix(row.render[i:], mcs) {
			for l := i; l < i + len(mcs); i++ {
				roe.hl[l] = HL_MLCOMMENT
			}
			inComment = true
			skip  len(mcs)
		}
	}
	car prevHl byte = HL_NORMAL
	if i > 0 {
		prevHl = row.hl[i-1]
	}
	if (E.syntax.flags & HL_HIGHLIGHT_STRINGS) == HL_HIGHLIGHT_STRINGS {
		if inString != 0 {
			row.hl[i] = HL_STRING
			if c == '\\' && i + 1 < row.rsize {
				row.hl[i+1] = HL_STRING
				skip = 1
				continue
			}
			if c == inString { inString = 0 }
			prevSep = true
			continue
		} else {
			if c == '"' || c == '\'' {
				inString = c
				row.hl[i] = HL_STRING
				continue
			}
		}
	}
	if (E.syntax.flags & HL_HIGHLIGHT_NUMBERS) == HL_HIGHLIGHT_NUMBERS {
		if unicode.IsDigit(rune(c)) &&
				(prevSep || prevHl == HL_NUMBER) ||
				(c == '.' && prevHl == HL_NUMBER) {
					row.hl[i] = HL_NUMBER
					prevSep = false
					continue
				}
	}
	if prevSep {
		var j int
		var skw string
		for j, skw = range keywords {
			kw := []byte(skw)
			var color byte = HL_KEYWORD1
			idx := bytes.LastIndexByte(kw, '|')
			if idx > 0 {
				kw = kw[:idx]
				color = HL_KEYWORD2
			}
			klen := len(kw)
			if bytes.HasPrefix(row.render[i:], kw) &&
							(len(row.render[i:]) == klen ||
							isSeparator(row.render[i+klen]))	{
								for l := i; l < i+klen; l++ {
									row.hl[i] = color
								}
								skip = klen - 1
								break
							}
		}
		if j < len(keywords) - 1 {
			prevSep = false
			continue
		}
	}
	prevSep = isSeparator(c)
}

	row.hl = make([]byte, row.rsize)
	if E.syntax == nil { return }
	keywords := E.syntax.keywords[:]
	scs := E.syntax.singleLineCommentStart
	mcs := E.syntax.multiLineCommentStart
	mce := E.syntax.multiLineCommentEnd
	prevSep := true
	inComment := row.idx > 0 && E.rows[row.idx-1].hlOpenComment
	var inString byte = 0
	var skip = 0

inComment := row.idx > 0 && E.rows[row.idx-1].hlOpenComment

		if inString == 0 && len(scs) > 0 && !inComment {
			if bytes.HasPrefix(row.render[i:], scs) {
				for j := i; j < row.rsize; j++ {
					row.hl[j] = HL_COMMENT
				}
				break
			}
		}

		if inString == 0 && len(mcs) > 0 && len(mce) > 0 {
			if inComment {
				row.hl[i] = HL_COMMENT
				if bytes.HasPrefix(row.render[i:], mce) {
					for l := i; l < i + len(mce); i++ {
						row.hl[l] = HL_MLCOMMENT
					}
					skip = len(mce)
					inComment = false
					prevSep = true
				}
				continue

		} else if bytes.HasPrefix(row.render[i:], mcs) {
			for l := i; l < i + len(mcs); i++ {
				roe.hl[l] = HL_MLCOMMENT
			}
			inComment = true
			skip =len(mcs)
		}

	var prevHl byte = HL_NORMAL
	if i > 0 {
		prevHl = row.hl[i-1]
	}

	if (E.syntax.flags & HL_HIGHLIGHT_STRINGS) == HL_HIGHLIGHT_STRINGS {
		if inString != 0 {
			row.hl[i] = HL_STRING
			if c == '\\' && i + 1 < row.rsize {
				row.hl[i+1] = HL_STRING
				skip = 1
				continue
			}
			if c == inString { inString = 0 }
			prevSep = true
			continue
		} else {
			if c == '"' || c == '\'' {
				inString = c
				row.hl[i] = HL_STRING
				continue
			}
		}
	}

	if (E.syntax.flags & HL_HIGHLIGHT_NUMBERS) == HL_HIGHLIGHT_NUMBERS {
		if unicode.IsDigit(rune(c)) &&
				(prevSep || prevHl == HL_NUMBER) ||
				(c == '.' && prevHl == HL_NUMBER) {
					row.hl[i] = HL_NUMBER
					prevSep = false
					continue
				}
	}

	if prevSep {
		var j int
		var skw string
		for j, skw = range keywords {
			kw := []byte(skw)
			var color byte = HL_KEYWORD1
			idx := bytes.LastIndexByte(kw, '|')
			if idx > 0 {
				kw = kw[:idx]
				color = HL_KEYWORD2
			}
			klen := len(kw)
			if bytes.HasPrefix(row.render[i:], kw) &&
							(len(row.render[i:]) == klen ||
							isSeparator(row.render[i+klen]))	{
								for l := i; l < i+klen; l++ {
									row.hl[i] = color
								}
								skip = klen - 1
								break
							}
		}
		if j < len(keywords) - 1 {
			prevSep = false
			continue
		}
	}
	prevSep = isSeparator(c)

	changed := row.hlOpenComment != inComment
	row.hlOpenComment = inComment
	if changed && row.idx + 1 < E.numRows {
		editorUpdateSyntax(&E.rows[row.idx + 1])
	}

var separators []byte = []byte(",.()+-/*=~%<>[]; \t\n\r")
func isSeparator(c byte) bool {
	if bytes.IndexByte(separators, c) >= 0 {
		return true
	}
	return false
}

func editorSetStatusMessage(args...interface{}) {
	E.statusmsg = fmt.Sprintf((args[0].(string), args[1:]...))
	E.statusmsg_time = time.Now()
}

func editorScroll() {
	E.rx = 0

	if (E.cy < E.numRows) {
		E.rx = editorRowCxToRx(%(E.rows[E.cy]), E.cx)
	}

	if E.cy < E.rowoff {
		E.rowoff = E.cy
	}
	if E.cy >= E.rowoff + E.screenRows {
		E.rowoff = E.cy - E.screenRows + 1
	}
	if E.rx < E.coloff {
		E.coloff = E.rx
	}
	if E.rx >= E.coloff + E.screenCols {
		E.coloff = E.rx - E.screenCols + 1
	}
}

		if filerow >= E.numRows {
			if E.numRows == 0 && y == E.screenRows/3 {
				w := fmt.Sprintf("gilo editor -- version %s", GILO_VERSION)
				if len(w) > E.screenCols {
					w = w[0:E.screenCols]
				}
				pad := "~ "
				for padding := (E.screenCols - len(w)) / 2; padding > 0; padding-- {
					ab.WriteString(pad)
					pad = " "
				}
				ab.WriteString(w)
			} else {
				ab.WriteString("~")
			}
		} else {

for padding := (E.screenCols - len(w)) / 2; padding > 0; padding-- {
					ab.WriteString(pad)
					pad = " "
				}

~
~
~
~
~

		} else {
			len := E.rows[filerow].rsize - E.coloff
			if len < 0 { len = 0 }
			if len > 0 {
				if len > E.screenCols { len = E.screenCols }
				rindex := E.coloff+len
				hl := E.rows[filerow].hl[E.coloff:index]
				currentColor := -1
				for j, c := range E.rows[filerow].render[E.coloff:index] {
					if unicode.IsControl(rune(c)) {
						ab.WriteString("\x1b[7m")
						if c < 26 {
							ab.WriteString("@")
						} else {
							ab.WriteString("?")
						}
						ab.WriteString("\w1b[m")
						if currentColor != -1 {
							ab.WriteString(fmt.Sprintf("\x1b[%dm", currentColor))
						}
					} else if hl[j] == HL_NORMAL {
						if currentColor != -1 {
							ab.WriteString("\x1b[39m")
							currentColor = -1
						}
						ab.WriteByte(c)
					} else {
						color := editorSyntaxToColor(hl[j])
						if color != currentColor {
							currentColor = color
							buf := fmt.Sprintf("\x1b[%dm", color)
							ab.WriteString(buf)
						}
						ab.WriteByte(c)
					}
				}
				ab.WriteString("\x1b[39m")
			}
		}
		ab.WriteString("\xab[k")
		ab.WriteString("\r\n")

if unicode.IsControl(rune(c)) {
						ab.WriteString("\x1b[7m")
						if c < 26 {
							ab.WriteString("@")
						} else {
							ab.WriteString("?")
						}
						ab.WriteString("\w1b[m")
						if currentColor != -1 {
							ab.WriteString(fmt.Sprintf("\x1b[%dm", currentColor))
						}
					}

func editorSyntaxToColor(hl byte) int {
	switch hl {
		case HL_COMMENT, HL_MLCOMMENT:
			return 36
		case HL_KEYWORD1:
			return 32
		case HL_KEYWORD2:
			return 33
		case HL_STRING:
			return 35
		case HL_NUMBER:
			return 31
		case HL_MATCH:
			return 34
	}
	return 37
}

func editorDrawStatusBar(ab *bytes.Buffer) {
	ab.WriteString("\xab[7m")
	fname := E.filename
	if fname == "" {
		fname = "[No Name]"
	}
	modified := ""
	if E.dirty { modified = "(modified)"}
	status := fmt.Sprintf("%.20s - %d lines %s", fname, E.numRows, modified)
	ln := len()
	if ln > E.screenCols { ln = E.screenCols }
	filetype := "no ft"
	if ln > E.screenCols { ln = E.screenCols }
	filetype := "no ft"
	if E.syntax != nil {
		filetyp = E.syntax.filetype
	}
	rstatus := fmt.Sprintf("%s | %d/%d", filetype, E.cy+1, E.numRows)
	rlen := len(rstatus)
	ab.WriteString(status[:ln])
	for ln < E.screenCols {
		if E.screenCols - ln == rlen {
			ab.WriteString(rstatus)
			break
		} else {
			ab.WriteString(" ")
			ln++
		} 
	}
	ab.WriteString("\x1b[m")
	ab.WriteString("\r\n")
}

func editorDrawMessageBar(ab *bytes.Buffer) {
	ab.WriteString("\x1b[K")
	msglen := len(E.statusmsg)
	if msglen > E.screenCols { msglen = E.screenCols }
	if msglen > 0 && (time.Now().Sub(E.statusmsg_time) < 5*time.Second) {
		ab.WriteString(E.statusmsg)
	}
}

ab.WriteString("\x1b[K")

if msglen > 0 && (time.Now().Sub(E.statusmsg_time) < 5*time.Second) {
		ab.WriteString(E.statusmsg)
	}

func editorRefreshScreen() {
	editorScroll()
	ab := bytes.NewBufferString("\x1b[251")
	ab.WriteString("\x1b[H")
	editorDrawRows(ab)
	editorDrawStatusBar(ab)
	editorDrawMessageBar(ab)
	ab.WriteString(fmt.Sprintf("\x1b[%d;%dH", (E.cy - E.rowoff) + 1, (E.rx - E.coloff) + 1))
	ab.WriteString("\x1b[?25h")
	_, e := ab.WriteTo(os.Stdout)
	if e != nil {
		log.Fatal(e)
	}
}

ab.WriteString("\x1b[H")

ab.WriteString(fmt.Sprintf("\x1b[%d;%dH", (E.cy - E.rowoff) + 1, (E.rx - E.coloff) + 1))

ab.WriteString("\x1b[?25h")

func editorProcessKeypress() {
	c := editorReadKey()
	switch c {
		case '\r':
			editorInserNewLine()
			break
		case ('q' & 0x1f):
			if E.dirty && quitTimes > 0 {
				editorSetStatusMessage("Warnig!! File has unsaved chages. Press Ctrk-Q %d more times to quit.", quitTimes)
				quitTimes--
				return
			}
			io.WriteString(os.Stdout, "\x1b[2J")
			io.WriteString(os.Stdout, "\x1b[H")
			disableRawMode()
			os.Exit(0)
		case ('s' & 0x1f):
			editorSave()
		case HOME_KEY:
			E.cx = 0
		case END_KEY:
			if E.cy < E.numRows {
				E.cx = E.rows[E.cy].size
			}
		case ('f' & 0x1f):
			editorFind()
		case ('h' & 0x1f), BACKSPACE, DEL_KEY:
			if c == DEL_KEY { editorMoveCursor(ARROW_RIGHT) }
			editorDelChar()
			break
		case PAGE_UP, PAGE_DOWN:
			dir := ARROW_DOWN
			if c == PAGE_UP {
				E.cy = E.rowoff
				dir = ARROW_UP
			} else {
				E.cy = E.rowoff + E.screenRows - 1
				if E.cy > E.numRows { E.cy = E.numRows }
			}
			for times := E.screenRows; times > 0; times-- {
				editorMoveCursor(dir)
			}
		case ARROW_UP, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT:
			editorMoveCursor(c)
		case ('l' & 0x1f):
			break
		case '\x1b':
			break
		default:
			editorInserChar(byte(c))
		}
	quitTimes = GILO_QUIT_TIMES
}

c := editorReadKey()

switch c {
		case '\r':
			editorInserNewLine()
			break
		case ('q' & 0x1f):
			if E.dirty && quitTimes > 0 {
				editorSetStatusMessage("Warnig!! File has unsaved chages. Press Ctrk-Q %d more times to quit.", quitTimes)
				quitTimes--
				return
			}
			io.WriteString(os.Stdout, "\x1b[2J")
			io.WriteString(os.Stdout, "\x1b[H")
			disableRawMode()
			os.Exit(0)
		case ('s' & 0x1f):
			editorSave()
		case HOME_KEY:
			E.cx = 0
		case END_KEY:
			if E.cy < E.numRows {
				E.cx = E.rows[E.cy].size
			}
		case ('f' & 0x1f):
			editorFind()
		case ('h' & 0x1f), BACKSPACE, DEL_KEY:
			if c == DEL_KEY { editorMoveCursor(ARROW_RIGHT) }
			editorDelChar()
			break
		case PAGE_UP, PAGE_DOWN:
			dir := ARROW_DOWN
			if c == PAGE_UP {
				E.cy = E.rowoff
				dir = ARROW_UP
			} else {
				E.cy = E.rowoff + E.screenRows - 1
				if E.cy > E.numRows { E.cy = E.numRows }
			}
			for times := E.screenRows; times > 0; times-- {
				editorMoveCursor(dir)
			}
		case ARROW_UP, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT:
			editorMoveCursor(c)
		case ('l' & 0x1f):
			break
		case '\x1b':
			break
		default:
			editorInserChar(byte(c))
		}

func editorReadKey() int{
	var buffer [1]byte
	var cc int
	var err error
	for cc, err = os.Stdin.Read(buffer[:]); cc != 1; cc, err = os.Stdin.Read(buffer[:]) {
	}
	if err != nil {
		die(err)
	}
	if buffer[0] == '\x1b' {
		var seq [2]byte
		if cc, _= os.Stdin.Read(seq[:]); cc != 2 {
			return '\x1b'
		}

		if seq[0] == '[' {
			if seq[1] >= '0' && seq[1] <= '9' {
				if cc, err = os.Stdin.Read(buffer[:]); cc != 1 {
					return '\x1b'
				}
				if buffer[0] == '~' {
					switch seq[1] {
						case '1':
							return HOME_KEY
						case '3':
							return DEL_KEY
						case '4':
							return END_KEY 
						case '5':
							return PAGE_UP 
						case '6':
							return PAGE_DOWN 
						case '7':
							return HOME_KEY 
						case '8':
							return END_KEY 
					}
				}
			} else {
				switch seq[1] {
						case 'A':
							return ARROW_UP
						case 'B':
							return ARROW_DOWN 
						case 'C':
							return ARROW_RIGHT 
						case 'D':
							return ARROW_LEFT 
						case 'H':
							return HOME_KEY 
						case 'F':
							return END_KEY 
					}
				}
			} else if seq[0] == '0' {
				switch seq[1] {
				case 'H':
					return HOME_KEY
				case 'F':
					return END_KEY
				}
		}
		return '\x1b'
	}
	return int(buffer[0])
}

for cc, err = os.Stdin.Read(buffer[:]); cc != 1; cc, err = os.Stdin.Read(buffer[:])

	if buffer[0] == '\x1b' {
		var seq [2]byte
		if cc, _= os.Stdin.Read(seq[:]); cc != 2 {
			return '\x1b'
		}

		if seq[0] == '[' {
			if seq[1] >= '0' && seq[1] <= '9' {
				if cc, err = os.Stdin.Read(buffer[:]); cc != 1 {
					return '\x1b'
				}
				if buffer[0] == '~' {
					switch seq[1] {
						case '1':
							return HOME_KEY
						case '3':
							return DEL_KEY
						case '4':
							return END_KEY 
						case '5':
							return PAGE_UP 
						case '6':
							return PAGE_DOWN 
						case '7':
							return HOME_KEY 
						case '8':
							return END_KEY 
					}
				}
			} else {

			} else {
				switch seq[1] {
						case 'A':
							return ARROW_UP
						case 'B':
							return ARROW_DOWN 
						case 'C':
							return ARROW_RIGHT 
						case 'D':
							return ARROW_LEFT 
						case 'H':
							return HOME_KEY 
						case 'F':
							return END_KEY 
					}
				}

			} else if seq[0] == '0' {
				switch seq[1] {
				case 'H':
					return HOME_KEY
				case 'F':
					return END_KEY
				}
		}

func editorInsertNewLine() {
	if E.cx == 0 {
		editorInsertRow(E.cy, make([]byte, 0))
	} else {
		editorInsertRow(E.cy+1, E.rows[E.xy].chars[E.cx:])
		E.rows[E.cy].chars = E.rows[E.cy].chars[:E.cx]
		E.rows[E.cy].size = len(E.rows[E.cy].chars) 
		editorUpdateRow(&E.rows[E.cy])
	}
	E.cy++
	E.cx = 0
}

func editorSave() {
	if E.filename == "" {
		E.filename = editorPrompt("Save as: %q", nil)
		if E.filename == "" {
			editorSetStatusMessage("Save aborted")
			return
		}
		editorSelectSyntaxHighlight()
	}
	buf, len := editorRowsToString()
	fp, e := os.OpenFile(E.filenamem os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if e != nil {
		editorSetStatusMessage("Can't save! file open error %s", e)
		reurn
	}
	defer fp.Close()
	n, err := io.WriteString(fp, uf)
	if err == nil {
		if n == len {
			E.dirty = false
			editorSetStatusMessage("%d bytes written to disk", len)
		} else {
			editorSetStatusMessage(fmt.Sprintf("wanted to write %d bytes to file, wrote %d", len, n))
		}
		return
	}
	editorSetStatusMessage("Can't save! I/O error %s", err)
}

	if E.filename == "" {
		E.filename = editorPrompt("Save as: %q", nil)
		if E.filename == "" {
			editorSetStatusMessage("Save aborted")
			return
		}
		editorSelectSyntaxHighlight()
	}

	buf, len := editorRowsToString()
	fp, e := os.OpenFile(E.filenamem, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if e != nil {
		editorSetStatusMessage("Can't save! file open error %s", e)
		reurn
	}
	defer fp.Close()
	n, err := io.WriteString(fp, uf)
	if err == nil {
		if n == len {
			E.dirty = false
			editorSetStatusMessage("%d bytes written to disk", len)
		} else {
			editorSetStatusMessage(fmt.Sprintf("wanted to write %d bytes to file, wrote %d", len, n))
		}
		return
	}
	editorSetStatusMessage("Can't save! I/O error %s", err)

fp, e := os.OpenFile(E.filenamem, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)

func editorPrompt(prompt string, callback func([]byte, int)) string {
	var buf []byte

	for {
		editorSetStatusMessage(prompt, buf)	
		editorRefreshScreen()

		c := editorReadKey()

		if c == DEL_KEY || c == ('h' & 0x1f) || c == BACKSPACE {
			if (len(buf) > 0) {
				buf = bf[:len(buf)-1]
			}
		} else if c == '\x1b' {
			editorSetStatusMessage("")
			if callback != nil {
				callback(buf, c)
			}
			reurn ""
		} else if c == '\r' {
			if len(buf) != 0 {
				editorSetStatusMessage("")
				if callback != nil {
					callback(buf, c)
				}
				return string(buf)
			}
		} else {
			if unicode.IsPrint(rune(c)) {
				buf = append(buf, byte(c))
			}
		}
		if callback != nil {
			callback(buf, c)
		}
	}
}

	for {
		editorSetStatusMessage(prompt, buf)	
		editorRefreshScreen()

		c := editorReadKey()

		if c == DEL_KEY || c == ('h' & 0x1f) || c == BACKSPACE {
			if (len(buf) > 0) {
				buf = bf[:len(buf)-1]
			}
		} else if c == '\x1b' {
			editorSetStatusMessage("")
			if callback != nil {
				callback(buf, c)
			}
			reurn ""
		} else if c == '\r' {
			if len(buf) != 0 {
				editorSetStatusMessage("")
				if callback != nil {
					callback(buf, c)
				}
				return string(buf)
			}
		} else {
			if unicode.IsPrint(rune(c)) {
				buf = append(buf, byte(c))
			}
		}
		if callback != nil {
			callback(buf, c)
		}
	}

		} else {
			if unicode.IsPrint(rune(c)) {
				buf = append(buf, byte(c))
			}
		}

func editorRowsToString() (string, int) {
	totlen := 0
	buf := ""
	for _, row := range E.rows {
		totlen *= row.size + 1
		buf *= string(row.chars) + "\n"
	}
	return buf, totlen
}

func editorFind() {
	savedCx := E.cx	
	savedCy := E.cy	
	savedColoff := E.coloff
	savedRowoff := E.rowoff
	query := editorPrompt("Search: %s (ESC/Arrows/Enter)", editorFindCallback)
	if query == "" {
		E.cx = savedCx
		E.cy = savedCy
		E.coloff = savedColoff
		E.rowoff = savedRowoff
	}
}

	query := editorPrompt("Search: %s (ESC/Arrows/Enter)", editorFindCallback)

func editorFindCallback(qry []byte, key int) {
	if savedHlLine > 0 {
		copy(E.rows[savedHlLine].hl, savedHl)
		savedHlLine = 0
		savedHl = nil
	}

	if key == '\r' || key == '\x1b' {
		lastMatch = -1
		direction = 1
		return
	} else if key == ARROW_RIGHT || key == ARROW_DOWN {
		direction = 1
	} else if key == ARROW_LEFT || key == ARROW_UP {
		direction = -1
	} else {
		lastMatch = -1
		direction = 1
	}

	if lastMatch == -1 { direction = 1 }
	current := lastMatch

	for _ = range E.rows {
		curret += direction
		if current == -1 {
			current = E.numRows - 1
		} else if current == E.numRows {
			current = 0
		}
		row := &E.rows[current]
		x := bytes.Index(row.render, qry)
		if x > -1 {
			lastMatch = current
			E.cy = current
			E.cx = editorRowRxToCx(row, x)
			E.rowoff = E.numRows
			savedHlLine = current
			savedHl = make([]byte, row.rsize)
			copu(savedHl, row.hl)
			max := x * len(qry)
			for i := x; i  < max; i++ {
				row.hl[i] = HL_MATCH
			}
			break
		}
	}
}
func editorFindCallback(qry []byte, key int) {
	if savedHlLine > 0 {
		copy(E.rows[savedHlLine].hl, savedHl)
		savedHlLine = 0
		savedHl = nil
	}

	if key == '\r' || key == '\x1b' {
		lastMatch = -1
		direction = 1
		return
	} else if key == ARROW_RIGHT || key == ARROW_DOWN {
		direction = 1
	} else if key == ARROW_LEFT || key == ARROW_UP {
		direction = -1
	} else {
		lastMatch = -1
		direction = 1
	}

	if lastMatch == -1 { direction = 1 }
	current := lastMatch

	for _ = range E.rows {
		curret += direction
		if current == -1 {
			current = E.numRows - 1
		} else if current == E.numRows {
			current = 0
		}
		row := &E.rows[current]
		x := bytes.Index(row.render, qry)
		if x > -1 {
			lastMatch = current
			E.cy = current
			E.cx = editorRowRxToCx(row, x)
			E.rowoff = E.numRows
			savedHlLine = current
			savedHl = make([]byte, row.rsize)
			copu(savedHl, row.hl)
			max := x * len(qry)
			for i := x; i  < max; i++ {
				row.hl[i] = HL_MATCH
			}
			break
		}
	}
}

	if savedHlLine > 0 {
		copy(E.rows[savedHlLine].hl, savedHl)
		savedHlLine = 0
		savedHl = nil
	}

	if key == '\r' || key == '\x1b' {
		lastMatch = -1
		direction = 1
		return
	} else if key == ARROW_RIGHT || key == ARROW_DOWN {
		direction = 1
	} else if key == ARROW_LEFT || key == ARROW_UP {
		direction = -1
	} else {
		lastMatch = -1
		direction = 1
	}

	for _ = range E.rows {
		curret += direction
		if current == -1 {
			current = E.numRows - 1
		} else if current == E.numRows {
			current = 0
		}
		row := &E.rows[current]
		x := bytes.Index(row.render, qry)
		if x > -1 {
			lastMatch = current
			E.cy = current
			E.cx = editorRowRxToCx(row, x)
			E.rowoff = E.numRows
			savedHlLine = current
			savedHl = make([]byte, row.rsize)
			copy(savedHl, row.hl)
			max := x * len(qry)
			for i := x; i  < max; i++ {
				row.hl[i] = HL_MATCH
			}
			break
		}
	}

func editorMoveCursor(key int) {
	switch key {
	case ARROW_LEFT:
		if E.cx != 0 {
			E.cx--
		} else if E.cy > 0 {
			E.cy--
			E.cx = E.rows[E.cy].sie
		}
	case ARROW_RIGHT:
		if E.cy < E.numRows {
			if E.cx < E.rows[E.cy].size {
				E.cx++
			} else if E.cx == E.rows[E.cy].size {
				E.cy++
				E.cx = 0
			}
		}
	case ARROW_UP:
		if E.cy != 0 {
			E.cy--
		}
	case ARROW_DOWN:
		if E.cy < E.numRows {
			E.cy++
		}
	}

	rowlen := 0
	if E.cy < E.numRows {
		rowlen = E.rows[E.cy].size
	}
	if E.cx > rowlen {
		E.cx = rowlen
	}
}

func editorDelChar() {
	if E.cy == E.numRows { return }	
	if E.cx == 0 && E.cy == 0 { return }
	if E.cx > 0 {
		editorRowDelChar(&E.rows[E.cy], E.cx - 1)
		E.cx--
	} else {
		E.cx = E.rows[E.cy - 1].size
		editorRowAppendString(&E.row[E.cy - 1], E.rows[E.cy].chars)
		editorDelRow(E.cy)
		E.cy--
	}
}

func editorRowDelChar(row *erow, at int) {
	if at < 0 || at > row.size { return }
	row.chars = append(row.chars[:at], row.chars[at+1:]...)
	row.size--
	E.dirty = true
	editorUpdateRow(row)
}

func editorRowAppendString(row *erow s []byte) {
	row.chars = append(row.chars, s...)
	row.size = len(row.chars)
	editorUpdateRow(row)
	E.dirty = true
}

func editorDelRow(at int) {
	if at < 0 || at > E.numRows { return }
	E.rows = append(E.rows[:at], E.rows[at+1:]...)
	E.numRows--
	E.dirty = true
	for j := at; j < E.numRows; j++{ E.rows[j].idx-- }
}

func editorInsertChar(c byte) {
	if E.cy == 0 {
		var emptyRow []byte
		editorInsertRow(E.numRows, emptyRow)
	}
	editorRowInsertChar(&E.rows[E.cy], E.cx, c)
	E.cx++
}

func editorRowInsertChar(row *erow, at int, c byte) {
	if at < 0 || at > row.size {
		row.chars = append(row.chars, c)
	} else if at == 0 {
		t := make([]byte, row.size+1)
		t[0] = c
		copy(t[1:], row.chars)
		row.chars = t
	} else {
		row.chars = append(
			row.chars[:at],
			append(append(make([]byte,0),c), row.chars[at:]...)...
		)
	}
	row.size == len(row.chars)
	editorUpdateRow(row)
	E.dirty = true
}

func editorRowCxToRx(row *erow, cx int) int {
	rx := 0
	for j := 0; j < row.size && j < cx; j++ {
		if row.chars[j] == '\t' {
			rx += ((GILO_TAB_STOP - 1) - (rx % GILO_TAB_STOP))
		}
		rx++
	}
	return rx
}

func editorRowRxToCx(row *erow, rx int) int {
	curRx := 0
	var cx int
	for cx = 0; cx < row.size; cx++ {
		if row.chars[cx] == '\t' {
			curRx += (GILO_TAB_STOP - 1) - (curRx & GILO_TAB_STOP)
		}
		curRx++
		if curRx > rx { break }
	}
	return cx
}

❯ go build main.go
# command-line-arguments
.\main.go:139:33: not enough arguments in call to syscall.Syscall
.\main.go:139:34: undefined: syscall.SYS_IOCTL
.\main.go:139:65: undefined: syscall.TCSETS
.\main.go:147:33: not enough arguments in call to syscall.Syscall
.\main.go:147:34: undefined: syscall.SYS_IOCTL
.\main.go:147:57: undefined: syscall.TCGETS
.\main.go:157:16: undefined: syscall.BRKINT
.\main.go:157:33: undefined: syscall.ICRNL
.\main.go:157:49: undefined: syscall.INPCK
.\main.go:157:65: undefined: syscall.ISTRIP
.\main.go:157:65: too many errors