Merge

Allow GitHub to detect license

.gitignore

@@ -1,6 +1,9 @@
+.DS_Store
+
 micro
 !cmd/micro
 binaries/
 tmp.sh
 test/
 .idea/
+packages/

.gitmodules

@@ -0,0 +1,57 @@
+[submodule "cmd/micro/vendor/github.com/blang/semver"]
+	path = cmd/micro/vendor/github.com/blang/semver
+	url = https://github.com/blang/semver
+[submodule "cmd/micro/vendor/github.com/dustin/go-humanize"]
+	path = cmd/micro/vendor/github.com/dustin/go-humanize
+	url = https://github.com/dustin/go-humanize
+[submodule "cmd/micro/vendor/github.com/go-errors/errors"]
+	path = cmd/micro/vendor/github.com/go-errors/errors
+	url = https://github.com/go-errors/errors
+[submodule "cmd/micro/vendor/github.com/mattn/go-isatty"]
+	path = cmd/micro/vendor/github.com/mattn/go-isatty
+	url = https://github.com/mattn/go-isatty
+[submodule "cmd/micro/vendor/github.com/mattn/go-runewidth"]
+	path = cmd/micro/vendor/github.com/mattn/go-runewidth
+	url = https://github.com/mattn/go-runewidth
+[submodule "cmd/micro/vendor/github.com/mitchellh/go-homedir"]
+	path = cmd/micro/vendor/github.com/mitchellh/go-homedir
+	url = https://github.com/mitchellh/go-homedir
+[submodule "cmd/micro/vendor/github.com/sergi/go-diff"]
+	path = cmd/micro/vendor/github.com/sergi/go-diff
+	url = https://github.com/sergi/go-diff
+[submodule "cmd/micro/vendor/github.com/yuin/gopher-lua"]
+	path = cmd/micro/vendor/github.com/yuin/gopher-lua
+	url = https://github.com/yuin/gopher-lua
+[submodule "cmd/micro/vendor/golang.org/x/net"]
+	path = cmd/micro/vendor/golang.org/x/net
+	url = https://go.googlesource.com/net
+[submodule "cmd/micro/vendor/github.com/zyedidia/clipboard"]
+	path = cmd/micro/vendor/github.com/zyedidia/clipboard
+	url = https://github.com/zyedidia/clipboard
+[submodule "cmd/micro/vendor/github.com/zyedidia/glob"]
+	path = cmd/micro/vendor/github.com/zyedidia/glob
+	url = https://github.com/zyedidia/glob
+[submodule "cmd/micro/vendor/github.com/zyedidia/tcell"]
+	path = cmd/micro/vendor/github.com/zyedidia/tcell
+	url = https://github.com/zyedidia/tcell
+[submodule "cmd/micro/vendor/github.com/gdamore/encoding"]
+	path = cmd/micro/vendor/github.com/gdamore/encoding
+	url = https://github.com/gdamore/encoding
+[submodule "cmd/micro/vendor/golang.org/x/text"]
+	path = cmd/micro/vendor/golang.org/x/text
+	url = https://go.googlesource.com/text
+[submodule "cmd/micro/vendor/github.com/lucasb-eyer/go-colorful"]
+	path = cmd/micro/vendor/github.com/lucasb-eyer/go-colorful
+	url = https://github.com/lucasb-eyer/go-colorful
+[submodule "cmd/micro/vendor/layeh.com/gopher-luar"]
+	path = cmd/micro/vendor/layeh.com/gopher-luar
+	url = https://github.com/layeh/gopher-luar
+[submodule "cmd/micro/vendor/gopkg.in/yaml.v2"]
+	path = cmd/micro/vendor/gopkg.in/yaml.v2
+	url = https://gopkg.in/yaml.v2
+[submodule "cmd/micro/vendor/github.com/zyedidia/poller"]
+	path = cmd/micro/vendor/github.com/zyedidia/poller
+	url = https://github.com/zyedidia/poller
+[submodule "cmd/micro/vendor/github.com/flynn/json5"]
+	path = cmd/micro/vendor/github.com/flynn/json5
+	url = https://github.com/flynn/json5

LICENSE

@@ -1,6 +1,6 @@
-Micro is licensed under the MIT "Expat" License:
+MIT License
 
-Copyright (c) 2016: Zachary Yedidia.
+Copyright (c) 2016-2017: Zachary Yedidia, et al.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

Makefile

@@ -1,14 +1,17 @@
 .PHONY: runtime
 
-VERSION = $(shell go run tools/build-version.go)
-HASH = $(shell git rev-parse --short HEAD)
-DATE = $(shell go run tools/build-date.go)
-ADDITIONAL_GO_LINKER_FLAGS = $(shell go run tools/info-plist.go "$(VERSION)")
-
-GOBIN ?= $(GOPATH)/bin
+VERSION := $(shell GOOS=$(shell go env GOHOSTOS) GOARCH=$(shell go env GOHOSTARCH) \
+	go run tools/build-version.go)
+HASH := $(shell git rev-parse --short HEAD)
+DATE := $(shell GOOS=$(shell go env GOHOSTOS) GOARCH=$(shell go env GOHOSTARCH) \
+	go run tools/build-date.go)
+ADDITIONAL_GO_LINKER_FLAGS := $(shell GOOS=$(shell go env GOHOSTOS) \
+	GOARCH=$(shell go env GOHOSTARCH) \
+	go run tools/info-plist.go "$(VERSION)")
+GOBIN ?= $(shell go env GOPATH)/bin
 
 # Builds micro after checking dependencies but without updating the runtime
-build: deps
+build: update
 	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 # Builds micro after building the runtime and checking dependencies
@@ -19,7 +22,7 @@ build-quick:
 	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 # Same as 'build' but installs to $GOBIN afterward
-install: deps
+install: update
 	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 # Same as 'build-all' but installs to $GOBIN afterward
@@ -29,13 +32,9 @@ install-all: runtime install
 install-quick:
 	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)"  ./cmd/micro
 
-# Checks for dependencies
-deps:
-	go get -d ./cmd/micro
-
 update:
 	git pull
-	go get -u -d ./cmd/micro
+	git submodule update --init
 
 # Builds the runtime
 runtime:
@@ -44,7 +43,6 @@ runtime:
 	mv runtime.go cmd/micro
 
 test:
-	go get -d ./cmd/micro
 	go test ./cmd/micro
 
 clean:

README.md

@@ -4,6 +4,7 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/zyedidia/micro)](https://goreportcard.com/report/github.com/zyedidia/micro)
 [![Join the chat at https://gitter.im/zyedidia/micro](https://badges.gitter.im/zyedidia/micro.svg)](https://gitter.im/zyedidia/micro?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/zyedidia/micro/blob/master/LICENSE)
+[![Snap Status](https://build.snapcraft.io/badge/zyedidia/micro.svg)](https://build.snapcraft.io/user/zyedidia/micro)
 
 Micro is a terminal-based text editor that aims to be easy to use and intuitive, while also taking advantage of the full capabilities
 of modern terminals. It comes as one single, batteries-included, static binary with no dependencies, and you can download and use it right now.
@@ -23,6 +24,7 @@ You can also check out the website for Micro at https://micro-editor.github.io.
 
 * Easy to use and to install
 * No dependencies or external files are needed -- just the binary you can download further down the page
+* Multiple cursors
 * Common keybindings (ctrl-s, ctrl-c, ctrl-v, ctrl-z...)
     * Keybindings can be rebound to your liking
 * Sane defaults
@@ -75,12 +77,24 @@ You can install micro using Homebrew on Mac:
 brew install micro
 ```
 
-On Windows, you can install micro through Chocolatey:
+On Windows, you can install micro through [Chocolatey](https://chocolatey.org/) or [Scoop](https://github.com/lukesampson/scoop):
 
 ```
 choco install micro
 ```
 
+or
+
+```
+scoop install micro
+```
+
+On Linux, you can install micro through [snap](https://snapcraft.io/docs/core/install)
+
+```
+snap install micro --edge --classic
+```
+
 ### Building from source
 
 If your operating system does not have a binary release, but does run Go, you can build from source.
@@ -88,15 +102,21 @@ If your operating system does not have a binary release, but does run Go, you ca
 Make sure that you have Go version 1.5 or greater (Go 1.4 will work if your version supports CGO) and that your `GOPATH` env variable is set (I recommand setting it to `~/go` if you don't have one).
 
 ```
-go get -d github.com/zyedidia/micro
+go get -d github.com/zyedidia/micro/cmd/micro
 cd $GOPATH/src/github.com/zyedidia/micro
 make install
 ```
 
 The binary will then be installed to `$GOPATH/bin` (or your `$GOBIN`).
 
+Please make sure that when you are working with micro's code, you are working on your `GOPATH`.
+
 You can install directly with `go get` (`go get -u github.com/zyedidia/micro/cmd/micro`) but this isn't recommended because it doesn't build micro with version information which is useful for the plugin manager.
 
+### MacOS terminal
+
+If you are using MacOS, you should consider using [iTerm2](http://iterm2.com/) instead of the default Mac terminal. The iTerm2 terminal has much better mouse support as well as better handling of key events. The newest versions also support true color.
+
 ### Linux clipboard support
 
 On Linux, clipboard support requires the 'xclip' or 'xsel' commands to be installed.
@@ -123,11 +143,11 @@ that micro's default colorscheme won't look very good. You can either set
 the colorscheme to `simple`, or download a better terminal emulator, like
 mintty.
 
-### Plan9, NaCl, Cygwin
+### Plan9, Cygwin
 
 Please note that micro uses the amazing [tcell library](https://github.com/gdamore/tcell), but this
 means that micro is restricted to the platforms tcell supports. As a result, micro does not support
-Plan9, NaCl, and Cygwin (although this may change in the future).
+Plan9, and Cygwin (although this may change in the future). Micro also doesn't support NaCl (but NaCl is deprecated anyways).
 
 # Usage
 
@@ -164,6 +184,7 @@ a brief introduction to the more powerful configuration features micro offers.
 
 If you find any bugs, please report them! I am also happy to accept pull requests from anyone.
 
-You can use the [GitHub issue tracker](https://github.com/zyedidia/micro/issues) to report bugs, ask questions, or suggest new features.
+You can use the [GitHub issue tracker](https://github.com/zyedidia/micro/issues)
+to report bugs, ask questions, or suggest new features.
 
 For a more informal setting to discuss the editor, you can join the [Gitter chat](https://gitter.im/zyedidia/micro).

cmd/micro/actions_other.go

@@ -0,0 +1,9 @@
+// +build android plan9 nacl windows
+
+package main
+
+func (v *View) Suspend(usePlugin bool) bool {
+	messenger.Error("Suspend is only supported on Linux")
+
+	return false
+}

cmd/micro/actions_posix.go

@@ -0,0 +1,37 @@
+// +build linux darwin dragonfly solaris openbsd netbsd freebsd
+
+package main
+
+import "syscall"
+
+// Suspend sends micro to the background. This is the same as pressing CtrlZ in most unix programs.
+// This only works on linux and has no default binding.
+// This code was adapted from the suspend code in nsf/godit
+func (v *View) Suspend(usePlugin bool) bool {
+	if usePlugin && !PreActionCall("Suspend", v) {
+		return false
+	}
+
+	screenWasNil := screen == nil
+
+	if !screenWasNil {
+		screen.Fini()
+		screen = nil
+	}
+
+	// suspend the process
+	pid := syscall.Getpid()
+	err := syscall.Kill(pid, syscall.SIGSTOP)
+	if err != nil {
+		TermMessage(err)
+	}
+
+	if !screenWasNil {
+		InitScreen()
+	}
+
+	if usePlugin {
+		return PostActionCall("Suspend", v)
+	}
+	return true
+}

cmd/micro/autocomplete.go

@@ -98,6 +98,25 @@ func HelpComplete(input string) (string, []string) {
 	return chosen, suggestions
 }
 
+// ColorschemeComplete tab-completes names of colorschemes.
+func ColorschemeComplete(input string) (string, []string) {
+	var suggestions []string
+	files := ListRuntimeFiles(RTColorscheme)
+
+	for _, f := range files {
+		if strings.HasPrefix(f.Name(), input) {
+			suggestions = append(suggestions, f.Name())
+		}
+	}
+
+	var chosen string
+	if len(suggestions) == 1 {
+		chosen = suggestions[0]
+	}
+
+	return chosen, suggestions
+}
+
 func contains(s []string, e string) bool {
 	for _, a := range s {
 		if a == e {
@@ -129,7 +148,7 @@ func OptionComplete(input string) (string, []string) {
 	return chosen, suggestions
 }
 
-// MakeCompletion registeres a function from a plugin for autocomplete commands
+// MakeCompletion registers a function from a plugin for autocomplete commands
 func MakeCompletion(function string) Completion {
 	pluginCompletions = append(pluginCompletions, LuaFunctionComplete(function))
 	return Completion(-len(pluginCompletions))

cmd/micro/bindings.go

@@ -5,95 +5,119 @@ import (
 	"os"
 	"strings"
 
-	"github.com/zyedidia/json5/encoding/json5"
+	"github.com/flynn/json5"
 	"github.com/zyedidia/tcell"
 )
 
 var bindings map[Key][]func(*View, bool) bool
+var mouseBindings map[Key][]func(*View, bool, *tcell.EventMouse) bool
 var helpBinding string
 
+var mouseBindingActions = map[string]func(*View, bool, *tcell.EventMouse) bool{
+	"MousePress":       (*View).MousePress,
+	"MouseMultiCursor": (*View).MouseMultiCursor,
+}
+
 var bindingActions = map[string]func(*View, bool) bool{
-	"CursorUp":            (*View).CursorUp,
-	"CursorDown":          (*View).CursorDown,
-	"CursorPageUp":        (*View).CursorPageUp,
-	"CursorPageDown":      (*View).CursorPageDown,
-	"CursorLeft":          (*View).CursorLeft,
-	"CursorRight":         (*View).CursorRight,
-	"CursorStart":         (*View).CursorStart,
-	"CursorEnd":           (*View).CursorEnd,
-	"SelectToStart":       (*View).SelectToStart,
-	"SelectToEnd":         (*View).SelectToEnd,
-	"SelectUp":            (*View).SelectUp,
-	"SelectDown":          (*View).SelectDown,
-	"SelectLeft":          (*View).SelectLeft,
-	"SelectRight":         (*View).SelectRight,
-	"WordRight":           (*View).WordRight,
-	"WordLeft":            (*View).WordLeft,
-	"SelectWordRight":     (*View).SelectWordRight,
-	"SelectWordLeft":      (*View).SelectWordLeft,
-	"DeleteWordRight":     (*View).DeleteWordRight,
-	"DeleteWordLeft":      (*View).DeleteWordLeft,
-	"SelectToStartOfLine": (*View).SelectToStartOfLine,
-	"SelectToEndOfLine":   (*View).SelectToEndOfLine,
-	"InsertNewline":       (*View).InsertNewline,
-	"InsertSpace":         (*View).InsertSpace,
-	"Backspace":           (*View).Backspace,
-	"Delete":              (*View).Delete,
-	"InsertTab":           (*View).InsertTab,
-	"Save":                (*View).Save,
-	"SaveAs":              (*View).SaveAs,
-	"Find":                (*View).Find,
-	"FindNext":            (*View).FindNext,
-	"FindPrevious":        (*View).FindPrevious,
-	"Center":              (*View).Center,
-	"Undo":                (*View).Undo,
-	"Redo":                (*View).Redo,
-	"Copy":                (*View).Copy,
-	"Cut":                 (*View).Cut,
-	"CutLine":             (*View).CutLine,
-	"DuplicateLine":       (*View).DuplicateLine,
-	"DeleteLine":          (*View).DeleteLine,
-	"MoveLinesUp":         (*View).MoveLinesUp,
-	"MoveLinesDown":       (*View).MoveLinesDown,
-	"IndentSelection":     (*View).IndentSelection,
-	"OutdentSelection":    (*View).OutdentSelection,
-	"OutdentLine":         (*View).OutdentLine,
-	"Paste":               (*View).Paste,
-	"PastePrimary":        (*View).PastePrimary,
-	"SelectAll":           (*View).SelectAll,
-	"OpenFile":            (*View).OpenFile,
-	"Start":               (*View).Start,
-	"End":                 (*View).End,
-	"PageUp":              (*View).PageUp,
-	"PageDown":            (*View).PageDown,
-	"HalfPageUp":          (*View).HalfPageUp,
-	"HalfPageDown":        (*View).HalfPageDown,
-	"StartOfLine":         (*View).StartOfLine,
-	"EndOfLine":           (*View).EndOfLine,
-	"ToggleHelp":          (*View).ToggleHelp,
-	"ToggleRuler":         (*View).ToggleRuler,
-	"JumpLine":            (*View).JumpLine,
-	"ClearStatus":         (*View).ClearStatus,
-	"ShellMode":           (*View).ShellMode,
-	"CommandMode":         (*View).CommandMode,
-	"Escape":              (*View).Escape,
-	"Quit":                (*View).Quit,
-	"QuitAll":             (*View).QuitAll,
-	"AddTab":              (*View).AddTab,
-	"PreviousTab":         (*View).PreviousTab,
-	"NextTab":             (*View).NextTab,
-	"NextSplit":           (*View).NextSplit,
-	"PreviousSplit":       (*View).PreviousSplit,
-	"Unsplit":             (*View).Unsplit,
-	"VSplit":              (*View).VSplitBinding,
-	"HSplit":              (*View).HSplitBinding,
-	"ToggleMacro":         (*View).ToggleMacro,
-	"PlayMacro":           (*View).PlayMacro,
+	"CursorUp":              (*View).CursorUp,
+	"CursorDown":            (*View).CursorDown,
+	"CursorPageUp":          (*View).CursorPageUp,
+	"CursorPageDown":        (*View).CursorPageDown,
+	"CursorLeft":            (*View).CursorLeft,
+	"CursorRight":           (*View).CursorRight,
+	"CursorStart":           (*View).CursorStart,
+	"CursorEnd":             (*View).CursorEnd,
+	"SelectToStart":         (*View).SelectToStart,
+	"SelectToEnd":           (*View).SelectToEnd,
+	"SelectUp":              (*View).SelectUp,
+	"SelectDown":            (*View).SelectDown,
+	"SelectLeft":            (*View).SelectLeft,
+	"SelectRight":           (*View).SelectRight,
+	"WordRight":             (*View).WordRight,
+	"WordLeft":              (*View).WordLeft,
+	"SelectWordRight":       (*View).SelectWordRight,
+	"SelectWordLeft":        (*View).SelectWordLeft,
+	"DeleteWordRight":       (*View).DeleteWordRight,
+	"DeleteWordLeft":        (*View).DeleteWordLeft,
+	"SelectToStartOfLine":   (*View).SelectToStartOfLine,
+	"SelectToEndOfLine":     (*View).SelectToEndOfLine,
+	"InsertNewline":         (*View).InsertNewline,
+	"InsertSpace":           (*View).InsertSpace,
+	"Backspace":             (*View).Backspace,
+	"Delete":                (*View).Delete,
+	"InsertTab":             (*View).InsertTab,
+	"Save":                  (*View).Save,
+	"SaveAll":               (*View).SaveAll,
+	"SaveAs":                (*View).SaveAs,
+	"Find":                  (*View).Find,
+	"FindNext":              (*View).FindNext,
+	"FindPrevious":          (*View).FindPrevious,
+	"Center":                (*View).Center,
+	"Undo":                  (*View).Undo,
+	"Redo":                  (*View).Redo,
+	"Copy":                  (*View).Copy,
+	"Cut":                   (*View).Cut,
+	"CutLine":               (*View).CutLine,
+	"DuplicateLine":         (*View).DuplicateLine,
+	"DeleteLine":            (*View).DeleteLine,
+	"MoveLinesUp":           (*View).MoveLinesUp,
+	"MoveLinesDown":         (*View).MoveLinesDown,
+	"IndentSelection":       (*View).IndentSelection,
+	"OutdentSelection":      (*View).OutdentSelection,
+	"OutdentLine":           (*View).OutdentLine,
+	"Paste":                 (*View).Paste,
+	"PastePrimary":          (*View).PastePrimary,
+	"SelectAll":             (*View).SelectAll,
+	"OpenFile":              (*View).OpenFile,
+	"Start":                 (*View).Start,
+	"End":                   (*View).End,
+	"PageUp":                (*View).PageUp,
+	"PageDown":              (*View).PageDown,
+	"HalfPageUp":            (*View).HalfPageUp,
+	"HalfPageDown":          (*View).HalfPageDown,
+	"StartOfLine":           (*View).StartOfLine,
+	"EndOfLine":             (*View).EndOfLine,
+	"ToggleHelp":            (*View).ToggleHelp,
+	"ToggleRuler":           (*View).ToggleRuler,
+	"JumpLine":              (*View).JumpLine,
+	"ClearStatus":           (*View).ClearStatus,
+	"ShellMode":             (*View).ShellMode,
+	"CommandMode":           (*View).CommandMode,
+	"Escape":                (*View).Escape,
+	"Quit":                  (*View).Quit,
+	"QuitAll":               (*View).QuitAll,
+	"AddTab":                (*View).AddTab,
+	"PreviousTab":           (*View).PreviousTab,
+	"NextTab":               (*View).NextTab,
+	"NextSplit":             (*View).NextSplit,
+	"PreviousSplit":         (*View).PreviousSplit,
+	"Unsplit":               (*View).Unsplit,
+	"VSplit":                (*View).VSplitBinding,
+	"HSplit":                (*View).HSplitBinding,
+	"ToggleMacro":           (*View).ToggleMacro,
+	"PlayMacro":             (*View).PlayMacro,
+	"Suspend":               (*View).Suspend,
+	"ScrollUp":              (*View).ScrollUpAction,
+	"ScrollDown":            (*View).ScrollDownAction,
+	"SpawnMultiCursor":      (*View).SpawnMultiCursor,
+	"RemoveMultiCursor":     (*View).RemoveMultiCursor,
+	"RemoveAllMultiCursors": (*View).RemoveAllMultiCursors,
+	"SkipMultiCursor":       (*View).SkipMultiCursor,
 
 	// This was changed to InsertNewline but I don't want to break backwards compatibility
 	"InsertEnter": (*View).InsertNewline,
 }
 
+var bindingMouse = map[string]tcell.ButtonMask{
+	"MouseLeft":       tcell.Button1,
+	"MouseMiddle":     tcell.Button2,
+	"MouseRight":      tcell.Button3,
+	"MouseWheelUp":    tcell.WheelUp,
+	"MouseWheelDown":  tcell.WheelDown,
+	"MouseWheelLeft":  tcell.WheelLeft,
+	"MouseWheelRight": tcell.WheelRight,
+}
+
 var bindingKeys = map[string]tcell.Key{
 	"Up":             tcell.KeyUp,
 	"Down":           tcell.KeyDown,
@@ -213,6 +237,8 @@ var bindingKeys = map[string]tcell.Key{
 	"CtrlRightSq":    tcell.KeyCtrlRightSq,
 	"CtrlCarat":      tcell.KeyCtrlCarat,
 	"CtrlUnderscore": tcell.KeyCtrlUnderscore,
+	"CtrlPageUp":     tcell.KeyCtrlPgUp,
+	"CtrlPageDown":   tcell.KeyCtrlPgDn,
 	"Tab":            tcell.KeyTab,
 	"Esc":            tcell.KeyEsc,
 	"Escape":         tcell.KeyEscape,
@@ -228,12 +254,14 @@ var bindingKeys = map[string]tcell.Key{
 type Key struct {
 	keyCode   tcell.Key
 	modifiers tcell.ModMask
+	buttons   tcell.ButtonMask
 	r         rune
 }
 
 // InitBindings initializes the keybindings for micro
 func InitBindings() {
 	bindings = make(map[Key][]func(*View, bool) bool)
+	mouseBindings = make(map[Key][]func(*View, bool, *tcell.EventMouse) bool)
 
 	var parsed map[string]string
 	defaults := DefaultBindings()
@@ -299,6 +327,7 @@ modSearch:
 			return Key{
 				keyCode:   code,
 				modifiers: modifiers,
+				buttons:   -1,
 				r:         0,
 			}, true
 		}
@@ -309,6 +338,16 @@ modSearch:
 		return Key{
 			keyCode:   code,
 			modifiers: modifiers,
+			buttons:   -1,
+			r:         0,
+		}, true
+	}
+
+	// See if we can find the key in bindingMouse
+	if code, ok := bindingMouse[k]; ok {
+		return Key{
+			modifiers: modifiers,
+			buttons:   code,
 			r:         0,
 		}, true
 	}
@@ -318,12 +357,13 @@ modSearch:
 		return Key{
 			keyCode:   tcell.KeyRune,
 			modifiers: modifiers,
+			buttons:   -1,
 			r:         rune(k[0]),
 		}, true
 	}
 
 	// We don't know what happened.
-	return Key{}, false
+	return Key{buttons: -1}, false
 }
 
 // findAction will find 'action' using string 'v'
@@ -337,6 +377,16 @@ func findAction(v string) (action func(*View, bool) bool) {
 	return action
 }
 
+func findMouseAction(v string) func(*View, bool, *tcell.EventMouse) bool {
+	action, ok := mouseBindingActions[v]
+	if !ok {
+		// If the user seems to be binding a function that doesn't exist
+		// We hope that it's a lua function that exists and bind it to that
+		action = LuaFunctionMouseBinding(v)
+	}
+	return action
+}
+
 // BindKey takes a key and an action and binds the two together
 func BindKey(k, v string) {
 	key, ok := findKey(k)
@@ -350,22 +400,35 @@ func BindKey(k, v string) {
 	if helpBinding == k && v != "ToggleHelp" {
 		helpBinding = ""
 	}
-	
+
 	actionNames := strings.Split(v, ",")
 	if actionNames[0] == "UnbindKey" {
 		delete(bindings, key)
+		delete(mouseBindings, key)
 		if len(actionNames) == 1 {
-			actionNames = make([]string, 0, 0)
-		} else {
-			actionNames = append(actionNames[:0], actionNames[1:]...)
+			return
 		}
+		actionNames = append(actionNames[:0], actionNames[1:]...)
 	}
 	actions := make([]func(*View, bool) bool, 0, len(actionNames))
+	mouseActions := make([]func(*View, bool, *tcell.EventMouse) bool, 0, len(actionNames))
 	for _, actionName := range actionNames {
-		actions = append(actions, findAction(actionName))
+		if strings.HasPrefix(actionName, "Mouse") {
+			mouseActions = append(mouseActions, findMouseAction(actionName))
+		} else {
+			actions = append(actions, findAction(actionName))
+		}
 	}
 
-	bindings[key] = actions
+	if len(actions) > 0 {
+		// Can't have a binding be both mouse and normal
+		delete(mouseBindings, key)
+		bindings[key] = actions
+	} else if len(mouseActions) > 0 {
+		// Can't have a binding be both mouse and normal
+		delete(bindings, key)
+		mouseBindings[key] = mouseActions
+	}
 }
 
 // DefaultBindings returns a map containing micro's default keybindings
@@ -388,7 +451,9 @@ func DefaultBindings() map[string]string {
 		"CtrlLeft":       "StartOfLine",
 		"CtrlRight":      "EndOfLine",
 		"CtrlShiftLeft":  "SelectToStartOfLine",
+		"ShiftHome":      "SelectToStartOfLine",
 		"CtrlShiftRight": "SelectToEndOfLine",
+		"ShiftEnd":       "SelectToEndOfLine",
 		"CtrlUp":         "CursorStart",
 		"CtrlDown":       "CursorEnd",
 		"CtrlShiftUp":    "SelectToStart",
@@ -414,14 +479,16 @@ func DefaultBindings() map[string]string {
 		"CtrlV":          "Paste",
 		"CtrlA":          "SelectAll",
 		"CtrlT":          "AddTab",
-		"CtrlRightSq":    "PreviousTab",
-		"CtrlBackslash":  "NextTab",
+		"Alt,":           "PreviousTab",
+		"Alt.":           "NextTab",
 		"Home":           "StartOfLine",
 		"End":            "EndOfLine",
 		"CtrlHome":       "CursorStart",
 		"CtrlEnd":        "CursorEnd",
 		"PageUp":         "CursorPageUp",
 		"PageDown":       "CursorPageDown",
+		"CtrlPageUp":     "PreviousTab",
+		"CtrlPageDown":   "NextTab",
 		"CtrlG":          "ToggleHelp",
 		"CtrlR":          "ToggleRuler",
 		"CtrlL":          "JumpLine",
@@ -438,15 +505,28 @@ func DefaultBindings() map[string]string {
 		"Alt-b": "WordLeft",
 		"Alt-a": "StartOfLine",
 		"Alt-e": "EndOfLine",
-		"Alt-p": "CursorUp",
-		"Alt-n": "CursorDown",
+		// "Alt-p": "CursorUp",
+		// "Alt-n": "CursorDown",
 
 		// Integration with file managers
 		"F1":  "ToggleHelp",
 		"F2":  "Save",
+		"F3":  "Find",
 		"F4":  "Quit",
 		"F7":  "Find",
 		"F10": "Quit",
 		"Esc": "Escape",
+
+		// Mouse bindings
+		"MouseWheelUp":   "ScrollUp",
+		"MouseWheelDown": "ScrollDown",
+		"MouseLeft":      "MousePress",
+		"MouseMiddle":    "PastePrimary",
+		"Ctrl-MouseLeft": "MouseMultiCursor",
+
+		"Alt-n": "SpawnMultiCursor",
+		"Alt-p": "RemoveMultiCursor",
+		"Alt-c": "RemoveAllMultiCursors",
+		"Alt-x": "SkipMultiCursor",
 	}
 }

cmd/micro/buffer.go

@@ -16,6 +16,14 @@ import (
 	"unicode/utf8"
 
 	"github.com/mitchellh/go-homedir"
+	"github.com/zyedidia/micro/cmd/micro/highlight"
+)
+
+var (
+	// 0 - no line type detected
+	// 1 - lf detected
+	// 2 - crlf detected
+	fileformat = 0
 )
 
 // Buffer stores the text for files that are loaded into the text editor
@@ -27,7 +35,9 @@ type Buffer struct {
 	// This stores all the text in the buffer as an array of lines
 	*LineArray
 
-	Cursor Cursor
+	Cursor    Cursor
+	cursors   []*Cursor // for multiple cursors
+	curCursor int       // the current cursor
 
 	// Path to the file on disk
 	Path string
@@ -44,8 +54,8 @@ type Buffer struct {
 
 	NumLines int
 
-	// Syntax highlighting rules
-	rules []SyntaxRule
+	syntaxDef   *highlight.Def
+	highlighter *highlight.Highlighter
 
 	// Buffer local settings
 	Settings map[string]interface{}
@@ -60,11 +70,11 @@ type SerializedBuffer struct {
 }
 
 func NewBufferFromString(text, path string) *Buffer {
-	return NewBuffer(strings.NewReader(text), path)
+	return NewBuffer(strings.NewReader(text), int64(len(text)), path)
 }
 
 // NewBuffer creates a new buffer from a given reader with a given path
-func NewBuffer(reader io.Reader, path string) *Buffer {
+func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 	if path != "" {
 		for _, tab := range tabs {
 			for _, view := range tab.views {
@@ -76,7 +86,7 @@ func NewBuffer(reader io.Reader, path string) *Buffer {
 	}
 
 	b := new(Buffer)
-	b.LineArray = NewLineArray(reader)
+	b.LineArray = NewLineArray(size, reader)
 
 	b.Settings = DefaultLocalSettings()
 	for k, v := range globalSettings {
@@ -85,6 +95,12 @@ func NewBuffer(reader io.Reader, path string) *Buffer {
 		}
 	}
 
+	if fileformat == 1 {
+		b.Settings["fileformat"] = "unix"
+	} else if fileformat == 2 {
+		b.Settings["fileformat"] = "dos"
+	}
+
 	absPath, _ := filepath.Abs(path)
 
 	b.Path = path
@@ -96,7 +112,6 @@ func NewBuffer(reader io.Reader, path string) *Buffer {
 	b.EventHandler = NewEventHandler(b)
 
 	b.Update()
-	b.FindFileType()
 	b.UpdateRules()
 
 	if _, err := os.Stat(configDir + "/buffers/"); os.IsNotExist(err) {
@@ -169,6 +184,12 @@ func NewBuffer(reader io.Reader, path string) *Buffer {
 		file.Close()
 	}
 
+	if b.Settings["mouse"].(bool) {
+		screen.EnableMouse()
+	}
+
+	b.cursors = []*Cursor{&b.Cursor}
+
 	return b
 }
 
@@ -185,12 +206,67 @@ func (b *Buffer) GetName() string {
 // UpdateRules updates the syntax rules and filetype for this buffer
 // This is called when the colorscheme changes
 func (b *Buffer) UpdateRules() {
-	b.rules = GetRules(b)
-}
+	rehighlight := false
+	var files []*highlight.File
+	for _, f := range ListRuntimeFiles(RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+		} else {
+			file, err := highlight.ParseFile(data)
+			if err != nil {
+				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+			ftdetect, err := highlight.ParseFtDetect(file)
+			if err != nil {
+				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
 
-// FindFileType identifies this buffer's filetype based on the extension or header
-func (b *Buffer) FindFileType() {
-	b.Settings["filetype"] = FindFileType(b)
+			ft := b.Settings["filetype"].(string)
+			if (ft == "Unknown" || ft == "") && !rehighlight {
+				if highlight.MatchFiletype(ftdetect, b.Path, b.lines[0].data) {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.syntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			} else {
+				if file.FileType == ft && !rehighlight {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.syntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			}
+			files = append(files, file)
+		}
+	}
+
+	if b.syntaxDef != nil {
+		highlight.ResolveIncludes(b.syntaxDef, files)
+	}
+
+	if b.highlighter == nil || rehighlight {
+		if b.syntaxDef != nil {
+			b.Settings["filetype"] = b.syntaxDef.FileType
+			b.highlighter = highlight.NewHighlighter(b.syntaxDef)
+			if b.Settings["syntax"].(bool) {
+				b.highlighter.HighlightStates(b)
+			}
+		}
+	}
 }
 
 // FileType returns the buffer's filetype
@@ -249,6 +325,30 @@ func (b *Buffer) Update() {
 	b.NumLines = len(b.lines)
 }
 
+func (b *Buffer) MergeCursors() {
+	var cursors []*Cursor
+	for i := 0; i < len(b.cursors); i++ {
+		c1 := b.cursors[i]
+		if c1 != nil {
+			for j := 0; j < len(b.cursors); j++ {
+				c2 := b.cursors[j]
+				if c2 != nil && i != j && c1.Loc == c2.Loc {
+					b.cursors[j] = nil
+				}
+			}
+			cursors = append(cursors, c1)
+		}
+	}
+
+	b.cursors = cursors
+}
+
+func (b *Buffer) UpdateCursors() {
+	for i, c := range b.cursors {
+		c.Num = i
+	}
+}
+
 // Save saves the buffer to its default path
 func (b *Buffer) Save() error {
 	return b.SaveAs(b.Path)
@@ -272,7 +372,7 @@ func (b *Buffer) Serialize() error {
 				b.ModTime,
 			})
 		}
-		file.Close()
+		err = file.Close()
 		return err
 	}
 	return nil
@@ -280,10 +380,8 @@ func (b *Buffer) Serialize() error {
 
 // SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
 func (b *Buffer) SaveAs(filename string) error {
-	b.FindFileType()
 	b.UpdateRules()
 	dir, _ := homedir.Dir()
-	b.Path = strings.Replace(filename, "~", dir, 1)
 	if b.Settings["rmtrailingws"].(bool) {
 		r, _ := regexp.Compile(`[ \t]+$`)
 		for lineNum, line := range b.Lines(0, b.NumLines) {
@@ -302,10 +400,11 @@ func (b *Buffer) SaveAs(filename string) error {
 			b.Insert(end, "\n")
 		}
 	}
-	str := b.String()
+	str := b.SaveString(b.Settings["fileformat"] == "dos")
 	data := []byte(str)
 	err := ioutil.WriteFile(filename, data, 0644)
 	if err == nil {
+		b.Path = strings.Replace(filename, "~", dir, 1)
 		b.IsModified = false
 		b.ModTime, _ = GetModTime(filename)
 		return b.Serialize()
@@ -317,25 +416,16 @@ func (b *Buffer) SaveAs(filename string) error {
 // SaveAsWithSudo is the same as SaveAs except it uses a neat trick
 // with tee to use sudo so the user doesn't have to reopen micro with sudo
 func (b *Buffer) SaveAsWithSudo(filename string) error {
-	b.FindFileType()
 	b.UpdateRules()
 	b.Path = filename
 
-	// The user may have already used sudo in which case we won't need the password
-	// It's a bit nicer for them if they don't have to enter the password every time
-	_, err := RunShellCommand("sudo -v")
-	needPassword := err != nil
-
-	// If we need the password, we have to close the screen and ask using the shell
-	if needPassword {
-		// Shut down the screen because we're going to interact directly with the shell
-		screen.Fini()
-		screen = nil
-	}
+	// Shut down the screen because we're going to interact directly with the shell
+	screen.Fini()
+	screen = nil
 
 	// Set up everything for the command
 	cmd := exec.Command("sudo", "tee", filename)
-	cmd.Stdin = bytes.NewBufferString(b.String())
+	cmd.Stdin = bytes.NewBufferString(b.SaveString(b.Settings["fileformat"] == "dos"))
 
 	// This is a trap for Ctrl-C so that it doesn't kill micro
 	// Instead we trap Ctrl-C to kill the program we're running
@@ -349,13 +439,10 @@ func (b *Buffer) SaveAsWithSudo(filename string) error {
 
 	// Start the command
 	cmd.Start()
-	err = cmd.Wait()
+	err := cmd.Wait()
 
-	// If we needed the password, we closed the screen, so we have to initialize it again
-	if needPassword {
-		// Start the screen back up
-		InitScreen()
-	}
+	// Start the screen back up
+	InitScreen()
 	if err == nil {
 		b.IsModified = false
 		b.ModTime, _ = GetModTime(filename)
@@ -388,7 +475,7 @@ func (b *Buffer) Start() Loc {
 
 // End returns the location of the last character in the buffer
 func (b *Buffer) End() Loc {
-	return Loc{utf8.RuneCount(b.lines[b.NumLines-1]), b.NumLines - 1}
+	return Loc{utf8.RuneCount(b.lines[b.NumLines-1].data), b.NumLines - 1}
 }
 
 // RuneAt returns the rune at a given location in the buffer
@@ -405,7 +492,11 @@ func (b *Buffer) Line(n int) string {
 	if n >= len(b.lines) {
 		return ""
 	}
-	return string(b.lines[n])
+	return string(b.lines[n].data)
+}
+
+func (b *Buffer) LinesNum() int {
+	return len(b.lines)
 }
 
 // Lines returns an array of strings containing the lines from start to end
@@ -413,7 +504,7 @@ func (b *Buffer) Lines(start, end int) []string {
 	lines := b.lines[start:end]
 	var slice []string
 	for _, line := range lines {
-		slice = append(slice, string(line))
+		slice = append(slice, string(line.data))
 	}
 	return slice
 }
@@ -432,7 +523,7 @@ func (b *Buffer) MoveLinesUp(start int, end int) {
 	if end == len(b.lines) {
 		b.Insert(
 			Loc{
-				utf8.RuneCount(b.lines[end-1]),
+				utf8.RuneCount(b.lines[end-1].data),
 				end - 1,
 			},
 			"\n"+b.Line(start-1),
@@ -467,3 +558,20 @@ func (b *Buffer) MoveLinesDown(start int, end int) {
 		Loc{0, end + 1},
 	)
 }
+
+// ClearMatches clears all of the syntax highlighting for this buffer
+func (b *Buffer) ClearMatches() {
+	for i := range b.lines {
+		b.SetMatch(i, nil)
+		b.SetState(i, nil)
+	}
+}
+
+func (b *Buffer) clearCursors() {
+	for i := 1; i < len(b.cursors); i++ {
+		b.cursors[i] = nil
+	}
+	b.cursors = b.cursors[:1]
+	b.UpdateCursors()
+	b.Cursor.ResetSelection()
+}

cmd/micro/cellview.go

@@ -0,0 +1,207 @@
+package main
+
+import (
+	"github.com/mattn/go-runewidth"
+	"github.com/zyedidia/tcell"
+)
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+func visualToCharPos(visualIndex int, lineN int, str string, buf *Buffer, tabsize int) (int, int, *tcell.Style) {
+	charPos := 0
+	var lineIdx int
+	var lastWidth int
+	var style *tcell.Style
+	var width int
+	var rw int
+	for i, c := range str {
+		// width := StringWidth(str[:i], tabsize)
+
+		if group, ok := buf.Match(lineN)[charPos]; ok {
+			s := GetColor(group.String())
+			style = &s
+		}
+
+		if width >= visualIndex {
+			return charPos, visualIndex - lastWidth, style
+		}
+
+		if i != 0 {
+			charPos++
+			lineIdx += rw
+		}
+		lastWidth = width
+		rw = 0
+		if c == '\t' {
+			rw = tabsize - (lineIdx % tabsize)
+			width += rw
+		} else {
+			rw = runewidth.RuneWidth(c)
+			width += rw
+		}
+	}
+
+	return -1, -1, style
+}
+
+type Char struct {
+	visualLoc Loc
+	realLoc   Loc
+	char      rune
+	// The actual character that is drawn
+	// This is only different from char if it's for example hidden character
+	drawChar rune
+	style    tcell.Style
+	width    int
+}
+
+type CellView struct {
+	lines [][]*Char
+}
+
+func (c *CellView) Draw(buf *Buffer, top, height, left, width int) {
+	tabsize := int(buf.Settings["tabsize"].(float64))
+	softwrap := buf.Settings["softwrap"].(bool)
+	indentrunes := []rune(buf.Settings["indentchar"].(string))
+	// if empty indentchar settings, use space
+	if indentrunes == nil || len(indentrunes) == 0 {
+		indentrunes = []rune(" ")
+	}
+	indentchar := indentrunes[0]
+
+	start := buf.Cursor.Y
+	if buf.Settings["syntax"].(bool) && buf.syntaxDef != nil {
+		if start > 0 && buf.lines[start-1].rehighlight {
+			buf.highlighter.ReHighlightLine(buf, start-1)
+			buf.lines[start-1].rehighlight = false
+		}
+
+		buf.highlighter.ReHighlightStates(buf, start)
+
+		buf.highlighter.HighlightMatches(buf, top, top+height)
+	}
+
+	c.lines = make([][]*Char, 0)
+
+	viewLine := 0
+	lineN := top
+
+	curStyle := defStyle
+	for viewLine < height {
+		if lineN >= len(buf.lines) {
+			break
+		}
+
+		lineStr := buf.Line(lineN)
+		line := []rune(lineStr)
+
+		colN, startOffset, startStyle := visualToCharPos(left, lineN, lineStr, buf, tabsize)
+		if colN < 0 {
+			colN = len(line)
+		}
+		viewCol := -startOffset
+		if startStyle != nil {
+			curStyle = *startStyle
+		}
+
+		// We'll either draw the length of the line, or the width of the screen
+		// whichever is smaller
+		lineLength := min(StringWidth(lineStr, tabsize), width)
+		c.lines = append(c.lines, make([]*Char, lineLength))
+
+		wrap := false
+		// We only need to wrap if the length of the line is greater than the width of the terminal screen
+		if softwrap && StringWidth(lineStr, tabsize) > width {
+			wrap = true
+			// We're going to draw the entire line now
+			lineLength = StringWidth(lineStr, tabsize)
+		}
+
+		for viewCol < lineLength {
+			if colN >= len(line) {
+				break
+			}
+			if group, ok := buf.Match(lineN)[colN]; ok {
+				curStyle = GetColor(group.String())
+			}
+
+			char := line[colN]
+
+			if viewCol >= 0 {
+				c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, char, curStyle, 1}
+			}
+			if char == '\t' {
+				charWidth := tabsize - (viewCol+left)%tabsize
+				if viewCol >= 0 {
+					c.lines[viewLine][viewCol].drawChar = indentchar
+					c.lines[viewLine][viewCol].width = charWidth
+
+					indentStyle := curStyle
+					if group, ok := colorscheme["indent-char"]; ok {
+						indentStyle = group
+					}
+
+					c.lines[viewLine][viewCol].style = indentStyle
+				}
+
+				for i := 1; i < charWidth; i++ {
+					viewCol++
+					if viewCol >= 0 && viewCol < lineLength {
+						c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, ' ', curStyle, 1}
+					}
+				}
+				viewCol++
+			} else if runewidth.RuneWidth(char) > 1 {
+				charWidth := runewidth.RuneWidth(char)
+				if viewCol >= 0 {
+					c.lines[viewLine][viewCol].width = charWidth
+				}
+				for i := 1; i < charWidth; i++ {
+					viewCol++
+					if viewCol >= 0 && viewCol < lineLength {
+						c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, ' ', curStyle, 1}
+					}
+				}
+				viewCol++
+			} else {
+				viewCol++
+			}
+			colN++
+
+			if wrap && viewCol >= width {
+				viewLine++
+
+				// If we go too far soft wrapping we have to cut off
+				if viewLine >= height {
+					break
+				}
+
+				nextLine := line[colN:]
+				lineLength := min(StringWidth(string(nextLine), tabsize), width)
+				c.lines = append(c.lines, make([]*Char, lineLength))
+
+				viewCol = 0
+			}
+
+		}
+		if group, ok := buf.Match(lineN)[len(line)]; ok {
+			curStyle = GetColor(group.String())
+		}
+
+		// newline
+		viewLine++
+		lineN++
+	}
+
+	for i := top; i < top+height; i++ {
+		if i >= buf.NumLines {
+			break
+		}
+		buf.SetMatch(i, nil)
+	}
+}

cmd/micro/colorscheme.go

@@ -15,6 +15,33 @@ type Colorscheme map[string]tcell.Style
 // The current colorscheme
 var colorscheme Colorscheme
 
+// This takes in a syntax group and returns the colorscheme's style for that group
+func GetColor(color string) tcell.Style {
+	st := defStyle
+	if color == "" {
+		return st
+	}
+	groups := strings.Split(color, ".")
+	if len(groups) > 1 {
+		curGroup := ""
+		for i, g := range groups {
+			if i != 0 {
+				curGroup += "."
+			}
+			curGroup += g
+			if style, ok := colorscheme[curGroup]; ok {
+				st = style
+			}
+		}
+	} else if style, ok := colorscheme[color]; ok {
+		st = style
+	} else {
+		st = StringToStyle(color)
+	}
+
+	return st
+}
+
 // ColorschemeExists checks if a given colorscheme exists
 func ColorschemeExists(colorschemeName string) bool {
 	return FindRuntimeFile(RTColorscheme, colorschemeName) != nil
@@ -23,10 +50,11 @@ func ColorschemeExists(colorschemeName string) bool {
 // InitColorscheme picks and initializes the colorscheme when micro starts
 func InitColorscheme() {
 	colorscheme = make(Colorscheme)
+	defStyle = tcell.StyleDefault.
+		Foreground(tcell.ColorDefault).
+		Background(tcell.ColorDefault)
 	if screen != nil {
-		screen.SetStyle(tcell.StyleDefault.
-			Foreground(tcell.ColorDefault).
-			Background(tcell.ColorDefault))
+		screen.SetStyle(defStyle)
 	}
 
 	LoadDefaultColorscheme()
@@ -47,20 +75,6 @@ func LoadColorscheme(colorschemeName string) {
 			TermMessage("Error loading colorscheme:", err)
 		} else {
 			colorscheme = ParseColorscheme(string(data))
-
-			// Default style
-			defStyle = tcell.StyleDefault.
-				Foreground(tcell.ColorDefault).
-				Background(tcell.ColorDefault)
-
-			// There may be another default style defined in the colorscheme
-			// In that case we should use that one
-			if style, ok := colorscheme["default"]; ok {
-				defStyle = style
-			}
-			if screen != nil {
-				screen.SetStyle(defStyle)
-			}
 		}
 	}
 }
@@ -94,6 +108,9 @@ func ParseColorscheme(text string) Colorscheme {
 			if link == "default" {
 				defStyle = style
 			}
+			if screen != nil {
+				screen.SetStyle(defStyle)
+			}
 		} else {
 			fmt.Println("Color-link statement is not valid:", line)
 		}
@@ -107,7 +124,13 @@ func ParseColorscheme(text string) Colorscheme {
 // The 'extra' can be bold, reverse, or underline
 func StringToStyle(str string) tcell.Style {
 	var fg, bg string
-	split := strings.Split(str, ",")
+	spaceSplit := strings.Split(str, " ")
+	var split []string
+	if len(spaceSplit) > 1 {
+		split = strings.Split(spaceSplit[1], ",")
+	} else {
+		split = strings.Split(str, ",")
+	}
 	if len(split) > 1 {
 		fg, bg = split[0], split[1]
 	} else {

cmd/micro/command.go

@@ -9,16 +9,21 @@ import (
 	"os/signal"
 	"path/filepath"
 	"regexp"
+	"runtime"
+	"strconv"
 	"strings"
 
+	humanize "github.com/dustin/go-humanize"
 	"github.com/mitchellh/go-homedir"
 )
 
+// A Command contains a action (a function to call) as well as information about how to autocomplete the command
 type Command struct {
 	action      func([]string)
 	completions []Completion
 }
 
+// A StrCommand is similar to a command but keeps the name of the action
 type StrCommand struct {
 	action      string
 	completions []Completion
@@ -30,25 +35,28 @@ var commandActions map[string]func([]string)
 
 func init() {
 	commandActions = map[string]func([]string){
-		"Set":       Set,
-		"SetLocal":  SetLocal,
-		"Show":      Show,
-		"Run":       Run,
-		"Bind":      Bind,
-		"Quit":      Quit,
-		"Save":      Save,
-		"Replace":   Replace,
-		"VSplit":    VSplit,
-		"HSplit":    HSplit,
-		"Tab":       NewTab,
-		"Help":      Help,
-		"Eval":      Eval,
-		"ToggleLog": ToggleLog,
-		"Plugin":    PluginCmd,
-		"Reload":    Reload,
-		"Cd":        Cd,
-		"Pwd":       Pwd,
-		"Open":      Open,
+		"Set":        Set,
+		"SetLocal":   SetLocal,
+		"Show":       Show,
+		"Run":        Run,
+		"Bind":       Bind,
+		"Quit":       Quit,
+		"Save":       Save,
+		"Replace":    Replace,
+		"ReplaceAll": ReplaceAll,
+		"VSplit":     VSplit,
+		"HSplit":     HSplit,
+		"Tab":        NewTab,
+		"Help":       Help,
+		"Eval":       Eval,
+		"ToggleLog":  ToggleLog,
+		"Plugin":     PluginCmd,
+		"Reload":     Reload,
+		"Cd":         Cd,
+		"Pwd":        Pwd,
+		"Open":       Open,
+		"TabSwitch":  TabSwitch,
+		"MemUsage":   MemUsage,
 	}
 }
 
@@ -82,25 +90,28 @@ func MakeCommand(name, function string, completions ...Completion) {
 // DefaultCommands returns a map containing micro's default commands
 func DefaultCommands() map[string]StrCommand {
 	return map[string]StrCommand{
-		"set":      {"Set", []Completion{OptionCompletion, NoCompletion}},
-		"setlocal": {"SetLocal", []Completion{OptionCompletion, NoCompletion}},
-		"show":     {"Show", []Completion{OptionCompletion, NoCompletion}},
-		"bind":     {"Bind", []Completion{NoCompletion}},
-		"run":      {"Run", []Completion{NoCompletion}},
-		"quit":     {"Quit", []Completion{NoCompletion}},
-		"save":     {"Save", []Completion{NoCompletion}},
-		"replace":  {"Replace", []Completion{NoCompletion}},
-		"vsplit":   {"VSplit", []Completion{FileCompletion, NoCompletion}},
-		"hsplit":   {"HSplit", []Completion{FileCompletion, NoCompletion}},
-		"tab":      {"Tab", []Completion{FileCompletion, NoCompletion}},
-		"help":     {"Help", []Completion{HelpCompletion, NoCompletion}},
-		"eval":     {"Eval", []Completion{NoCompletion}},
-		"log":      {"ToggleLog", []Completion{NoCompletion}},
-		"plugin":   {"Plugin", []Completion{PluginCmdCompletion, PluginNameCompletion}},
-		"reload":   {"Reload", []Completion{NoCompletion}},
-		"cd":       {"Cd", []Completion{FileCompletion}},
-		"pwd":      {"Pwd", []Completion{NoCompletion}},
-		"open":     {"Open", []Completion{FileCompletion}},
+		"set":        {"Set", []Completion{OptionCompletion, NoCompletion}},
+		"setlocal":   {"SetLocal", []Completion{OptionCompletion, NoCompletion}},
+		"show":       {"Show", []Completion{OptionCompletion, NoCompletion}},
+		"bind":       {"Bind", []Completion{NoCompletion}},
+		"run":        {"Run", []Completion{NoCompletion}},
+		"quit":       {"Quit", []Completion{NoCompletion}},
+		"save":       {"Save", []Completion{NoCompletion}},
+		"replace":    {"Replace", []Completion{NoCompletion}},
+		"replaceall": {"ReplaceAll", []Completion{NoCompletion}},
+		"vsplit":     {"VSplit", []Completion{FileCompletion, NoCompletion}},
+		"hsplit":     {"HSplit", []Completion{FileCompletion, NoCompletion}},
+		"tab":        {"Tab", []Completion{FileCompletion, NoCompletion}},
+		"help":       {"Help", []Completion{HelpCompletion, NoCompletion}},
+		"eval":       {"Eval", []Completion{NoCompletion}},
+		"log":        {"ToggleLog", []Completion{NoCompletion}},
+		"plugin":     {"Plugin", []Completion{PluginCmdCompletion, PluginNameCompletion}},
+		"reload":     {"Reload", []Completion{NoCompletion}},
+		"cd":         {"Cd", []Completion{FileCompletion}},
+		"pwd":        {"Pwd", []Completion{NoCompletion}},
+		"open":       {"Open", []Completion{FileCompletion}},
+		"tabswitch":  {"TabSwitch", []Completion{NoCompletion}},
+		"memusage":   {"MemUsage", []Completion{NoCompletion}},
 	}
 }
 
@@ -187,6 +198,36 @@ func PluginCmd(args []string) {
 	}
 }
 
+// TabSwitch switches to a given tab either by name or by number
+func TabSwitch(args []string) {
+	if len(args) > 0 {
+		num, err := strconv.Atoi(args[0])
+		if err != nil {
+			// Check for tab with this name
+
+			found := false
+			for _, t := range tabs {
+				v := t.views[t.CurView]
+				if v.Buf.GetName() == args[0] {
+					curTab = v.TabNum
+					found = true
+				}
+			}
+			if !found {
+				messenger.Error("Could not find tab: ", err)
+			}
+		} else {
+			num--
+			if num >= 0 && num < len(tabs) {
+				curTab = num
+			} else {
+				messenger.Error("Invalid tab index")
+			}
+		}
+	}
+}
+
+// Cd changes the current working directory
 func Cd(args []string) {
 	if len(args) > 0 {
 		home, _ := homedir.Dir()
@@ -204,6 +245,21 @@ func Cd(args []string) {
 	}
 }
 
+// MemUsage prints micro's memory usage
+// Alloc shows how many bytes are currently in use
+// Sys shows how many bytes have been requested from the operating system
+// NumGC shows how many times the GC has been run
+// Note that Go commonly reserves more memory from the OS than is currently in-use/required
+// Additionally, even if Go returns memory to the OS, the OS does not always claim it because
+// there may be plenty of memory to spare
+func MemUsage(args []string) {
+	var mem runtime.MemStats
+	runtime.ReadMemStats(&mem)
+
+	messenger.Message(fmt.Sprintf("Alloc: %v, Sys: %v, NumGC: %v", humanize.Bytes(mem.Alloc), humanize.Bytes(mem.Sys), mem.NumGC))
+}
+
+// Pwd prints the current working directory
 func Pwd(args []string) {
 	wd, err := os.Getwd()
 	if err != nil {
@@ -213,6 +269,7 @@ func Pwd(args []string) {
 	}
 }
 
+// Open opens a new buffer with a given filename
 func Open(args []string) {
 	if len(args) > 0 {
 		filename := args[0]
@@ -225,6 +282,7 @@ func Open(args []string) {
 	}
 }
 
+// ToggleLog toggles the log view
 func ToggleLog(args []string) {
 	buffer := messenger.getBuffer()
 	if CurView().Type != vtLog {
@@ -240,6 +298,7 @@ func ToggleLog(args []string) {
 	}
 }
 
+// Reload reloads all files (syntax files, colorschemes...)
 func Reload(args []string) {
 	LoadAll()
 }
@@ -263,20 +322,27 @@ func Help(args []string) {
 // If no file is given, it opens an empty buffer in a new split
 func VSplit(args []string) {
 	if len(args) == 0 {
-		CurView().VSplit(NewBuffer(strings.NewReader(""), ""))
+		CurView().VSplit(NewBufferFromString("", ""))
 	} else {
 		filename := args[0]
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
 		file, err := os.Open(filename)
+		fileInfo, _ := os.Stat(filename)
+
+		if err == nil && fileInfo.IsDir() {
+			messenger.Error(filename, " is a directory")
+			return
+		}
+
 		defer file.Close()
 
 		var buf *Buffer
 		if err != nil {
 			// File does not exist -- create an empty buffer with that name
-			buf = NewBuffer(strings.NewReader(""), filename)
+			buf = NewBufferFromString("", filename)
 		} else {
-			buf = NewBuffer(file, filename)
+			buf = NewBuffer(file, FSize(file), filename)
 		}
 		CurView().VSplit(buf)
 	}
@@ -286,20 +352,27 @@ func VSplit(args []string) {
 // If no file is given, it opens an empty buffer in a new split
 func HSplit(args []string) {
 	if len(args) == 0 {
-		CurView().HSplit(NewBuffer(strings.NewReader(""), ""))
+		CurView().HSplit(NewBufferFromString("", ""))
 	} else {
 		filename := args[0]
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
 		file, err := os.Open(filename)
+		fileInfo, _ := os.Stat(filename)
+
+		if err == nil && fileInfo.IsDir() {
+			messenger.Error(filename, " is a directory")
+			return
+		}
+
 		defer file.Close()
 
 		var buf *Buffer
 		if err != nil {
 			// File does not exist -- create an empty buffer with that name
-			buf = NewBuffer(strings.NewReader(""), filename)
+			buf = NewBufferFromString("", filename)
 		} else {
-			buf = NewBuffer(file, filename)
+			buf = NewBuffer(file, FSize(file), filename)
 		}
 		CurView().HSplit(buf)
 	}
@@ -325,10 +398,24 @@ func NewTab(args []string) {
 		filename := args[0]
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
-		file, _ := os.Open(filename)
+		file, err := os.Open(filename)
+		fileInfo, _ := os.Stat(filename)
+
+		if err == nil && fileInfo.IsDir() {
+			messenger.Error(filename, " is a directory")
+			return
+		}
+
 		defer file.Close()
 
-		tab := NewTabFromView(NewView(NewBuffer(file, filename)))
+		var buf *Buffer
+		if err != nil {
+			buf = NewBufferFromString("", filename)
+		} else {
+			buf = NewBuffer(file, FSize(file), filename)
+		}
+
+		tab := NewTabFromView(NewView(buf))
 		tab.SetNum(len(tabs))
 		tabs = append(tabs, tab)
 		curTab = len(tabs) - 1
@@ -349,8 +436,8 @@ func Set(args []string) {
 		return
 	}
 
-	option := strings.TrimSpace(args[0])
-	value := strings.TrimSpace(args[1])
+	option := args[0]
+	value := args[1]
 
 	SetOptionAndSettings(option, value)
 }
@@ -362,8 +449,8 @@ func SetLocal(args []string) {
 		return
 	}
 
-	option := strings.TrimSpace(args[0])
-	value := strings.TrimSpace(args[1])
+	option := args[0]
+	value := args[1]
 
 	err := SetLocalOption(option, value, CurView())
 	if err != nil {
@@ -421,16 +508,21 @@ func Save(args []string) {
 
 // Replace runs search and replace
 func Replace(args []string) {
-	if len(args) < 2 {
+	if len(args) < 2 || len(args) > 3 {
 		// We need to find both a search and replace expression
 		messenger.Error("Invalid replace statement: " + strings.Join(args, " "))
 		return
 	}
 
-	var flags string
+	allAtOnce := false
 	if len(args) == 3 {
-		// The user included some flags
-		flags = args[2]
+		// user added -a flag
+		if args[2] == "-a" {
+			allAtOnce = true
+		} else {
+			messenger.Error("Invalid replace flag: " + args[2])
+			return
+		}
 	}
 
 	search := string(args[0])
@@ -446,7 +538,32 @@ func Replace(args []string) {
 	view := CurView()
 
 	found := 0
-	if strings.Contains(flags, "c") {
+	replaceAll := func() {
+		var deltas []Delta
+		deltaXOffset := Count(replace) - Count(search)
+		for i := 0; i < view.Buf.LinesNum(); i++ {
+			matches := regex.FindAllIndex(view.Buf.lines[i].data, -1)
+			str := string(view.Buf.lines[i].data)
+
+			if matches != nil {
+				xOffset := 0
+				for _, m := range matches {
+					from := Loc{runePos(m[0], str) + xOffset, i}
+					to := Loc{runePos(m[1], str) + xOffset, i}
+
+					xOffset += deltaXOffset
+
+					deltas = append(deltas, Delta{replace, from, to})
+					found++
+				}
+			}
+		}
+		view.Buf.MultipleReplace(deltas)
+	}
+
+	if allAtOnce {
+		replaceAll()
+	} else {
 		for {
 			// The 'check' flag was used
 			Search(search, view, true)
@@ -454,11 +571,8 @@ func Replace(args []string) {
 				break
 			}
 			view.Relocate()
-			if view.Buf.Settings["syntax"].(bool) {
-				view.matches = Match(view)
-			}
 			RedrawAll()
-			choice, canceled := messenger.YesNoPrompt("Perform replacement? (y,n)")
+			choice, canceled := messenger.LetterPrompt("Perform replacement? (y,n,a)", 'y', 'n', 'a')
 			if canceled {
 				if view.Cursor.HasSelection() {
 					view.Cursor.Loc = view.Cursor.CurSelection[0]
@@ -466,43 +580,25 @@ func Replace(args []string) {
 				}
 				messenger.Reset()
 				break
-			}
-			if choice {
+			} else if choice == 'a' {
+				if view.Cursor.HasSelection() {
+					view.Cursor.Loc = view.Cursor.CurSelection[0]
+					view.Cursor.ResetSelection()
+				}
+				messenger.Reset()
+				replaceAll()
+				break
+			} else if choice == 'y' {
 				view.Cursor.DeleteSelection()
 				view.Buf.Insert(view.Cursor.Loc, replace)
 				view.Cursor.ResetSelection()
 				messenger.Reset()
 				found++
-			} else {
-				if view.Cursor.HasSelection() {
-					searchStart = ToCharPos(view.Cursor.CurSelection[1], view.Buf)
-				} else {
-					searchStart = ToCharPos(view.Cursor.Loc, view.Buf)
-				}
-				continue
 			}
-		}
-	} else {
-		bufStr := view.Buf.String()
-		matches := regex.FindAllStringIndex(bufStr, -1)
-		if matches != nil && len(matches) > 0 {
-			prevMatchCount := runePos(matches[0][0], bufStr)
-			searchCount := runePos(matches[0][1], bufStr) - prevMatchCount
-			from := FromCharPos(matches[0][0], view.Buf)
-			to := from.Move(searchCount, view.Buf)
-			adjust := Count(replace) - searchCount
-			view.Buf.Replace(from, to, replace)
-			if len(matches) > 1 {
-				for _, match := range matches[1:] {
-					found++
-					matchCount := runePos(match[0], bufStr)
-					searchCount = runePos(match[1], bufStr) - matchCount
-					from = from.Move(matchCount-prevMatchCount+adjust, view.Buf)
-					to = from.Move(searchCount, view.Buf)
-					view.Buf.Replace(from, to, replace)
-					prevMatchCount = matchCount
-					adjust = Count(replace) - searchCount
-				}
+			if view.Cursor.HasSelection() {
+				searchStart = view.Cursor.CurSelection[1]
+			} else {
+				searchStart = view.Cursor.Loc
 			}
 		}
 	}
@@ -517,6 +613,12 @@ func Replace(args []string) {
 	}
 }
 
+// ReplaceAll replaces search term all at once
+func ReplaceAll(args []string) {
+	// aliased to Replace command
+	Replace(append(args, "-a"))
+}
+
 // RunShellCommand executes a shell command and returns the output/error
 func RunShellCommand(input string) (string, error) {
 	inputCmd := SplitCommandArgs(input)[0]

cmd/micro/cursor.go

@@ -1,6 +1,8 @@
 package main
 
-import "github.com/zyedidia/clipboard"
+import (
+	"github.com/zyedidia/clipboard"
+)
 
 // The Cursor struct stores the location of the cursor in the view
 // The complicated part about the cursor is storing its location.
@@ -21,6 +23,9 @@ type Cursor struct {
 	// This is used for line and word selection where it is necessary
 	// to know what the original selection was
 	OrigSelection [2]Loc
+
+	// Which cursor index is this (for multiple cursors)
+	Num int
 }
 
 // Goto puts the cursor at the given cursor's location and gives the current cursor its selection too
@@ -245,19 +250,19 @@ func (c *Cursor) UpN(amount int) {
 	proposedY := c.Y - amount
 	if proposedY < 0 {
 		proposedY = 0
+		c.LastVisualX = 0
 	} else if proposedY >= c.buf.NumLines {
 		proposedY = c.buf.NumLines - 1
 	}
-	if proposedY == c.Y {
-		return
-	}
 
-	c.Y = proposedY
 	runes := []rune(c.buf.Line(c.Y))
-	c.X = c.GetCharPosInLine(c.Y, c.LastVisualX)
+	c.X = c.GetCharPosInLine(proposedY, c.LastVisualX)
+
 	if c.X > len(runes) {
 		c.X = len(runes)
 	}
+
+	c.Y = proposedY
 }
 
 // DownN moves the cursor down N lines (if possible)
@@ -334,9 +339,22 @@ func (c *Cursor) GetCharPosInLine(lineNum, visualPos int) int {
 func (c *Cursor) GetVisualX() int {
 	runes := []rune(c.buf.Line(c.Y))
 	tabSize := int(c.buf.Settings["tabsize"].(float64))
+	if c.X > len(runes) {
+		c.X = len(runes) - 1
+	}
+
+	if c.X < 0 {
+		c.X = 0
+	}
+
 	return StringWidth(string(runes[:c.X]), tabSize)
 }
 
+// StoreVisualX stores the current visual x value in the cursor
+func (c *Cursor) StoreVisualX() {
+	c.LastVisualX = c.GetVisualX()
+}
+
 // Relocate makes sure that the cursor is inside the bounds of the buffer
 // If it isn't, it moves it to be within the buffer's lines
 func (c *Cursor) Relocate() {

cmd/micro/eventhandler.go

@@ -11,10 +11,12 @@ import (
 const (
 	// Opposite and undoing events must have opposite values
 
-	// TextEventInsert repreasents an insertion event
+	// TextEventInsert represents an insertion event
 	TextEventInsert = 1
 	// TextEventRemove represents a deletion event
 	TextEventRemove = -1
+	// TextEventReplace represents a replace event
+	TextEventReplace = 0
 )
 
 // TextEvent holds data for a manipulation on some text that can be undone
@@ -22,18 +24,36 @@ type TextEvent struct {
 	C Cursor
 
 	EventType int
-	Text      string
-	Start     Loc
-	End       Loc
+	Deltas    []Delta
 	Time      time.Time
 }
 
+type Delta struct {
+	Text  string
+	Start Loc
+	End   Loc
+}
+
 // ExecuteTextEvent runs a text event
 func ExecuteTextEvent(t *TextEvent, buf *Buffer) {
 	if t.EventType == TextEventInsert {
-		buf.insert(t.Start, []byte(t.Text))
+		for _, d := range t.Deltas {
+			buf.insert(d.Start, []byte(d.Text))
+		}
 	} else if t.EventType == TextEventRemove {
-		t.Text = buf.remove(t.Start, t.End)
+		for i, d := range t.Deltas {
+			t.Deltas[i].Text = buf.remove(d.Start, d.End)
+		}
+	} else if t.EventType == TextEventReplace {
+		for i, d := range t.Deltas {
+			t.Deltas[i].Text = buf.remove(d.Start, d.End)
+			buf.insert(d.Start, []byte(d.Text))
+			t.Deltas[i].Start = d.Start
+			t.Deltas[i].End = Loc{d.Start.X + Count(d.Text), d.Start.Y}
+		}
+		for i, j := 0, len(t.Deltas)-1; i < j; i, j = i+1, j-1 {
+			t.Deltas[i], t.Deltas[j] = t.Deltas[j], t.Deltas[i]
+		}
 	}
 }
 
@@ -82,23 +102,67 @@ func (eh *EventHandler) ApplyDiff(new string) {
 // Insert creates an insert text event and executes it
 func (eh *EventHandler) Insert(start Loc, text string) {
 	e := &TextEvent{
-		C:         eh.buf.Cursor,
+		C:         *eh.buf.cursors[eh.buf.curCursor],
 		EventType: TextEventInsert,
-		Text:      text,
-		Start:     start,
+		Deltas:    []Delta{{text, start, Loc{0, 0}}},
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
-	e.End = start.Move(Count(text), eh.buf)
+	e.Deltas[0].End = start.Move(Count(text), eh.buf)
+	end := e.Deltas[0].End
+
+	for _, c := range eh.buf.cursors {
+		move := func(loc Loc) Loc {
+			if start.Y != end.Y && loc.GreaterThan(start) {
+				loc.Y += end.Y - start.Y
+			} else if loc.Y == start.Y && loc.GreaterEqual(start) {
+				loc = loc.Move(Count(text), eh.buf)
+			}
+			return loc
+		}
+		c.Loc = move(c.Loc)
+		c.CurSelection[0] = move(c.CurSelection[0])
+		c.CurSelection[1] = move(c.CurSelection[1])
+		c.OrigSelection[0] = move(c.OrigSelection[0])
+		c.OrigSelection[1] = move(c.OrigSelection[1])
+		c.LastVisualX = c.GetVisualX()
+	}
 }
 
 // Remove creates a remove text event and executes it
 func (eh *EventHandler) Remove(start, end Loc) {
 	e := &TextEvent{
-		C:         eh.buf.Cursor,
+		C:         *eh.buf.cursors[eh.buf.curCursor],
 		EventType: TextEventRemove,
-		Start:     start,
-		End:       end,
+		Deltas:    []Delta{{"", start, end}},
+		Time:      time.Now(),
+	}
+	eh.Execute(e)
+
+	for _, c := range eh.buf.cursors {
+		move := func(loc Loc) Loc {
+			if start.Y != end.Y && loc.GreaterThan(end) {
+				loc.Y -= end.Y - start.Y
+			} else if loc.Y == end.Y && loc.GreaterEqual(end) {
+				loc = loc.Move(-Diff(start, end, eh.buf), eh.buf)
+			}
+			return loc
+		}
+		c.Loc = move(c.Loc)
+		c.CurSelection[0] = move(c.CurSelection[0])
+		c.CurSelection[1] = move(c.CurSelection[1])
+		c.OrigSelection[0] = move(c.OrigSelection[0])
+		c.OrigSelection[1] = move(c.OrigSelection[1])
+		c.LastVisualX = c.GetVisualX()
+	}
+}
+
+// MultipleReplace creates an multiple insertions executes them
+func (eh *EventHandler) MultipleReplace(deltas []Delta) {
+	e := &TextEvent{
+		C:         *eh.buf.cursors[eh.buf.curCursor],
+		EventType: TextEventReplace,
+		Deltas:    deltas,
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
@@ -171,8 +235,12 @@ func (eh *EventHandler) UndoOneEvent() {
 
 	// Set the cursor in the right place
 	teCursor := t.C
-	t.C = eh.buf.Cursor
-	eh.buf.Cursor.Goto(teCursor)
+	if teCursor.Num >= 0 && teCursor.Num < len(eh.buf.cursors) {
+		t.C = *eh.buf.cursors[teCursor.Num]
+		eh.buf.cursors[teCursor.Num].Goto(teCursor)
+	} else {
+		teCursor.Num = -1
+	}
 
 	// Push it to the redo stack
 	eh.RedoStack.Push(t)
@@ -214,8 +282,12 @@ func (eh *EventHandler) RedoOneEvent() {
 	UndoTextEvent(t, eh.buf)
 
 	teCursor := t.C
-	t.C = eh.buf.Cursor
-	eh.buf.Cursor.Goto(teCursor)
+	if teCursor.Num >= 0 && teCursor.Num < len(eh.buf.cursors) {
+		t.C = *eh.buf.cursors[teCursor.Num]
+		eh.buf.cursors[teCursor.Num].Goto(teCursor)
+	} else {
+		teCursor.Num = -1
+	}
 
 	eh.UndoStack.Push(t)
 }

cmd/micro/highlight/ftdetect.go

@@ -0,0 +1,18 @@
+package highlight
+
+import "regexp"
+
+// DetectFiletype will use the list of syntax definitions provided and the filename and first line of the file
+// to determine the filetype of the file
+// It will return the corresponding syntax definition for the filetype
+func MatchFiletype(ftdetect [2]*regexp.Regexp, filename string, firstLine []byte) bool {
+	if ftdetect[0].MatchString(filename) {
+		return true
+	}
+
+	if ftdetect[1] != nil {
+		return ftdetect[1].Match(firstLine)
+	}
+
+	return false
+}

cmd/micro/highlight/highlighter.go

@@ -0,0 +1,374 @@
+package highlight
+
+import (
+	"regexp"
+	"strings"
+	"unicode/utf8"
+)
+
+// RunePos returns the rune index of a given byte index
+// This could cause problems if the byte index is between code points
+func runePos(p int, str string) int {
+	if p < 0 {
+		return 0
+	}
+	if p >= len(str) {
+		return utf8.RuneCountInString(str)
+	}
+	return utf8.RuneCountInString(str[:p])
+}
+
+func combineLineMatch(src, dst LineMatch) LineMatch {
+	for k, v := range src {
+		if g, ok := dst[k]; ok {
+			if g == 0 {
+				dst[k] = v
+			}
+		} else {
+			dst[k] = v
+		}
+	}
+	return dst
+}
+
+// A State represents the region at the end of a line
+type State *region
+
+// LineStates is an interface for a buffer-like object which can also store the states and matches for every line
+type LineStates interface {
+	Line(n int) string
+	LinesNum() int
+	State(lineN int) State
+	SetState(lineN int, s State)
+	SetMatch(lineN int, m LineMatch)
+}
+
+// A Highlighter contains the information needed to highlight a string
+type Highlighter struct {
+	lastRegion *region
+	Def        *Def
+}
+
+// NewHighlighter returns a new highlighter from the given syntax definition
+func NewHighlighter(def *Def) *Highlighter {
+	h := new(Highlighter)
+	h.Def = def
+	return h
+}
+
+// LineMatch represents the syntax highlighting matches for one line. Each index where the coloring is changed is marked with that
+// color's group (represented as one byte)
+type LineMatch map[int]Group
+
+func findIndex(regex *regexp.Regexp, skip *regexp.Regexp, str []rune, canMatchStart, canMatchEnd bool) []int {
+	regexStr := regex.String()
+	if strings.Contains(regexStr, "^") {
+		if !canMatchStart {
+			return nil
+		}
+	}
+	if strings.Contains(regexStr, "$") {
+		if !canMatchEnd {
+			return nil
+		}
+	}
+
+	var strbytes []byte
+	if skip != nil {
+		strbytes = skip.ReplaceAllFunc([]byte(string(str)), func(match []byte) []byte {
+			res := make([]byte, utf8.RuneCount(match))
+			return res
+		})
+	} else {
+		strbytes = []byte(string(str))
+	}
+
+	match := regex.FindIndex(strbytes)
+	if match == nil {
+		return nil
+	}
+	// return []int{match.Index, match.Index + match.Length}
+	return []int{runePos(match[0], string(str)), runePos(match[1], string(str))}
+}
+
+func findAllIndex(regex *regexp.Regexp, str []rune, canMatchStart, canMatchEnd bool) [][]int {
+	regexStr := regex.String()
+	if strings.Contains(regexStr, "^") {
+		if !canMatchStart {
+			return nil
+		}
+	}
+	if strings.Contains(regexStr, "$") {
+		if !canMatchEnd {
+			return nil
+		}
+	}
+	matches := regex.FindAllIndex([]byte(string(str)), -1)
+	for i, m := range matches {
+		matches[i][0] = runePos(m[0], string(str))
+		matches[i][1] = runePos(m[1], string(str))
+	}
+	return matches
+}
+
+func (h *Highlighter) highlightRegion(highlights LineMatch, start int, canMatchEnd bool, lineNum int, line []rune, curRegion *region, statesOnly bool) LineMatch {
+	// highlights := make(LineMatch)
+
+	if start == 0 {
+		if !statesOnly {
+			if _, ok := highlights[0]; !ok {
+				highlights[0] = curRegion.group
+			}
+		}
+	}
+
+	loc := findIndex(curRegion.end, curRegion.skip, line, start == 0, canMatchEnd)
+	if loc != nil {
+		if !statesOnly {
+			highlights[start+loc[0]] = curRegion.limitGroup
+		}
+		if curRegion.parent == nil {
+			if !statesOnly {
+				highlights[start+loc[1]] = 0
+				h.highlightRegion(highlights, start, false, lineNum, line[:loc[0]], curRegion, statesOnly)
+			}
+			h.highlightEmptyRegion(highlights, start+loc[1], canMatchEnd, lineNum, line[loc[1]:], statesOnly)
+			return highlights
+		}
+		if !statesOnly {
+			highlights[start+loc[1]] = curRegion.parent.group
+			h.highlightRegion(highlights, start, false, lineNum, line[:loc[0]], curRegion, statesOnly)
+		}
+		h.highlightRegion(highlights, start+loc[1], canMatchEnd, lineNum, line[loc[1]:], curRegion.parent, statesOnly)
+		return highlights
+	}
+
+	if len(line) == 0 || statesOnly {
+		if canMatchEnd {
+			h.lastRegion = curRegion
+		}
+
+		return highlights
+	}
+
+	firstLoc := []int{len(line), 0}
+
+	var firstRegion *region
+	for _, r := range curRegion.rules.regions {
+		loc := findIndex(r.start, nil, line, start == 0, canMatchEnd)
+		if loc != nil {
+			if loc[0] < firstLoc[0] {
+				firstLoc = loc
+				firstRegion = r
+			}
+		}
+	}
+	if firstLoc[0] != len(line) {
+		highlights[start+firstLoc[0]] = firstRegion.limitGroup
+		h.highlightRegion(highlights, start, false, lineNum, line[:firstLoc[0]], curRegion, statesOnly)
+		h.highlightRegion(highlights, start+firstLoc[1], canMatchEnd, lineNum, line[firstLoc[1]:], firstRegion, statesOnly)
+		return highlights
+	}
+
+	fullHighlights := make([]Group, len([]rune(string(line))))
+	for i := 0; i < len(fullHighlights); i++ {
+		fullHighlights[i] = curRegion.group
+	}
+
+	for _, p := range curRegion.rules.patterns {
+		matches := findAllIndex(p.regex, line, start == 0, canMatchEnd)
+		for _, m := range matches {
+			for i := m[0]; i < m[1]; i++ {
+				fullHighlights[i] = p.group
+			}
+		}
+	}
+	for i, h := range fullHighlights {
+		if i == 0 || h != fullHighlights[i-1] {
+			// if _, ok := highlights[start+i]; !ok {
+			highlights[start+i] = h
+			// }
+		}
+	}
+
+	if canMatchEnd {
+		h.lastRegion = curRegion
+	}
+
+	return highlights
+}
+
+func (h *Highlighter) highlightEmptyRegion(highlights LineMatch, start int, canMatchEnd bool, lineNum int, line []rune, statesOnly bool) LineMatch {
+	if len(line) == 0 {
+		if canMatchEnd {
+			h.lastRegion = nil
+		}
+		return highlights
+	}
+
+	firstLoc := []int{len(line), 0}
+	var firstRegion *region
+	for _, r := range h.Def.rules.regions {
+		loc := findIndex(r.start, nil, line, start == 0, canMatchEnd)
+		if loc != nil {
+			if loc[0] < firstLoc[0] {
+				firstLoc = loc
+				firstRegion = r
+			}
+		}
+	}
+	if firstLoc[0] != len(line) {
+		if !statesOnly {
+			highlights[start+firstLoc[0]] = firstRegion.limitGroup
+		}
+		h.highlightEmptyRegion(highlights, start, false, lineNum, line[:firstLoc[0]], statesOnly)
+		h.highlightRegion(highlights, start+firstLoc[1], canMatchEnd, lineNum, line[firstLoc[1]:], firstRegion, statesOnly)
+		return highlights
+	}
+
+	if statesOnly {
+		if canMatchEnd {
+			h.lastRegion = nil
+		}
+
+		return highlights
+	}
+
+	fullHighlights := make([]Group, len(line))
+	for _, p := range h.Def.rules.patterns {
+		matches := findAllIndex(p.regex, line, start == 0, canMatchEnd)
+		for _, m := range matches {
+			for i := m[0]; i < m[1]; i++ {
+				fullHighlights[i] = p.group
+			}
+		}
+	}
+	for i, h := range fullHighlights {
+		if i == 0 || h != fullHighlights[i-1] {
+			// if _, ok := highlights[start+i]; !ok {
+			highlights[start+i] = h
+			// }
+		}
+	}
+
+	if canMatchEnd {
+		h.lastRegion = nil
+	}
+
+	return highlights
+}
+
+// HighlightString syntax highlights a string
+// Use this function for simple syntax highlighting and use the other functions for
+// more advanced syntax highlighting. They are optimized for quick rehighlighting of the same
+// text with minor changes made
+func (h *Highlighter) HighlightString(input string) []LineMatch {
+	lines := strings.Split(input, "\n")
+	var lineMatches []LineMatch
+
+	for i := 0; i < len(lines); i++ {
+		line := []rune(lines[i])
+		highlights := make(LineMatch)
+
+		if i == 0 || h.lastRegion == nil {
+			lineMatches = append(lineMatches, h.highlightEmptyRegion(highlights, 0, true, i, line, false))
+		} else {
+			lineMatches = append(lineMatches, h.highlightRegion(highlights, 0, true, i, line, h.lastRegion, false))
+		}
+	}
+
+	return lineMatches
+}
+
+// HighlightStates correctly sets all states for the buffer
+func (h *Highlighter) HighlightStates(input LineStates) {
+	for i := 0; i < input.LinesNum(); i++ {
+		line := []rune(input.Line(i))
+		// highlights := make(LineMatch)
+
+		if i == 0 || h.lastRegion == nil {
+			h.highlightEmptyRegion(nil, 0, true, i, line, true)
+		} else {
+			h.highlightRegion(nil, 0, true, i, line, h.lastRegion, true)
+		}
+
+		curState := h.lastRegion
+
+		input.SetState(i, curState)
+	}
+}
+
+// HighlightMatches sets the matches for each line in between startline and endline
+// It sets all other matches in the buffer to nil to conserve memory
+// This assumes that all the states are set correctly
+func (h *Highlighter) HighlightMatches(input LineStates, startline, endline int) {
+	for i := startline; i < endline; i++ {
+		if i >= input.LinesNum() {
+			break
+		}
+
+		line := []rune(input.Line(i))
+		highlights := make(LineMatch)
+
+		var match LineMatch
+		if i == 0 || input.State(i-1) == nil {
+			match = h.highlightEmptyRegion(highlights, 0, true, i, line, false)
+		} else {
+			match = h.highlightRegion(highlights, 0, true, i, line, input.State(i-1), false)
+		}
+
+		input.SetMatch(i, match)
+	}
+}
+
+// ReHighlightStates will scan down from `startline` and set the appropriate end of line state
+// for each line until it comes across the same state in two consecutive lines
+func (h *Highlighter) ReHighlightStates(input LineStates, startline int) {
+	// lines := input.LineData()
+
+	h.lastRegion = nil
+	if startline > 0 {
+		h.lastRegion = input.State(startline - 1)
+	}
+	for i := startline; i < input.LinesNum(); i++ {
+		line := []rune(input.Line(i))
+		// highlights := make(LineMatch)
+
+		// var match LineMatch
+		if i == 0 || h.lastRegion == nil {
+			h.highlightEmptyRegion(nil, 0, true, i, line, true)
+		} else {
+			h.highlightRegion(nil, 0, true, i, line, h.lastRegion, true)
+		}
+		curState := h.lastRegion
+		lastState := input.State(i)
+
+		input.SetState(i, curState)
+
+		if curState == lastState {
+			break
+		}
+	}
+}
+
+// ReHighlightLine will rehighlight the state and match for a single line
+func (h *Highlighter) ReHighlightLine(input LineStates, lineN int) {
+	line := []rune(input.Line(lineN))
+	highlights := make(LineMatch)
+
+	h.lastRegion = nil
+	if lineN > 0 {
+		h.lastRegion = input.State(lineN - 1)
+	}
+
+	var match LineMatch
+	if lineN == 0 || h.lastRegion == nil {
+		match = h.highlightEmptyRegion(highlights, 0, true, lineN, line, false)
+	} else {
+		match = h.highlightRegion(highlights, 0, true, lineN, line, h.lastRegion, false)
+	}
+	curState := h.lastRegion
+
+	input.SetMatch(lineN, match)
+	input.SetState(lineN, curState)
+}

cmd/micro/highlight/parser.go

@@ -0,0 +1,354 @@
+package highlight
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+
+	"gopkg.in/yaml.v2"
+)
+
+// A Group represents a syntax group
+type Group uint8
+
+// Groups contains all of the groups that are defined
+// You can access them in the map via their string name
+var Groups map[string]Group
+var numGroups Group
+
+// String returns the group name attached to the specific group
+func (g Group) String() string {
+	for k, v := range Groups {
+		if v == g {
+			return k
+		}
+	}
+	return ""
+}
+
+// A Def is a full syntax definition for a language
+// It has a filetype, information about how to detect the filetype based
+// on filename or header (the first line of the file)
+// Then it has the rules which define how to highlight the file
+type Def struct {
+	*Header
+
+	rules *rules
+}
+
+type Header struct {
+	FileType string
+	FtDetect [2]*regexp.Regexp
+}
+
+type File struct {
+	FileType string
+
+	yamlSrc map[interface{}]interface{}
+}
+
+// A Pattern is one simple syntax rule
+// It has a group that the rule belongs to, as well as
+// the regular expression to match the pattern
+type pattern struct {
+	group Group
+	regex *regexp.Regexp
+}
+
+// rules defines which patterns and regions can be used to highlight
+// a filetype
+type rules struct {
+	regions  []*region
+	patterns []*pattern
+	includes []string
+}
+
+// A region is a highlighted region (such as a multiline comment, or a string)
+// It belongs to a group, and has start and end regular expressions
+// A region also has rules of its own that only apply when matching inside the
+// region and also rules from the above region do not match inside this region
+// Note that a region may contain more regions
+type region struct {
+	group      Group
+	limitGroup Group
+	parent     *region
+	start      *regexp.Regexp
+	end        *regexp.Regexp
+	skip       *regexp.Regexp
+	rules      *rules
+}
+
+func init() {
+	Groups = make(map[string]Group)
+}
+
+func ParseFtDetect(file *File) (r [2]*regexp.Regexp, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("pkg: %v", r)
+			}
+		}
+	}()
+
+	rules := file.yamlSrc
+
+	loaded := 0
+	for k, v := range rules {
+		if k == "detect" {
+			ftdetect := v.(map[interface{}]interface{})
+			if len(ftdetect) >= 1 {
+				syntax, err := regexp.Compile(ftdetect["filename"].(string))
+				if err != nil {
+					return r, err
+				}
+
+				r[0] = syntax
+			}
+			if len(ftdetect) >= 2 {
+				header, err := regexp.Compile(ftdetect["header"].(string))
+				if err != nil {
+					return r, err
+				}
+
+				r[1] = header
+			}
+			loaded++
+		}
+
+		if loaded >= 2 {
+			break
+		}
+	}
+
+	if loaded == 0 {
+		return r, errors.New("No detect regexes found")
+	}
+
+	return r, err
+}
+
+func ParseFile(input []byte) (f *File, err error) {
+	// This is just so if we have an error, we can exit cleanly and return the parse error to the user
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("pkg: %v", r)
+			}
+		}
+	}()
+
+	var rules map[interface{}]interface{}
+	if err = yaml.Unmarshal(input, &rules); err != nil {
+		return nil, err
+	}
+
+	f = new(File)
+	f.yamlSrc = rules
+
+	for k, v := range rules {
+		if k == "filetype" {
+			filetype := v.(string)
+
+			f.FileType = filetype
+			break
+		}
+	}
+
+	return f, err
+}
+
+// ParseDef parses an input syntax file into a highlight Def
+func ParseDef(f *File, header *Header) (s *Def, err error) {
+	// This is just so if we have an error, we can exit cleanly and return the parse error to the user
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("pkg: %v", r)
+			}
+		}
+	}()
+
+	rules := f.yamlSrc
+
+	s = new(Def)
+	s.Header = header
+
+	for k, v := range rules {
+		if k == "rules" {
+			inputRules := v.([]interface{})
+
+			rules, err := parseRules(inputRules, nil)
+			if err != nil {
+				return nil, err
+			}
+
+			s.rules = rules
+		}
+	}
+
+	return s, err
+}
+
+// ResolveIncludes will sort out the rules for including other filetypes
+// You should call this after parsing all the Defs
+func ResolveIncludes(def *Def, files []*File) {
+	resolveIncludesInDef(files, def)
+}
+
+func resolveIncludesInDef(files []*File, d *Def) {
+	for _, lang := range d.rules.includes {
+		for _, searchFile := range files {
+			if lang == searchFile.FileType {
+				searchDef, _ := ParseDef(searchFile, nil)
+				d.rules.patterns = append(d.rules.patterns, searchDef.rules.patterns...)
+				d.rules.regions = append(d.rules.regions, searchDef.rules.regions...)
+			}
+		}
+	}
+	for _, r := range d.rules.regions {
+		resolveIncludesInRegion(files, r)
+		r.parent = nil
+	}
+}
+
+func resolveIncludesInRegion(files []*File, region *region) {
+	for _, lang := range region.rules.includes {
+		for _, searchFile := range files {
+			if lang == searchFile.FileType {
+				searchDef, _ := ParseDef(searchFile, nil)
+				region.rules.patterns = append(region.rules.patterns, searchDef.rules.patterns...)
+				region.rules.regions = append(region.rules.regions, searchDef.rules.regions...)
+			}
+		}
+	}
+	for _, r := range region.rules.regions {
+		resolveIncludesInRegion(files, r)
+		r.parent = region
+	}
+}
+
+func parseRules(input []interface{}, curRegion *region) (ru *rules, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("pkg: %v", r)
+			}
+		}
+	}()
+	ru = new(rules)
+
+	for _, v := range input {
+		rule := v.(map[interface{}]interface{})
+		for k, val := range rule {
+			group := k
+
+			switch object := val.(type) {
+			case string:
+				if k == "include" {
+					ru.includes = append(ru.includes, object)
+				} else {
+					// Pattern
+					r, err := regexp.Compile(object)
+					if err != nil {
+						return nil, err
+					}
+
+					groupStr := group.(string)
+					if _, ok := Groups[groupStr]; !ok {
+						numGroups++
+						Groups[groupStr] = numGroups
+					}
+					groupNum := Groups[groupStr]
+					ru.patterns = append(ru.patterns, &pattern{groupNum, r})
+				}
+			case map[interface{}]interface{}:
+				// region
+				region, err := parseRegion(group.(string), object, curRegion)
+				if err != nil {
+					return nil, err
+				}
+				ru.regions = append(ru.regions, region)
+			default:
+				return nil, fmt.Errorf("Bad type %T", object)
+			}
+		}
+	}
+
+	return ru, nil
+}
+
+func parseRegion(group string, regionInfo map[interface{}]interface{}, prevRegion *region) (r *region, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("pkg: %v", r)
+			}
+		}
+	}()
+
+	r = new(region)
+	if _, ok := Groups[group]; !ok {
+		numGroups++
+		Groups[group] = numGroups
+	}
+	groupNum := Groups[group]
+	r.group = groupNum
+	r.parent = prevRegion
+
+	r.start, err = regexp.Compile(regionInfo["start"].(string))
+
+	if err != nil {
+		return nil, err
+	}
+
+	r.end, err = regexp.Compile(regionInfo["end"].(string))
+
+	if err != nil {
+		return nil, err
+	}
+
+	// skip is optional
+	if _, ok := regionInfo["skip"]; ok {
+		r.skip, err = regexp.Compile(regionInfo["skip"].(string))
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// limit-color is optional
+	if _, ok := regionInfo["limit-group"]; ok {
+		groupStr := regionInfo["limit-group"].(string)
+		if _, ok := Groups[groupStr]; !ok {
+			numGroups++
+			Groups[groupStr] = numGroups
+		}
+		groupNum := Groups[groupStr]
+		r.limitGroup = groupNum
+
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		r.limitGroup = r.group
+	}
+
+	r.rules, err = parseRules(regionInfo["rules"].([]interface{}), r)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}

cmd/micro/highlighter.go

@@ -1,368 +1,28 @@
 package main
 
-import (
-	"regexp"
-	"strings"
+import "github.com/zyedidia/micro/cmd/micro/highlight"
 
-	"github.com/zyedidia/tcell"
-)
+var syntaxFiles []*highlight.File
 
-// FileTypeRules represents a complete set of syntax rules for a filetype
-type FileTypeRules struct {
-	filetype string
-	filename string
-	text     string
-}
-
-// SyntaxRule represents a regex to highlight in a certain style
-type SyntaxRule struct {
-	// What to highlight
-	regex *regexp.Regexp
-	// Any flags
-	flags string
-	// Whether this regex is a start=... end=... regex
-	startend bool
-	// How to highlight it
-	style tcell.Style
-}
-
-var syntaxKeys [][2]*regexp.Regexp
-var syntaxFiles map[[2]*regexp.Regexp]FileTypeRules
-
-// LoadSyntaxFiles loads the syntax files from the default directory (configDir)
 func LoadSyntaxFiles() {
 	InitColorscheme()
-	syntaxFiles = make(map[[2]*regexp.Regexp]FileTypeRules)
 	for _, f := range ListRuntimeFiles(RTSyntax) {
 		data, err := f.Data()
 		if err != nil {
 			TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
 		} else {
-			LoadSyntaxFile(string(data), f.Name())
+			LoadSyntaxFile(data, f.Name())
 		}
 	}
 }
 
-// JoinRule takes a syntax rule (which can be multiple regular expressions)
-// and joins it into one regular expression by ORing everything together
-func JoinRule(rule string) string {
-	split := strings.Split(rule, `" "`)
-	joined := strings.Join(split, ")|(")
-	joined = "(" + joined + ")"
-	return joined
-}
-
-// LoadSyntaxFile simply gets the filetype of a the syntax file and the source for the
-// file and creates FileTypeRules out of it. If this filetype is the one opened by the user
-// the rules will be loaded and compiled later
-// In this function we are only concerned with loading the syntax and header regexes
-func LoadSyntaxFile(text, filename string) {
-	var err error
-	lines := strings.Split(string(text), "\n")
-
-	// Regex for parsing syntax statements
-	syntaxParser := regexp.MustCompile(`syntax "(.*?)"\s+"(.*)"+`)
-	// Regex for parsing header statements
-	headerParser := regexp.MustCompile(`header "(.*)"`)
-
-	// Is there a syntax definition in this file?
-	hasSyntax := syntaxParser.MatchString(text)
-	// Is there a header definition in this file?
-	hasHeader := headerParser.MatchString(text)
-
-	var syntaxRegex *regexp.Regexp
-	var headerRegex *regexp.Regexp
-	var filetype string
-	for lineNum, line := range lines {
-		if (hasSyntax == (syntaxRegex != nil)) && (hasHeader == (headerRegex != nil)) {
-			// We found what we we're supposed to find
-			break
-		}
-
-		if strings.TrimSpace(line) == "" ||
-			strings.TrimSpace(line)[0] == '#' {
-			// Ignore this line
-			continue
-		}
-
-		if strings.HasPrefix(line, "syntax") {
-			// Syntax statement
-			syntaxMatches := syntaxParser.FindSubmatch([]byte(line))
-			if len(syntaxMatches) == 3 {
-				if syntaxRegex != nil {
-					TermError(filename, lineNum, "Syntax statement redeclaration")
-				}
-
-				filetype = string(syntaxMatches[1])
-				extensions := JoinRule(string(syntaxMatches[2]))
-
-				syntaxRegex, err = regexp.Compile(extensions)
-				if err != nil {
-					TermError(filename, lineNum, err.Error())
-					continue
-				}
-			} else {
-				TermError(filename, lineNum, "Syntax statement is not valid: "+line)
-				continue
-			}
-		} else if strings.HasPrefix(line, "header") {
-			// Header statement
-			headerMatches := headerParser.FindSubmatch([]byte(line))
-			if len(headerMatches) == 2 {
-				header := JoinRule(string(headerMatches[1]))
-
-				headerRegex, err = regexp.Compile(header)
-				if err != nil {
-					TermError(filename, lineNum, "Regex error: "+err.Error())
-					continue
-				}
-			} else {
-				TermError(filename, lineNum, "Header statement is not valid: "+line)
-				continue
-			}
-		}
-	}
-	if syntaxRegex != nil {
-		// Add the current rules to the syntaxFiles variable
-		regexes := [2]*regexp.Regexp{syntaxRegex, headerRegex}
-		syntaxKeys = append(syntaxKeys, regexes)
-		syntaxFiles[regexes] = FileTypeRules{filetype, filename, text}
-	}
-}
-
-// LoadRulesFromFile loads just the syntax rules from a given file
-// Only the necessary rules are loaded when the buffer is opened.
-// If we load all the rules for every filetype when micro starts, there's a bit of lag
-// A rule just explains how to color certain regular expressions
-// Example: color comment "//.*"
-// This would color all strings that match the regex "//.*" in the comment color defined
-// by the colorscheme
-func LoadRulesFromFile(text, filename string) []SyntaxRule {
-	lines := strings.Split(string(text), "\n")
-
-	// Regex for parsing standard syntax rules
-	ruleParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?"(.*)"`)
-	// Regex for parsing syntax rules with start="..." end="..."
-	ruleStartEndParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?start="(.*)"\s+end="(.*)"`)
-
-	var rules []SyntaxRule
-	for lineNum, line := range lines {
-		if strings.TrimSpace(line) == "" ||
-			strings.TrimSpace(line)[0] == '#' ||
-			strings.HasPrefix(line, "syntax") ||
-			strings.HasPrefix(line, "header") {
-			// Ignore this line
-			continue
-		}
-
-		// Syntax rule, but it could be standard or start-end
-		if ruleParser.MatchString(line) {
-			// Standard syntax rule
-			// Parse the line
-			submatch := ruleParser.FindSubmatch([]byte(line))
-			var color string
-			var regexStr string
-			var flags string
-			if len(submatch) == 4 {
-				// If len is 4 then the user specified some additional flags to use
-				color = string(submatch[1])
-				flags = string(submatch[2])
-				regexStr = "(?" + flags + ")" + JoinRule(string(submatch[3]))
-			} else if len(submatch) == 3 {
-				// If len is 3, no additional flags were given
-				color = string(submatch[1])
-				regexStr = JoinRule(string(submatch[2]))
-			} else {
-				// If len is not 3 or 4 there is a problem
-				TermError(filename, lineNum, "Invalid statement: "+line)
-				continue
-			}
-			// Compile the regex
-			regex, err := regexp.Compile(regexStr)
-			if err != nil {
-				TermError(filename, lineNum, err.Error())
-				continue
-			}
-
-			// Get the style
-			// The user could give us a "color" that is really a part of the colorscheme
-			// in which case we should look that up in the colorscheme
-			// They can also just give us a straight up color
-			st := defStyle
-			groups := strings.Split(color, ".")
-			if len(groups) > 1 {
-				curGroup := ""
-				for i, g := range groups {
-					if i != 0 {
-						curGroup += "."
-					}
-					curGroup += g
-					if style, ok := colorscheme[curGroup]; ok {
-						st = style
-					}
-				}
-			} else if style, ok := colorscheme[color]; ok {
-				st = style
-			} else {
-				st = StringToStyle(color)
-			}
-			// Add the regex, flags, and style
-			// False because this is not start-end
-			rules = append(rules, SyntaxRule{regex, flags, false, st})
-		} else if ruleStartEndParser.MatchString(line) {
-			// Start-end syntax rule
-			submatch := ruleStartEndParser.FindSubmatch([]byte(line))
-			var color string
-			var start string
-			var end string
-			// Use m and s flags by default
-			flags := "ms"
-			if len(submatch) == 5 {
-				// If len is 5 the user provided some additional flags
-				color = string(submatch[1])
-				flags += string(submatch[2])
-				start = string(submatch[3])
-				end = string(submatch[4])
-			} else if len(submatch) == 4 {
-				// If len is 4 the user did not provide additional flags
-				color = string(submatch[1])
-				start = string(submatch[2])
-				end = string(submatch[3])
-			} else {
-				// If len is not 4 or 5 there is a problem
-				TermError(filename, lineNum, "Invalid statement: "+line)
-				continue
-			}
-
-			// Compile the regex
-			regex, err := regexp.Compile("(?" + flags + ")" + "(" + start + ").*?(" + end + ")")
-			if err != nil {
-				TermError(filename, lineNum, err.Error())
-				continue
-			}
-
-			// Get the style
-			// The user could give us a "color" that is really a part of the colorscheme
-			// in which case we should look that up in the colorscheme
-			// They can also just give us a straight up color
-			st := defStyle
-			if _, ok := colorscheme[color]; ok {
-				st = colorscheme[color]
-			} else {
-				st = StringToStyle(color)
-			}
-			// Add the regex, flags, and style
-			// True because this is start-end
-			rules = append(rules, SyntaxRule{regex, flags, true, st})
-		}
-	}
-	return rules
-}
-
-// FindFileType finds the filetype for the given buffer
-func FindFileType(buf *Buffer) string {
-	for _, r := range syntaxKeys {
-		if r[1] != nil && r[1].MatchString(buf.Line(0)) {
-			// The header statement matches the first line
-			return syntaxFiles[r].filetype
-		}
-	}
-	for _, r := range syntaxKeys {
-		if r[0] != nil && r[0].MatchString(buf.Path) {
-			// The syntax statement matches the extension
-			return syntaxFiles[r].filetype
-		}
-	}
-	return "Unknown"
-}
-
-// GetRules finds the syntax rules that should be used for the buffer
-// and returns them. It also returns the filetype of the file
-func GetRules(buf *Buffer) []SyntaxRule {
-	for _, r := range syntaxKeys {
-		if syntaxFiles[r].filetype == buf.FileType() {
-			return LoadRulesFromFile(syntaxFiles[r].text, syntaxFiles[r].filename)
-		}
-	}
-	return nil
-}
-
-// SyntaxMatches is an alias to a map from character numbers to styles,
-// so map[3] represents the style of the third character
-type SyntaxMatches [][]tcell.Style
-
-// Match takes a buffer and returns the syntax matches: a 2d array specifying how it should be syntax highlighted
-// We match the rules from up `synLinesUp` lines and down `synLinesDown` lines
-func Match(v *View) SyntaxMatches {
-	buf := v.Buf
-	rules := v.Buf.rules
-
-	viewStart := v.Topline
-	viewEnd := v.Topline + v.Height
-	if viewEnd > buf.NumLines {
-		viewEnd = buf.NumLines
-	}
-
-	lines := buf.Lines(viewStart, viewEnd)
-	matches := make(SyntaxMatches, len(lines))
-
-	for i, line := range lines {
-		matches[i] = make([]tcell.Style, len(line)+1)
-		for j := range matches[i] {
-			matches[i][j] = defStyle
-		}
-	}
-
-	// We don't actually check the entire buffer, just from synLinesUp to synLinesDown
-	totalStart := v.Topline - synLinesUp
-	totalEnd := v.Topline + v.Height + synLinesDown
-	if totalStart < 0 {
-		totalStart = 0
-	}
-	if totalEnd > buf.NumLines {
-		totalEnd = buf.NumLines
-	}
-
-	str := strings.Join(buf.Lines(totalStart, totalEnd), "\n")
-	startNum := ToCharPos(Loc{0, totalStart}, v.Buf)
-
-	for _, rule := range rules {
-		if rule.startend {
-			if indicies := rule.regex.FindAllStringIndex(str, -1); indicies != nil {
-				for _, value := range indicies {
-					value[0] = runePos(value[0], str) + startNum
-					value[1] = runePos(value[1], str) + startNum
-					startLoc := FromCharPos(value[0], buf)
-					endLoc := FromCharPos(value[1], buf)
-					for curLoc := startLoc; curLoc.LessThan(endLoc); curLoc = curLoc.Move(1, buf) {
-						if curLoc.Y < v.Topline {
-							continue
-						}
-						colNum, lineNum := curLoc.X, curLoc.Y
-						if lineNum == -1 || colNum == -1 {
-							continue
-						}
-						lineNum -= viewStart
-						if lineNum >= 0 && lineNum < v.Height {
-							matches[lineNum][colNum] = rule.style
-						}
-					}
-				}
-			}
-		} else {
-			for lineN, line := range lines {
-				if indicies := rule.regex.FindAllStringIndex(line, -1); indicies != nil {
-					for _, value := range indicies {
-						start := runePos(value[0], line)
-						end := runePos(value[1], line)
-						for i := start; i < end; i++ {
-							matches[lineN][i] = rule.style
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return matches
+func LoadSyntaxFile(text []byte, filename string) {
+	f, err := highlight.ParseFile(text)
+
+	if err != nil {
+		TermMessage("Syntax file error: " + filename + ": " + err.Error())
+		return
+	}
+
+	syntaxFiles = append(syntaxFiles, f)
 }

cmd/micro/lineArray.go

@@ -2,9 +2,10 @@ package main
 
 import (
 	"bufio"
-	"bytes"
 	"io"
 	"unicode/utf8"
+
+	"github.com/zyedidia/micro/cmd/micro/highlight"
 )
 
 func runeToByteIndex(n int, txt []byte) int {
@@ -28,30 +29,84 @@ func runeToByteIndex(n int, txt []byte) int {
 	return count
 }
 
+type Line struct {
+	data []byte
+
+	state       highlight.State
+	match       highlight.LineMatch
+	rehighlight bool
+}
+
 // A LineArray simply stores and array of lines and makes it easy to insert
 // and delete in it
 type LineArray struct {
-	lines [][]byte
+	lines []Line
+}
+
+func Append(slice []Line, data ...Line) []Line {
+	l := len(slice)
+	if l+len(data) > cap(slice) { // reallocate
+		// Allocate double what's needed, for future growth.
+		newSlice := make([]Line, (l+len(data))+10000)
+		// The copy function is predeclared and works for any slice type.
+		copy(newSlice, slice)
+		slice = newSlice
+	}
+	slice = slice[0 : l+len(data)]
+	for i, c := range data {
+		slice[l+i] = c
+	}
+	return slice
 }
 
 // NewLineArray returns a new line array from an array of bytes
-func NewLineArray(reader io.Reader) *LineArray {
+func NewLineArray(size int64, reader io.Reader) *LineArray {
 	la := new(LineArray)
-	br := bufio.NewReader(reader)
 
-	i := 0
+	la.lines = make([]Line, 0, 1000)
+
+	br := bufio.NewReader(reader)
+	var loaded int
+
+	n := 0
 	for {
 		data, err := br.ReadBytes('\n')
+		if len(data) > 1 && data[len(data)-2] == '\r' {
+			data = append(data[:len(data)-2], '\n')
+			if fileformat == 0 {
+				fileformat = 2
+			}
+		} else if len(data) > 0 {
+			if fileformat == 0 {
+				fileformat = 1
+			}
+		}
+
+		if n >= 1000 && loaded >= 0 {
+			totalLinesNum := int(float64(size) * (float64(n) / float64(loaded)))
+			newSlice := make([]Line, len(la.lines), totalLinesNum+10000)
+			// The copy function is predeclared and works for any slice type.
+			copy(newSlice, la.lines)
+			la.lines = newSlice
+			loaded = -1
+		}
+
+		if loaded >= 0 {
+			loaded += len(data)
+		}
+
 		if err != nil {
 			if err == io.EOF {
-				la.lines = append(la.lines, data[:len(data)])
+				la.lines = Append(la.lines, Line{data[:], nil, nil, false})
+				// la.lines = Append(la.lines, Line{data[:len(data)]})
 			}
 			// Last line was read
 			break
 		} else {
-			la.lines = append(la.lines, data[:len(data)-1])
+			// la.lines = Append(la.lines, Line{data[:len(data)-1]})
+			la.lines = Append(la.lines, Line{data[:len(data)-1], nil, nil, false})
 		}
-		i++
+		n++
 	}
 
 	return la
@@ -59,19 +114,43 @@ func NewLineArray(reader io.Reader) *LineArray {
 
 // Returns the String representation of the LineArray
 func (la *LineArray) String() string {
-	return string(bytes.Join(la.lines, []byte("\n")))
+	str := ""
+	for i, l := range la.lines {
+		str += string(l.data)
+		if i != len(la.lines)-1 {
+			str += "\n"
+		}
+	}
+	return str
+}
+
+// SaveString returns the string that should be written to disk when
+// the line array is saved
+// It is the same as string but uses crlf or lf line endings depending
+func (la *LineArray) SaveString(useCrlf bool) string {
+	str := ""
+	for i, l := range la.lines {
+		str += string(l.data)
+		if i != len(la.lines)-1 {
+			if useCrlf {
+				str += "\r"
+			}
+			str += "\n"
+		}
+	}
+	return str
 }
 
 // NewlineBelow adds a newline below the given line number
 func (la *LineArray) NewlineBelow(y int) {
-	la.lines = append(la.lines, []byte(" "))
+	la.lines = append(la.lines, Line{[]byte(" "), nil, nil, false})
 	copy(la.lines[y+2:], la.lines[y+1:])
-	la.lines[y+1] = []byte("")
+	la.lines[y+1] = Line{[]byte(""), la.lines[y].state, nil, false}
 }
 
 // inserts a byte array at a given location
 func (la *LineArray) insert(pos Loc, value []byte) {
-	x, y := runeToByteIndex(pos.X, la.lines[pos.Y]), pos.Y
+	x, y := runeToByteIndex(pos.X, la.lines[pos.Y].data), pos.Y
 	// x, y := pos.x, pos.y
 	for i := 0; i < len(value); i++ {
 		if value[i] == '\n' {
@@ -87,31 +166,36 @@ func (la *LineArray) insert(pos Loc, value []byte) {
 
 // inserts a byte at a given location
 func (la *LineArray) insertByte(pos Loc, value byte) {
-	la.lines[pos.Y] = append(la.lines[pos.Y], 0)
-	copy(la.lines[pos.Y][pos.X+1:], la.lines[pos.Y][pos.X:])
-	la.lines[pos.Y][pos.X] = value
+	la.lines[pos.Y].data = append(la.lines[pos.Y].data, 0)
+	copy(la.lines[pos.Y].data[pos.X+1:], la.lines[pos.Y].data[pos.X:])
+	la.lines[pos.Y].data[pos.X] = value
 }
 
 // JoinLines joins the two lines a and b
 func (la *LineArray) JoinLines(a, b int) {
-	la.insert(Loc{len(la.lines[a]), a}, la.lines[b])
+	la.insert(Loc{len(la.lines[a].data), a}, la.lines[b].data)
 	la.DeleteLine(b)
 }
 
 // Split splits a line at a given position
 func (la *LineArray) Split(pos Loc) {
 	la.NewlineBelow(pos.Y)
-	la.insert(Loc{0, pos.Y + 1}, la.lines[pos.Y][pos.X:])
+	la.insert(Loc{0, pos.Y + 1}, la.lines[pos.Y].data[pos.X:])
+	la.lines[pos.Y+1].state = la.lines[pos.Y].state
+	la.lines[pos.Y].state = nil
+	la.lines[pos.Y].match = nil
+	la.lines[pos.Y+1].match = nil
+	la.lines[pos.Y].rehighlight = true
 	la.DeleteToEnd(Loc{pos.X, pos.Y})
 }
 
 // removes from start to end
 func (la *LineArray) remove(start, end Loc) string {
 	sub := la.Substr(start, end)
-	startX := runeToByteIndex(start.X, la.lines[start.Y])
-	endX := runeToByteIndex(end.X, la.lines[end.Y])
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
 	if start.Y == end.Y {
-		la.lines[start.Y] = append(la.lines[start.Y][:startX], la.lines[start.Y][endX:]...)
+		la.lines[start.Y].data = append(la.lines[start.Y].data[:startX], la.lines[start.Y].data[endX:]...)
 	} else {
 		for i := start.Y + 1; i <= end.Y-1; i++ {
 			la.DeleteLine(start.Y + 1)
@@ -125,12 +209,12 @@ func (la *LineArray) remove(start, end Loc) string {
 
 // DeleteToEnd deletes from the end of a line to the position
 func (la *LineArray) DeleteToEnd(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][:pos.X]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X]
 }
 
 // DeleteFromStart deletes from the start of a line to the position
 func (la *LineArray) DeleteFromStart(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][pos.X+1:]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[pos.X+1:]
 }
 
 // DeleteLine deletes the line number
@@ -140,21 +224,37 @@ func (la *LineArray) DeleteLine(y int) {
 
 // DeleteByte deletes the byte at a position
 func (la *LineArray) DeleteByte(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][:pos.X+copy(la.lines[pos.Y][pos.X:], la.lines[pos.Y][pos.X+1:])]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X+copy(la.lines[pos.Y].data[pos.X:], la.lines[pos.Y].data[pos.X+1:])]
 }
 
 // Substr returns the string representation between two locations
 func (la *LineArray) Substr(start, end Loc) string {
-	startX := runeToByteIndex(start.X, la.lines[start.Y])
-	endX := runeToByteIndex(end.X, la.lines[end.Y])
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
 	if start.Y == end.Y {
-		return string(la.lines[start.Y][startX:endX])
+		return string(la.lines[start.Y].data[startX:endX])
 	}
 	var str string
-	str += string(la.lines[start.Y][startX:]) + "\n"
+	str += string(la.lines[start.Y].data[startX:]) + "\n"
 	for i := start.Y + 1; i <= end.Y-1; i++ {
-		str += string(la.lines[i]) + "\n"
+		str += string(la.lines[i].data) + "\n"
 	}
-	str += string(la.lines[end.Y][:endX])
+	str += string(la.lines[end.Y].data[:endX])
 	return str
 }
+
+func (la *LineArray) State(lineN int) highlight.State {
+	return la.lines[lineN].state
+}
+
+func (la *LineArray) SetState(lineN int, s highlight.State) {
+	la.lines[lineN].state = s
+}
+
+func (la *LineArray) SetMatch(lineN int, m highlight.LineMatch) {
+	la.lines[lineN].match = m
+}
+
+func (la *LineArray) Match(lineN int) highlight.LineMatch {
+	return la.lines[lineN].match
+}

cmd/micro/loc.go

@@ -54,6 +54,28 @@ type Loc struct {
 	X, Y int
 }
 
+func Diff(a, b Loc, buf *Buffer) int {
+	if a.Y == b.Y {
+		if a.X > b.X {
+			return a.X - b.X
+		}
+		return b.X - a.X
+	}
+
+	// Make sure a is guaranteed to be less than b
+	if b.LessThan(a) {
+		a, b = b, a
+	}
+
+	loc := 0
+	for i := a.Y + 1; i < b.Y; i++ {
+		// + 1 for the newline
+		loc += Count(buf.Line(i)) + 1
+	}
+	loc += Count(buf.Line(a.Y)) - a.X + b.X + 1
+	return loc
+}
+
 // LessThan returns true if b is smaller
 func (l Loc) LessThan(b Loc) bool {
 	if l.Y < b.Y {

cmd/micro/lua.go

@@ -0,0 +1,536 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"math/rand"
+	"net"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"time"
+
+	luar "layeh.com/gopher-luar"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+var L *lua.LState
+
+func init() {
+	L = lua.NewState()
+	L.SetGlobal("import", luar.New(L, Import))
+}
+
+func LoadFile(module string, file string, data string) error {
+	pluginDef := "local P = {};" + module + " = P;setmetatable(" + module + ", {__index = _G});setfenv(1, P);"
+
+	if fn, err := L.Load(strings.NewReader(pluginDef+data), file); err != nil {
+		return err
+	} else {
+		L.Push(fn)
+		return L.PCall(0, lua.MultRet, nil)
+	}
+}
+
+func Import(pkg string) *lua.LTable {
+	switch pkg {
+	case "fmt":
+		return ImportFmt()
+	case "io":
+		return ImportIo()
+	case "ioutil":
+		return ImportIoUtil()
+	case "net":
+		return ImportNet()
+	case "math":
+		return ImportMath()
+	case "os":
+		return ImportOs()
+	case "runtime":
+		return ImportRuntime()
+	case "path":
+		return ImportPath()
+	case "filepath":
+		return ImportFilePath()
+	case "strings":
+		return ImportStrings()
+	case "regexp":
+		return ImportRegexp()
+	case "errors":
+		return ImportErrors()
+	case "time":
+		return ImportTime()
+	default:
+		return nil
+	}
+}
+
+func ImportFmt() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "tErrorf", luar.New(L, fmt.Errorf))
+	L.SetField(pkg, "Fprint", luar.New(L, fmt.Fprint))
+	L.SetField(pkg, "Fprintf", luar.New(L, fmt.Fprintf))
+	L.SetField(pkg, "Fprintln", luar.New(L, fmt.Fprintln))
+	L.SetField(pkg, "Fscan", luar.New(L, fmt.Fscan))
+	L.SetField(pkg, "Fscanf", luar.New(L, fmt.Fscanf))
+	L.SetField(pkg, "Fscanln", luar.New(L, fmt.Fscanln))
+	L.SetField(pkg, "Print", luar.New(L, fmt.Print))
+	L.SetField(pkg, "Printf", luar.New(L, fmt.Printf))
+	L.SetField(pkg, "Println", luar.New(L, fmt.Println))
+	L.SetField(pkg, "Scan", luar.New(L, fmt.Scan))
+	L.SetField(pkg, "Scanf", luar.New(L, fmt.Scanf))
+	L.SetField(pkg, "Scanln", luar.New(L, fmt.Scanln))
+	L.SetField(pkg, "Sprint", luar.New(L, fmt.Sprint))
+	L.SetField(pkg, "Sprintf", luar.New(L, fmt.Sprintf))
+	L.SetField(pkg, "Sprintln", luar.New(L, fmt.Sprintln))
+	L.SetField(pkg, "Sscan", luar.New(L, fmt.Sscan))
+	L.SetField(pkg, "Sscanf", luar.New(L, fmt.Sscanf))
+	L.SetField(pkg, "Sscanln", luar.New(L, fmt.Sscanln))
+
+	return pkg
+}
+
+func ImportIo() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Copy", luar.New(L, io.Copy))
+	L.SetField(pkg, "CopyN", luar.New(L, io.CopyN))
+	L.SetField(pkg, "EOF", luar.New(L, io.EOF))
+	L.SetField(pkg, "ErrClosedPipe", luar.New(L, io.ErrClosedPipe))
+	L.SetField(pkg, "ErrNoProgress", luar.New(L, io.ErrNoProgress))
+	L.SetField(pkg, "ErrShortBuffer", luar.New(L, io.ErrShortBuffer))
+	L.SetField(pkg, "ErrShortWrite", luar.New(L, io.ErrShortWrite))
+	L.SetField(pkg, "ErrUnexpectedEOF", luar.New(L, io.ErrUnexpectedEOF))
+	L.SetField(pkg, "LimitReader", luar.New(L, io.LimitReader))
+	L.SetField(pkg, "MultiReader", luar.New(L, io.MultiReader))
+	L.SetField(pkg, "MultiWriter", luar.New(L, io.MultiWriter))
+	L.SetField(pkg, "NewSectionReader", luar.New(L, io.NewSectionReader))
+	L.SetField(pkg, "Pipe", luar.New(L, io.Pipe))
+	L.SetField(pkg, "ReadAtLeast", luar.New(L, io.ReadAtLeast))
+	L.SetField(pkg, "ReadFull", luar.New(L, io.ReadFull))
+	L.SetField(pkg, "TeeReader", luar.New(L, io.TeeReader))
+	L.SetField(pkg, "WriteString", luar.New(L, io.WriteString))
+
+	return pkg
+}
+
+func ImportIoUtil() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "ReadAll", luar.New(L, ioutil.ReadAll))
+	L.SetField(pkg, "ReadDir", luar.New(L, ioutil.ReadDir))
+	L.SetField(pkg, "ReadFile", luar.New(L, ioutil.ReadFile))
+	L.SetField(pkg, "WriteFile", luar.New(L, ioutil.WriteFile))
+
+	return pkg
+}
+
+func ImportNet() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "CIDRMask", luar.New(L, net.CIDRMask))
+	L.SetField(pkg, "Dial", luar.New(L, net.Dial))
+	L.SetField(pkg, "DialIP", luar.New(L, net.DialIP))
+	L.SetField(pkg, "DialTCP", luar.New(L, net.DialTCP))
+	L.SetField(pkg, "DialTimeout", luar.New(L, net.DialTimeout))
+	L.SetField(pkg, "DialUDP", luar.New(L, net.DialUDP))
+	L.SetField(pkg, "DialUnix", luar.New(L, net.DialUnix))
+	L.SetField(pkg, "ErrWriteToConnected", luar.New(L, net.ErrWriteToConnected))
+	L.SetField(pkg, "FileConn", luar.New(L, net.FileConn))
+	L.SetField(pkg, "FileListener", luar.New(L, net.FileListener))
+	L.SetField(pkg, "FilePacketConn", luar.New(L, net.FilePacketConn))
+	L.SetField(pkg, "FlagBroadcast", luar.New(L, net.FlagBroadcast))
+	L.SetField(pkg, "FlagLoopback", luar.New(L, net.FlagLoopback))
+	L.SetField(pkg, "FlagMulticast", luar.New(L, net.FlagMulticast))
+	L.SetField(pkg, "FlagPointToPoint", luar.New(L, net.FlagPointToPoint))
+	L.SetField(pkg, "FlagUp", luar.New(L, net.FlagUp))
+	L.SetField(pkg, "IPv4", luar.New(L, net.IPv4))
+	L.SetField(pkg, "IPv4Mask", luar.New(L, net.IPv4Mask))
+	L.SetField(pkg, "IPv4allrouter", luar.New(L, net.IPv4allrouter))
+	L.SetField(pkg, "IPv4allsys", luar.New(L, net.IPv4allsys))
+	L.SetField(pkg, "IPv4bcast", luar.New(L, net.IPv4bcast))
+	L.SetField(pkg, "IPv4len", luar.New(L, net.IPv4len))
+	L.SetField(pkg, "IPv4zero", luar.New(L, net.IPv4zero))
+	L.SetField(pkg, "IPv6interfacelocalallnodes", luar.New(L, net.IPv6interfacelocalallnodes))
+	L.SetField(pkg, "IPv6len", luar.New(L, net.IPv6len))
+	L.SetField(pkg, "IPv6linklocalallnodes", luar.New(L, net.IPv6linklocalallnodes))
+	L.SetField(pkg, "IPv6linklocalallrouters", luar.New(L, net.IPv6linklocalallrouters))
+	L.SetField(pkg, "IPv6loopback", luar.New(L, net.IPv6loopback))
+	L.SetField(pkg, "IPv6unspecified", luar.New(L, net.IPv6unspecified))
+	L.SetField(pkg, "IPv6zero", luar.New(L, net.IPv6zero))
+	L.SetField(pkg, "InterfaceAddrs", luar.New(L, net.InterfaceAddrs))
+	L.SetField(pkg, "InterfaceByIndex", luar.New(L, net.InterfaceByIndex))
+	L.SetField(pkg, "InterfaceByName", luar.New(L, net.InterfaceByName))
+	L.SetField(pkg, "Interfaces", luar.New(L, net.Interfaces))
+	L.SetField(pkg, "JoinHostPort", luar.New(L, net.JoinHostPort))
+	L.SetField(pkg, "Listen", luar.New(L, net.Listen))
+	L.SetField(pkg, "ListenIP", luar.New(L, net.ListenIP))
+	L.SetField(pkg, "ListenMulticastUDP", luar.New(L, net.ListenMulticastUDP))
+	L.SetField(pkg, "ListenPacket", luar.New(L, net.ListenPacket))
+	L.SetField(pkg, "ListenTCP", luar.New(L, net.ListenTCP))
+	L.SetField(pkg, "ListenUDP", luar.New(L, net.ListenUDP))
+	L.SetField(pkg, "ListenUnix", luar.New(L, net.ListenUnix))
+	L.SetField(pkg, "ListenUnixgram", luar.New(L, net.ListenUnixgram))
+	L.SetField(pkg, "LookupAddr", luar.New(L, net.LookupAddr))
+	L.SetField(pkg, "LookupCNAME", luar.New(L, net.LookupCNAME))
+	L.SetField(pkg, "LookupHost", luar.New(L, net.LookupHost))
+	L.SetField(pkg, "LookupIP", luar.New(L, net.LookupIP))
+	L.SetField(pkg, "LookupMX", luar.New(L, net.LookupMX))
+	L.SetField(pkg, "LookupNS", luar.New(L, net.LookupNS))
+	L.SetField(pkg, "LookupPort", luar.New(L, net.LookupPort))
+	L.SetField(pkg, "LookupSRV", luar.New(L, net.LookupSRV))
+	L.SetField(pkg, "LookupTXT", luar.New(L, net.LookupTXT))
+	L.SetField(pkg, "ParseCIDR", luar.New(L, net.ParseCIDR))
+	L.SetField(pkg, "ParseIP", luar.New(L, net.ParseIP))
+	L.SetField(pkg, "ParseMAC", luar.New(L, net.ParseMAC))
+	L.SetField(pkg, "Pipe", luar.New(L, net.Pipe))
+	L.SetField(pkg, "ResolveIPAddr", luar.New(L, net.ResolveIPAddr))
+	L.SetField(pkg, "ResolveTCPAddr", luar.New(L, net.ResolveTCPAddr))
+	L.SetField(pkg, "ResolveUDPAddr", luar.New(L, net.ResolveUDPAddr))
+	L.SetField(pkg, "ResolveUnixAddr", luar.New(L, net.ResolveUnixAddr))
+	L.SetField(pkg, "SplitHostPort", luar.New(L, net.SplitHostPort))
+
+	return pkg
+}
+
+func ImportMath() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Abs", luar.New(L, math.Abs))
+	L.SetField(pkg, "Acos", luar.New(L, math.Acos))
+	L.SetField(pkg, "Acosh", luar.New(L, math.Acosh))
+	L.SetField(pkg, "Asin", luar.New(L, math.Asin))
+	L.SetField(pkg, "Asinh", luar.New(L, math.Asinh))
+	L.SetField(pkg, "Atan", luar.New(L, math.Atan))
+	L.SetField(pkg, "Atan2", luar.New(L, math.Atan2))
+	L.SetField(pkg, "Atanh", luar.New(L, math.Atanh))
+	L.SetField(pkg, "Cbrt", luar.New(L, math.Cbrt))
+	L.SetField(pkg, "Ceil", luar.New(L, math.Ceil))
+	L.SetField(pkg, "Copysign", luar.New(L, math.Copysign))
+	L.SetField(pkg, "Cos", luar.New(L, math.Cos))
+	L.SetField(pkg, "Cosh", luar.New(L, math.Cosh))
+	L.SetField(pkg, "Dim", luar.New(L, math.Dim))
+	L.SetField(pkg, "Erf", luar.New(L, math.Erf))
+	L.SetField(pkg, "Erfc", luar.New(L, math.Erfc))
+	L.SetField(pkg, "Exp", luar.New(L, math.Exp))
+	L.SetField(pkg, "Exp2", luar.New(L, math.Exp2))
+	L.SetField(pkg, "Expm1", luar.New(L, math.Expm1))
+	L.SetField(pkg, "Float32bits", luar.New(L, math.Float32bits))
+	L.SetField(pkg, "Float32frombits", luar.New(L, math.Float32frombits))
+	L.SetField(pkg, "Float64bits", luar.New(L, math.Float64bits))
+	L.SetField(pkg, "Float64frombits", luar.New(L, math.Float64frombits))
+	L.SetField(pkg, "Floor", luar.New(L, math.Floor))
+	L.SetField(pkg, "Frexp", luar.New(L, math.Frexp))
+	L.SetField(pkg, "Gamma", luar.New(L, math.Gamma))
+	L.SetField(pkg, "Hypot", luar.New(L, math.Hypot))
+	L.SetField(pkg, "Ilogb", luar.New(L, math.Ilogb))
+	L.SetField(pkg, "Inf", luar.New(L, math.Inf))
+	L.SetField(pkg, "IsInf", luar.New(L, math.IsInf))
+	L.SetField(pkg, "IsNaN", luar.New(L, math.IsNaN))
+	L.SetField(pkg, "J0", luar.New(L, math.J0))
+	L.SetField(pkg, "J1", luar.New(L, math.J1))
+	L.SetField(pkg, "Jn", luar.New(L, math.Jn))
+	L.SetField(pkg, "Ldexp", luar.New(L, math.Ldexp))
+	L.SetField(pkg, "Lgamma", luar.New(L, math.Lgamma))
+	L.SetField(pkg, "Log", luar.New(L, math.Log))
+	L.SetField(pkg, "Log10", luar.New(L, math.Log10))
+	L.SetField(pkg, "Log1p", luar.New(L, math.Log1p))
+	L.SetField(pkg, "Log2", luar.New(L, math.Log2))
+	L.SetField(pkg, "Logb", luar.New(L, math.Logb))
+	L.SetField(pkg, "Max", luar.New(L, math.Max))
+	L.SetField(pkg, "Min", luar.New(L, math.Min))
+	L.SetField(pkg, "Mod", luar.New(L, math.Mod))
+	L.SetField(pkg, "Modf", luar.New(L, math.Modf))
+	L.SetField(pkg, "NaN", luar.New(L, math.NaN))
+	L.SetField(pkg, "Nextafter", luar.New(L, math.Nextafter))
+	L.SetField(pkg, "Pow", luar.New(L, math.Pow))
+	L.SetField(pkg, "Pow10", luar.New(L, math.Pow10))
+	L.SetField(pkg, "Remainder", luar.New(L, math.Remainder))
+	L.SetField(pkg, "Signbit", luar.New(L, math.Signbit))
+	L.SetField(pkg, "Sin", luar.New(L, math.Sin))
+	L.SetField(pkg, "Sincos", luar.New(L, math.Sincos))
+	L.SetField(pkg, "Sinh", luar.New(L, math.Sinh))
+	L.SetField(pkg, "Sqrt", luar.New(L, math.Sqrt))
+	L.SetField(pkg, "Tan", luar.New(L, math.Tan))
+	L.SetField(pkg, "Tanh", luar.New(L, math.Tanh))
+	L.SetField(pkg, "Trunc", luar.New(L, math.Trunc))
+	L.SetField(pkg, "Y0", luar.New(L, math.Y0))
+	L.SetField(pkg, "Y1", luar.New(L, math.Y1))
+	L.SetField(pkg, "Yn", luar.New(L, math.Yn))
+
+	return pkg
+}
+
+func ImportMathRand() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "ExpFloat64", luar.New(L, rand.ExpFloat64))
+	L.SetField(pkg, "Float32", luar.New(L, rand.Float32))
+	L.SetField(pkg, "Float64", luar.New(L, rand.Float64))
+	L.SetField(pkg, "Int", luar.New(L, rand.Int))
+	L.SetField(pkg, "Int31", luar.New(L, rand.Int31))
+	L.SetField(pkg, "Int31n", luar.New(L, rand.Int31n))
+	L.SetField(pkg, "Int63", luar.New(L, rand.Int63))
+	L.SetField(pkg, "Int63n", luar.New(L, rand.Int63n))
+	L.SetField(pkg, "Intn", luar.New(L, rand.Intn))
+	L.SetField(pkg, "NormFloat64", luar.New(L, rand.NormFloat64))
+	L.SetField(pkg, "Perm", luar.New(L, rand.Perm))
+	L.SetField(pkg, "Seed", luar.New(L, rand.Seed))
+	L.SetField(pkg, "Uint32", luar.New(L, rand.Uint32))
+
+	return pkg
+}
+
+func ImportOs() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Args", luar.New(L, os.Args))
+	L.SetField(pkg, "Chdir", luar.New(L, os.Chdir))
+	L.SetField(pkg, "Chmod", luar.New(L, os.Chmod))
+	L.SetField(pkg, "Chown", luar.New(L, os.Chown))
+	L.SetField(pkg, "Chtimes", luar.New(L, os.Chtimes))
+	L.SetField(pkg, "Clearenv", luar.New(L, os.Clearenv))
+	L.SetField(pkg, "Create", luar.New(L, os.Create))
+	L.SetField(pkg, "DevNull", luar.New(L, os.DevNull))
+	L.SetField(pkg, "Environ", luar.New(L, os.Environ))
+	L.SetField(pkg, "ErrExist", luar.New(L, os.ErrExist))
+	L.SetField(pkg, "ErrInvalid", luar.New(L, os.ErrInvalid))
+	L.SetField(pkg, "ErrNotExist", luar.New(L, os.ErrNotExist))
+	L.SetField(pkg, "ErrPermission", luar.New(L, os.ErrPermission))
+	L.SetField(pkg, "Exit", luar.New(L, os.Exit))
+	L.SetField(pkg, "Expand", luar.New(L, os.Expand))
+	L.SetField(pkg, "ExpandEnv", luar.New(L, os.ExpandEnv))
+	L.SetField(pkg, "FindProcess", luar.New(L, os.FindProcess))
+	L.SetField(pkg, "Getegid", luar.New(L, os.Getegid))
+	L.SetField(pkg, "Getenv", luar.New(L, os.Getenv))
+	L.SetField(pkg, "Geteuid", luar.New(L, os.Geteuid))
+	L.SetField(pkg, "Getgid", luar.New(L, os.Getgid))
+	L.SetField(pkg, "Getgroups", luar.New(L, os.Getgroups))
+	L.SetField(pkg, "Getpagesize", luar.New(L, os.Getpagesize))
+	L.SetField(pkg, "Getpid", luar.New(L, os.Getpid))
+	L.SetField(pkg, "Getuid", luar.New(L, os.Getuid))
+	L.SetField(pkg, "Getwd", luar.New(L, os.Getwd))
+	L.SetField(pkg, "Hostname", luar.New(L, os.Hostname))
+	L.SetField(pkg, "Interrupt", luar.New(L, os.Interrupt))
+	L.SetField(pkg, "IsExist", luar.New(L, os.IsExist))
+	L.SetField(pkg, "IsNotExist", luar.New(L, os.IsNotExist))
+	L.SetField(pkg, "IsPathSeparator", luar.New(L, os.IsPathSeparator))
+	L.SetField(pkg, "IsPermission", luar.New(L, os.IsPermission))
+	L.SetField(pkg, "Kill", luar.New(L, os.Kill))
+	L.SetField(pkg, "Lchown", luar.New(L, os.Lchown))
+	L.SetField(pkg, "Link", luar.New(L, os.Link))
+	L.SetField(pkg, "Lstat", luar.New(L, os.Lstat))
+	L.SetField(pkg, "Mkdir", luar.New(L, os.Mkdir))
+	L.SetField(pkg, "MkdirAll", luar.New(L, os.MkdirAll))
+	L.SetField(pkg, "ModeAppend", luar.New(L, os.ModeAppend))
+	L.SetField(pkg, "ModeCharDevice", luar.New(L, os.ModeCharDevice))
+	L.SetField(pkg, "ModeDevice", luar.New(L, os.ModeDevice))
+	L.SetField(pkg, "ModeDir", luar.New(L, os.ModeDir))
+	L.SetField(pkg, "ModeExclusive", luar.New(L, os.ModeExclusive))
+	L.SetField(pkg, "ModeNamedPipe", luar.New(L, os.ModeNamedPipe))
+	L.SetField(pkg, "ModePerm", luar.New(L, os.ModePerm))
+	L.SetField(pkg, "ModeSetgid", luar.New(L, os.ModeSetgid))
+	L.SetField(pkg, "ModeSetuid", luar.New(L, os.ModeSetuid))
+	L.SetField(pkg, "ModeSocket", luar.New(L, os.ModeSocket))
+	L.SetField(pkg, "ModeSticky", luar.New(L, os.ModeSticky))
+	L.SetField(pkg, "ModeSymlink", luar.New(L, os.ModeSymlink))
+	L.SetField(pkg, "ModeTemporary", luar.New(L, os.ModeTemporary))
+	L.SetField(pkg, "ModeType", luar.New(L, os.ModeType))
+	L.SetField(pkg, "NewFile", luar.New(L, os.NewFile))
+	L.SetField(pkg, "NewSyscallError", luar.New(L, os.NewSyscallError))
+	L.SetField(pkg, "O_APPEND", luar.New(L, os.O_APPEND))
+	L.SetField(pkg, "O_CREATE", luar.New(L, os.O_CREATE))
+	L.SetField(pkg, "O_EXCL", luar.New(L, os.O_EXCL))
+	L.SetField(pkg, "O_RDONLY", luar.New(L, os.O_RDONLY))
+	L.SetField(pkg, "O_RDWR", luar.New(L, os.O_RDWR))
+	L.SetField(pkg, "O_SYNC", luar.New(L, os.O_SYNC))
+	L.SetField(pkg, "O_TRUNC", luar.New(L, os.O_TRUNC))
+	L.SetField(pkg, "O_WRONLY", luar.New(L, os.O_WRONLY))
+	L.SetField(pkg, "Open", luar.New(L, os.Open))
+	L.SetField(pkg, "OpenFile", luar.New(L, os.OpenFile))
+	L.SetField(pkg, "PathListSeparator", luar.New(L, os.PathListSeparator))
+	L.SetField(pkg, "PathSeparator", luar.New(L, os.PathSeparator))
+	L.SetField(pkg, "Pipe", luar.New(L, os.Pipe))
+	L.SetField(pkg, "Readlink", luar.New(L, os.Readlink))
+	L.SetField(pkg, "Remove", luar.New(L, os.Remove))
+	L.SetField(pkg, "RemoveAll", luar.New(L, os.RemoveAll))
+	L.SetField(pkg, "Rename", luar.New(L, os.Rename))
+	L.SetField(pkg, "SEEK_CUR", luar.New(L, os.SEEK_CUR))
+	L.SetField(pkg, "SEEK_END", luar.New(L, os.SEEK_END))
+	L.SetField(pkg, "SEEK_SET", luar.New(L, os.SEEK_SET))
+	L.SetField(pkg, "SameFile", luar.New(L, os.SameFile))
+	L.SetField(pkg, "Setenv", luar.New(L, os.Setenv))
+	L.SetField(pkg, "StartProcess", luar.New(L, os.StartProcess))
+	L.SetField(pkg, "Stat", luar.New(L, os.Stat))
+	L.SetField(pkg, "Stderr", luar.New(L, os.Stderr))
+	L.SetField(pkg, "Stdin", luar.New(L, os.Stdin))
+	L.SetField(pkg, "Stdout", luar.New(L, os.Stdout))
+	L.SetField(pkg, "Symlink", luar.New(L, os.Symlink))
+	L.SetField(pkg, "TempDir", luar.New(L, os.TempDir))
+	L.SetField(pkg, "Truncate", luar.New(L, os.Truncate))
+
+	return pkg
+}
+
+func ImportRuntime() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "GC", luar.New(L, runtime.GC))
+	L.SetField(pkg, "GOARCH", luar.New(L, runtime.GOARCH))
+	L.SetField(pkg, "GOMAXPROCS", luar.New(L, runtime.GOMAXPROCS))
+	L.SetField(pkg, "GOOS", luar.New(L, runtime.GOOS))
+	L.SetField(pkg, "GOROOT", luar.New(L, runtime.GOROOT))
+
+	return pkg
+}
+
+func ImportPath() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Base", luar.New(L, path.Base))
+	L.SetField(pkg, "Clean", luar.New(L, path.Clean))
+	L.SetField(pkg, "Dir", luar.New(L, path.Dir))
+	L.SetField(pkg, "ErrBadPattern", luar.New(L, path.ErrBadPattern))
+	L.SetField(pkg, "Ext", luar.New(L, path.Ext))
+	L.SetField(pkg, "IsAbs", luar.New(L, path.IsAbs))
+	L.SetField(pkg, "Join", luar.New(L, path.Join))
+	L.SetField(pkg, "Match", luar.New(L, path.Match))
+	L.SetField(pkg, "Split", luar.New(L, path.Split))
+
+	return pkg
+}
+
+func ImportFilePath() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Join", luar.New(L, filepath.Join))
+	L.SetField(pkg, "Clean", luar.New(L, filepath.Join))
+	L.SetField(pkg, "Abs", luar.New(L, filepath.Abs))
+	L.SetField(pkg, "Base", luar.New(L, filepath.Base))
+	L.SetField(pkg, "Clean", luar.New(L, filepath.Clean))
+	L.SetField(pkg, "Dir", luar.New(L, filepath.Dir))
+	L.SetField(pkg, "EvalSymlinks", luar.New(L, filepath.EvalSymlinks))
+	L.SetField(pkg, "Ext", luar.New(L, filepath.Ext))
+	L.SetField(pkg, "FromSlash", luar.New(L, filepath.FromSlash))
+	L.SetField(pkg, "Glob", luar.New(L, filepath.Glob))
+	L.SetField(pkg, "HasPrefix", luar.New(L, filepath.HasPrefix))
+	L.SetField(pkg, "IsAbs", luar.New(L, filepath.IsAbs))
+	L.SetField(pkg, "Join", luar.New(L, filepath.Join))
+	L.SetField(pkg, "Match", luar.New(L, filepath.Match))
+	L.SetField(pkg, "Rel", luar.New(L, filepath.Rel))
+	L.SetField(pkg, "Split", luar.New(L, filepath.Split))
+	L.SetField(pkg, "SplitList", luar.New(L, filepath.SplitList))
+	L.SetField(pkg, "ToSlash", luar.New(L, filepath.ToSlash))
+	L.SetField(pkg, "VolumeName", luar.New(L, filepath.VolumeName))
+
+	return pkg
+}
+
+func ImportStrings() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Contains", luar.New(L, strings.Contains))
+	L.SetField(pkg, "ContainsAny", luar.New(L, strings.ContainsAny))
+	L.SetField(pkg, "ContainsRune", luar.New(L, strings.ContainsRune))
+	L.SetField(pkg, "Count", luar.New(L, strings.Count))
+	L.SetField(pkg, "EqualFold", luar.New(L, strings.EqualFold))
+	L.SetField(pkg, "Fields", luar.New(L, strings.Fields))
+	L.SetField(pkg, "FieldsFunc", luar.New(L, strings.FieldsFunc))
+	L.SetField(pkg, "HasPrefix", luar.New(L, strings.HasPrefix))
+	L.SetField(pkg, "HasSuffix", luar.New(L, strings.HasSuffix))
+	L.SetField(pkg, "Index", luar.New(L, strings.Index))
+	L.SetField(pkg, "IndexAny", luar.New(L, strings.IndexAny))
+	L.SetField(pkg, "IndexByte", luar.New(L, strings.IndexByte))
+	L.SetField(pkg, "IndexFunc", luar.New(L, strings.IndexFunc))
+	L.SetField(pkg, "IndexRune", luar.New(L, strings.IndexRune))
+	L.SetField(pkg, "Join", luar.New(L, strings.Join))
+	L.SetField(pkg, "LastIndex", luar.New(L, strings.LastIndex))
+	L.SetField(pkg, "LastIndexAny", luar.New(L, strings.LastIndexAny))
+	L.SetField(pkg, "LastIndexFunc", luar.New(L, strings.LastIndexFunc))
+	L.SetField(pkg, "Map", luar.New(L, strings.Map))
+	L.SetField(pkg, "NewReader", luar.New(L, strings.NewReader))
+	L.SetField(pkg, "NewReplacer", luar.New(L, strings.NewReplacer))
+	L.SetField(pkg, "Repeat", luar.New(L, strings.Repeat))
+	L.SetField(pkg, "Replace", luar.New(L, strings.Replace))
+	L.SetField(pkg, "Split", luar.New(L, strings.Split))
+	L.SetField(pkg, "SplitAfter", luar.New(L, strings.SplitAfter))
+	L.SetField(pkg, "SplitAfterN", luar.New(L, strings.SplitAfterN))
+	L.SetField(pkg, "SplitN", luar.New(L, strings.SplitN))
+	L.SetField(pkg, "Title", luar.New(L, strings.Title))
+	L.SetField(pkg, "ToLower", luar.New(L, strings.ToLower))
+	L.SetField(pkg, "ToLowerSpecial", luar.New(L, strings.ToLowerSpecial))
+	L.SetField(pkg, "ToTitle", luar.New(L, strings.ToTitle))
+	L.SetField(pkg, "ToTitleSpecial", luar.New(L, strings.ToTitleSpecial))
+	L.SetField(pkg, "ToUpper", luar.New(L, strings.ToUpper))
+	L.SetField(pkg, "ToUpperSpecial", luar.New(L, strings.ToUpperSpecial))
+	L.SetField(pkg, "Trim", luar.New(L, strings.Trim))
+	L.SetField(pkg, "TrimFunc", luar.New(L, strings.TrimFunc))
+	L.SetField(pkg, "TrimLeft", luar.New(L, strings.TrimLeft))
+	L.SetField(pkg, "TrimLeftFunc", luar.New(L, strings.TrimLeftFunc))
+	L.SetField(pkg, "TrimPrefix", luar.New(L, strings.TrimPrefix))
+	L.SetField(pkg, "TrimRight", luar.New(L, strings.TrimRight))
+	L.SetField(pkg, "TrimRightFunc", luar.New(L, strings.TrimRightFunc))
+	L.SetField(pkg, "TrimSpace", luar.New(L, strings.TrimSpace))
+	L.SetField(pkg, "TrimSuffix", luar.New(L, strings.TrimSuffix))
+
+	return pkg
+}
+
+func ImportRegexp() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Match", luar.New(L, regexp.Match))
+	L.SetField(pkg, "MatchReader", luar.New(L, regexp.MatchReader))
+	L.SetField(pkg, "MatchString", luar.New(L, regexp.MatchString))
+	L.SetField(pkg, "QuoteMeta", luar.New(L, regexp.QuoteMeta))
+	L.SetField(pkg, "Compile", luar.New(L, regexp.Compile))
+	L.SetField(pkg, "CompilePOSIX", luar.New(L, regexp.CompilePOSIX))
+	L.SetField(pkg, "MustCompile", luar.New(L, regexp.MustCompile))
+	L.SetField(pkg, "MustCompilePOSIX", luar.New(L, regexp.MustCompilePOSIX))
+
+	return pkg
+}
+
+func ImportErrors() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "New", luar.New(L, errors.New))
+
+	return pkg
+}
+
+func ImportTime() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "After", luar.New(L, time.After))
+	L.SetField(pkg, "Sleep", luar.New(L, time.Sleep))
+	L.SetField(pkg, "Tick", luar.New(L, time.Tick))
+	L.SetField(pkg, "Since", luar.New(L, time.Since))
+	L.SetField(pkg, "FixedZone", luar.New(L, time.FixedZone))
+	L.SetField(pkg, "LoadLocation", luar.New(L, time.LoadLocation))
+	L.SetField(pkg, "NewTicker", luar.New(L, time.NewTicker))
+	L.SetField(pkg, "Date", luar.New(L, time.Date))
+	L.SetField(pkg, "Now", luar.New(L, time.Now))
+	L.SetField(pkg, "Parse", luar.New(L, time.Parse))
+	L.SetField(pkg, "ParseDuration", luar.New(L, time.ParseDuration))
+	L.SetField(pkg, "ParseInLocation", luar.New(L, time.ParseInLocation))
+	L.SetField(pkg, "Unix", luar.New(L, time.Unix))
+	L.SetField(pkg, "AfterFunc", luar.New(L, time.AfterFunc))
+	L.SetField(pkg, "NewTimer", luar.New(L, time.NewTimer))
+	L.SetField(pkg, "Nanosecond", luar.New(L, time.Nanosecond))
+	L.SetField(pkg, "Microsecond", luar.New(L, time.Microsecond))
+	L.SetField(pkg, "Millisecond", luar.New(L, time.Millisecond))
+	L.SetField(pkg, "Second", luar.New(L, time.Second))
+	L.SetField(pkg, "Minute", luar.New(L, time.Minute))
+	L.SetField(pkg, "Hour", luar.New(L, time.Hour))
+
+	return pkg
+}

cmd/micro/messenger.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"os"
 	"strconv"
-	"strings"
 
+	"github.com/mattn/go-runewidth"
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
 )
@@ -70,16 +70,18 @@ type Messenger struct {
 	gutterMessage bool
 }
 
-func (m *Messenger) AddLog(msg string) {
+// AddLog sends a message to the log view
+func (m *Messenger) AddLog(msg ...interface{}) {
+	logMessage := fmt.Sprint(msg...)
 	buffer := m.getBuffer()
-	buffer.insert(buffer.End(), []byte(msg+"\n"))
+	buffer.insert(buffer.End(), []byte(logMessage+"\n"))
 	buffer.Cursor.Loc = buffer.End()
 	buffer.Cursor.Relocate()
 }
 
 func (m *Messenger) getBuffer() *Buffer {
 	if m.log == nil {
-		m.log = NewBuffer(strings.NewReader(""), "")
+		m.log = NewBufferFromString("", "")
 		m.log.name = "Log"
 	}
 	return m.log
@@ -162,17 +164,19 @@ func (m *Messenger) YesNoPrompt(prompt string) (bool, bool) {
 		case *tcell.EventKey:
 			switch e.Key() {
 			case tcell.KeyRune:
-				if e.Rune() == 'y' {
+				if e.Rune() == 'y' || e.Rune() == 'Y' {
 					m.AddLog("\t--> y")
 					m.hasPrompt = false
 					return true, false
-				} else if e.Rune() == 'n' {
+				} else if e.Rune() == 'n' || e.Rune() == 'N' {
 					m.AddLog("\t--> n")
 					m.hasPrompt = false
 					return false, false
 				}
 			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
 				m.AddLog("\t--> (cancel)")
+				m.Clear()
+				m.Reset()
 				m.hasPrompt = false
 				return false, true
 			}
@@ -462,8 +466,10 @@ func (m *Messenger) Display() {
 	if m.hasMessage {
 		if m.hasPrompt || globalSettings["infobar"].(bool) {
 			runes := []rune(m.message + m.response)
+			posx := 0
 			for x := 0; x < len(runes); x++ {
-				screen.SetContent(x, h-1, runes[x], nil, m.style)
+				screen.SetContent(posx, h-1, runes[x], nil, m.style)
+				posx += runewidth.RuneWidth(runes[x])
 			}
 		}
 	}

cmd/micro/micro.go

@@ -11,18 +11,16 @@ import (
 	"time"
 
 	"github.com/go-errors/errors"
-	"layeh.com/gopher-luar"
 	"github.com/mattn/go-isatty"
 	"github.com/mitchellh/go-homedir"
 	"github.com/yuin/gopher-lua"
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
 	"github.com/zyedidia/tcell/encoding"
+	"layeh.com/gopher-luar"
 )
 
 const (
-	synLinesUp           = 75  // How many lines up to look to do syntax highlighting
-	synLinesDown         = 75  // How many lines down to look to do syntax highlighting
 	doubleClickThreshold = 400 // How many milliseconds to wait before a second click is not a double click
 	undoThreshold        = 500 // If two events are less than n milliseconds apart, undo both of them
 	autosaveTime         = 8   // Number of seconds to wait before autosaving
@@ -50,10 +48,6 @@ var (
 	CommitHash  = "Unknown"
 	CompileDate = "Unknown"
 
-	// L is the lua state
-	// This is the VM that runs the plugins
-	L *lua.LState
-
 	// The list of views
 	tabs []*Tab
 	// This is the currently open tab
@@ -84,13 +78,14 @@ func LoadInput() []*Buffer {
 	var filename string
 	var input []byte
 	var err error
-	var buffers []*Buffer
+	args := flag.Args()
+	buffers := make([]*Buffer, 0, len(args))
 
-	if len(flag.Args()) > 0 {
+	if len(args) > 0 {
 		// Option 1
 		// We go through each file and load it
-		for i := 0; i < len(flag.Args()); i++ {
-			filename = flag.Args()[i]
+		for i := 0; i < len(args); i++ {
+			filename = args[i]
 
 			// Check that the file exists
 			var input *os.File
@@ -110,9 +105,9 @@ func LoadInput() []*Buffer {
 			}
 			// If the file didn't exist, input will be empty, and we'll open an empty buffer
 			if input != nil {
-				buffers = append(buffers, NewBuffer(input, filename))
+				buffers = append(buffers, NewBuffer(input, FSize(input), filename))
 			} else {
-				buffers = append(buffers, NewBuffer(strings.NewReader(""), filename))
+				buffers = append(buffers, NewBufferFromString("", filename))
 			}
 		}
 	} else if !isatty.IsTerminal(os.Stdin.Fd()) {
@@ -124,10 +119,10 @@ func LoadInput() []*Buffer {
 			TermMessage("Error reading from stdin: ", err)
 			input = []byte{}
 		}
-		buffers = append(buffers, NewBuffer(strings.NewReader(string(input)), filename))
+		buffers = append(buffers, NewBufferFromString(string(input), filename))
 	} else {
 		// Option 3, just open an empty buffer
-		buffers = append(buffers, NewBuffer(strings.NewReader(string(input)), filename))
+		buffers = append(buffers, NewBufferFromString(string(input), filename))
 	}
 
 	return buffers
@@ -182,6 +177,10 @@ func InitScreen() {
 	screen, err = tcell.NewScreen()
 	if err != nil {
 		fmt.Println(err)
+		if err == tcell.ErrTermNotFound {
+			fmt.Println("Micro does not recognize your terminal:", oldTerm)
+			fmt.Println("Please go to https://github.com/zyedidia/mkinfo to read about how to fix this problem (it should be easy to fix).")
+		}
 		os.Exit(1)
 	}
 	if err = screen.Init(); err != nil {
@@ -195,12 +194,19 @@ func InitScreen() {
 	}
 
 	screen.SetStyle(defStyle)
-	screen.EnableMouse()
 }
 
 // RedrawAll redraws everything -- all the views and the messenger
 func RedrawAll() {
 	messenger.Clear()
+
+	w, h := screen.Size()
+	for x := 0; x < w; x++ {
+		for y := 0; y < h; y++ {
+			screen.SetContent(x, y, ' ', nil, defStyle)
+		}
+	}
+
 	for _, v := range tabs[curTab].views {
 		v.Display()
 	}
@@ -222,14 +228,11 @@ func LoadAll() {
 	InitCommands()
 	InitBindings()
 
-	LoadSyntaxFiles()
+	InitColorscheme()
 
 	for _, tab := range tabs {
 		for _, v := range tab.views {
 			v.Buf.UpdateRules()
-			if v.Buf.Settings["syntax"].(bool) {
-				v.matches = Match(v)
-			}
 		}
 	}
 }
@@ -242,6 +245,7 @@ func main() {
 	flag.Usage = func() {
 		fmt.Println("Usage: micro [OPTIONS] [FILE]...")
 		fmt.Print("Micro's options can be set via command line arguments for quick adjustments. For real configuration, please use the bindings.json file (see 'help options').\n\n")
+		flag.CommandLine.SetOutput(os.Stdout)
 		flag.PrintDefaults()
 	}
 
@@ -308,6 +312,7 @@ func main() {
 		screen.Fini()
 		os.Exit(1)
 	}
+
 	for _, buf := range buffers {
 		// For each buffer we create a new tab and place the view in that tab
 		tab := NewTabFromView(NewView(buf))
@@ -353,6 +358,7 @@ func main() {
 	L.SetGlobal("Loc", luar.New(L, func(x, y int) Loc {
 		return Loc{x, y}
 	}))
+	L.SetGlobal("WorkingDirectory", luar.New(L, os.Getwd))
 	L.SetGlobal("JoinPaths", luar.New(L, filepath.Join))
 	L.SetGlobal("DirectoryName", luar.New(L, filepath.Dir))
 	L.SetGlobal("configDir", luar.New(L, configDir))
@@ -371,6 +377,10 @@ func main() {
 	L.SetGlobal("ListRuntimeFiles", luar.New(L, PluginListRuntimeFiles))
 	L.SetGlobal("AddRuntimeFile", luar.New(L, PluginAddRuntimeFile))
 	L.SetGlobal("AddRuntimeFilesFromDirectory", luar.New(L, PluginAddRuntimeFilesFromDirectory))
+	L.SetGlobal("AddRuntimeFileFromMemory", luar.New(L, PluginAddRuntimeFileFromMemory))
+
+	// Access to Go stdlib
+	L.SetGlobal("import", luar.New(L, Import))
 
 	jobs = make(chan JobFunction, 100)
 	events = make(chan tcell.Event, 100)
@@ -378,13 +388,8 @@ func main() {
 
 	LoadPlugins()
 
-	// Load the syntax files, including the colorscheme
-	LoadSyntaxFiles()
-
 	for _, t := range tabs {
 		for _, v := range t.views {
-			v.Buf.FindFileType()
-			v.Buf.UpdateRules()
 			for pl := range loadedPlugins {
 				_, err := Call(pl+".onViewOpen", v)
 				if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
@@ -392,16 +397,17 @@ func main() {
 					continue
 				}
 			}
-			if v.Buf.Settings["syntax"].(bool) {
-				v.matches = Match(v)
-			}
 		}
 	}
 
+	InitColorscheme()
+
 	// Here is the event loop which runs in a separate thread
 	go func() {
 		for {
-			events <- screen.PollEvent()
+			if screen != nil {
+				events <- screen.PollEvent()
+			}
 		}
 	}()
 
@@ -433,26 +439,32 @@ func main() {
 
 		for event != nil {
 			switch e := event.(type) {
+			case *tcell.EventResize:
+				for _, t := range tabs {
+					t.Resize()
+				}
 			case *tcell.EventMouse:
-				if e.Buttons() == tcell.Button1 {
-					// If the user left clicked we check a couple things
-					_, h := screen.Size()
-					x, y := e.Position()
-					if y == h-1 && messenger.message != "" && globalSettings["infobar"].(bool) {
-						// If the user clicked in the bottom bar, and there is a message down there
-						// we copy it to the clipboard.
-						// Often error messages are displayed down there so it can be useful to easily
-						// copy the message
-						clipboard.WriteAll(messenger.message, "primary")
-						break
-					}
+				if !searching {
+					if e.Buttons() == tcell.Button1 {
+						// If the user left clicked we check a couple things
+						_, h := screen.Size()
+						x, y := e.Position()
+						if y == h-1 && messenger.message != "" && globalSettings["infobar"].(bool) {
+							// If the user clicked in the bottom bar, and there is a message down there
+							// we copy it to the clipboard.
+							// Often error messages are displayed down there so it can be useful to easily
+							// copy the message
+							clipboard.WriteAll(messenger.message, "primary")
+							break
+						}
 
-					if CurView().mouseReleased {
-						// We loop through each view in the current tab and make sure the current view
-						// is the one being clicked in
-						for _, v := range tabs[curTab].views {
-							if x >= v.x && x < v.x+v.Width && y >= v.y && y < v.y+v.Height {
-								tabs[curTab].CurView = v.Num
+						if CurView().mouseReleased {
+							// We loop through each view in the current tab and make sure the current view
+							// is the one being clicked in
+							for _, v := range tabs[curTab].views {
+								if x >= v.x && x < v.x+v.Width && y >= v.y && y < v.y+v.Height {
+									tabs[curTab].CurView = v.Num
+								}
 							}
 						}
 					}
@@ -480,7 +492,6 @@ func main() {
 			default:
 				event = nil
 			}
-
 		}
 	}
 }

cmd/micro/plugin.go

@@ -6,8 +6,9 @@ import (
 	"os"
 	"strings"
 
-	"layeh.com/gopher-luar"
 	"github.com/yuin/gopher-lua"
+	"github.com/zyedidia/tcell"
+	"layeh.com/gopher-luar"
 )
 
 var loadedPlugins map[string]string
@@ -60,6 +61,16 @@ func LuaFunctionBinding(function string) func(*View, bool) bool {
 	}
 }
 
+func LuaFunctionMouseBinding(function string) func(*View, bool, *tcell.EventMouse) bool {
+	return func(v *View, _ bool, e *tcell.EventMouse) bool {
+		_, err := Call(function, e)
+		if err != nil {
+			TermMessage(err)
+		}
+		return false
+	}
+}
+
 func unpack(old []string) []interface{} {
 	new := make([]interface{}, len(old))
 	for i, v := range old {
@@ -119,11 +130,9 @@ func luaPluginName(name string) string {
 
 // LoadPlugins loads the pre-installed plugins and the plugins located in ~/.config/micro/plugins
 func LoadPlugins() {
-
 	loadedPlugins = make(map[string]string)
 
 	for _, plugin := range ListRuntimeFiles(RTPlugin) {
-
 		pluginName := plugin.Name()
 		if _, ok := loadedPlugins[pluginName]; ok {
 			continue
@@ -136,9 +145,8 @@ func LoadPlugins() {
 		}
 
 		pluginLuaName := luaPluginName(pluginName)
-		pluginDef := "\nlocal P = {}\n" + pluginLuaName + " = P\nsetmetatable(" + pluginLuaName + ", {__index = _G})\nsetfenv(1, P)\n"
 
-		if err := L.DoString(pluginDef + string(data)); err != nil {
+		if err := LoadFile(pluginName, pluginName, string(data)); err != nil {
 			TermMessage(err)
 			continue
 		}
@@ -148,9 +156,8 @@ func LoadPlugins() {
 	}
 
 	if _, err := os.Stat(configDir + "/init.lua"); err == nil {
-		pluginDef := "\nlocal P = {}\n" + "init" + " = P\nsetmetatable(" + "init" + ", {__index = _G})\nsetfenv(1, P)\n"
 		data, _ := ioutil.ReadFile(configDir + "/init.lua")
-		if err := L.DoString(pluginDef + string(data)); err != nil {
+		if err := LoadFile("init", configDir+"init.lua", string(data)); err != nil {
 			TermMessage(err)
 		}
 		loadedPlugins["init"] = "init"

cmd/micro/pluginmanager.go

@@ -8,14 +8,15 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"path"
 	"path/filepath"
 	"sort"
 	"strings"
 	"sync"
 
 	"github.com/blang/semver"
+	"github.com/flynn/json5"
 	"github.com/yuin/gopher-lua"
-	"github.com/zyedidia/json5/encoding/json5"
 )
 
 var (
@@ -434,6 +435,12 @@ func (pv *PluginVersion) DownloadAndInstall() error {
 				return err
 			}
 		} else {
+			basepath := path.Dir(targetName)
+
+			if err := os.MkdirAll(basepath, dirPerm); err != nil {
+				return err
+			}
+
 			content, err := f.Open()
 			if err != nil {
 				return err

cmd/micro/pluginmanager_test.go

@@ -1,10 +1,11 @@
 package main
 
 import (
-	"github.com/blang/semver"
 	"testing"
 
-	"github.com/zyedidia/json5/encoding/json5"
+	"github.com/blang/semver"
+
+	"github.com/flynn/json5"
 )
 
 func TestDependencyResolving(t *testing.T) {

cmd/micro/rtfiles.go

@@ -37,6 +37,19 @@ type namedFile struct {
 	name string
 }
 
+// a file with the data stored in memory
+type memoryFile struct {
+	name string
+	data []byte
+}
+
+func (mf memoryFile) Name() string {
+	return mf.name
+}
+func (mf memoryFile) Data() ([]byte, error) {
+	return mf.data, nil
+}
+
 func (rf realFile) Name() string {
 	fn := filepath.Base(string(rf))
 	return fn[:len(fn)-len(filepath.Ext(fn))]
@@ -120,7 +133,7 @@ func InitRuntimeFiles() {
 	}
 
 	add(RTColorscheme, "colorschemes", "*.micro")
-	add(RTSyntax, "syntax", "*.micro")
+	add(RTSyntax, "syntax", "*.yaml")
 	add(RTHelp, "help", "*.md")
 
 	// Search configDir for plugin-scripts
@@ -187,3 +200,8 @@ func PluginAddRuntimeFilesFromDirectory(plugin, filetype, directory, pattern str
 		AddRuntimeFilesFromAssets(filetype, fullpath, pattern)
 	}
 }
+
+// PluginAddRuntimeFileFromMemory adds a file to the runtime files for a plugin from a given string
+func PluginAddRuntimeFileFromMemory(plugin, filetype, filename, data string) {
+	AddRuntimeFile(filetype, memoryFile{filename, []byte(data)})
+}

cmd/micro/search.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"regexp"
+	"strings"
 
 	"github.com/zyedidia/tcell"
 )
@@ -11,7 +12,7 @@ var (
 	lastSearch string
 
 	// Where should we start the search down from (or up from)
-	searchStart int
+	searchStart Loc
 
 	// Is there currently a search in progress
 	searching bool
@@ -43,7 +44,7 @@ func EndSearch() {
 	}
 }
 
-// exit the search mode, reset active search phrase, and clear status bar
+// ExitSearch exits the search mode, reset active search phrase, and clear status bar
 func ExitSearch(v *View) {
 	lastSearch = ""
 	searching = false
@@ -86,9 +87,71 @@ func HandleSearchEvent(event tcell.Event, v *View) {
 
 	Search(messenger.response, v, true)
 
+	v.Relocate()
+
 	return
 }
 
+func searchDown(r *regexp.Regexp, v *View, start, end Loc) bool {
+	for i := start.Y; i <= end.Y; i++ {
+		var l []byte
+		var charPos int
+		if i == start.Y {
+			runes := []rune(string(v.Buf.lines[i].data))
+			l = []byte(string(runes[start.X:]))
+			charPos = start.X
+
+			if strings.Contains(r.String(), "^") && start.X != 0 {
+				continue
+			}
+		} else {
+			l = v.Buf.lines[i].data
+		}
+
+		match := r.FindIndex(l)
+
+		if match != nil {
+			v.Cursor.SetSelectionStart(Loc{charPos + runePos(match[0], string(l)), i})
+			v.Cursor.SetSelectionEnd(Loc{charPos + runePos(match[1], string(l)), i})
+			v.Cursor.OrigSelection[0] = v.Cursor.CurSelection[0]
+			v.Cursor.OrigSelection[1] = v.Cursor.CurSelection[1]
+			v.Cursor.Loc = v.Cursor.CurSelection[1]
+
+			return true
+		}
+	}
+	return false
+}
+
+func searchUp(r *regexp.Regexp, v *View, start, end Loc) bool {
+	for i := start.Y; i >= end.Y; i-- {
+		var l []byte
+		if i == start.Y {
+			runes := []rune(string(v.Buf.lines[i].data))
+			l = []byte(string(runes[:start.X]))
+
+			if strings.Contains(r.String(), "$") && start.X != Count(string(l)) {
+				continue
+			}
+		} else {
+			l = v.Buf.lines[i].data
+		}
+
+		match := r.FindIndex(l)
+
+		if match != nil {
+			v.Cursor.SetSelectionStart(Loc{runePos(match[0], string(l)), i})
+			v.Cursor.SetSelectionEnd(Loc{runePos(match[1], string(l)), i})
+			v.Cursor.OrigSelection[0] = v.Cursor.CurSelection[0]
+			v.Cursor.OrigSelection[1] = v.Cursor.CurSelection[1]
+			v.Cursor.Loc = v.Cursor.CurSelection[1]
+
+			return true
+		}
+	}
+	return false
+}
+
 // Search searches in the view for the given regex. The down bool
 // specifies whether it should search down from the searchStart position
 // or up from there
@@ -96,15 +159,6 @@ func Search(searchStr string, v *View, down bool) {
 	if searchStr == "" {
 		return
 	}
-	var str string
-	var charPos int
-	text := v.Buf.String()
-	if down {
-		str = string([]rune(text)[searchStart:])
-		charPos = searchStart
-	} else {
-		str = string([]rune(text)[:searchStart])
-	}
 	r, err := regexp.Compile(searchStr)
 	if v.Buf.Settings["ignorecase"].(bool) {
 		r, err = regexp.Compile("(?i)" + searchStr)
@@ -112,40 +166,22 @@ func Search(searchStr string, v *View, down bool) {
 	if err != nil {
 		return
 	}
-	matches := r.FindAllStringIndex(str, -1)
-	var match []int
-	if matches == nil {
-		// Search the entire buffer now
-		matches = r.FindAllStringIndex(text, -1)
-		charPos = 0
-		if matches == nil {
-			v.Cursor.ResetSelection()
-			return
-		}
 
-		if !down {
-			match = matches[len(matches)-1]
-		} else {
-			match = matches[0]
+	var found bool
+	if down {
+		found = searchDown(r, v, searchStart, v.Buf.End())
+		if !found {
+			found = searchDown(r, v, v.Buf.Start(), searchStart)
 		}
-		str = text
-	}
-
-	if !down {
-		match = matches[len(matches)-1]
 	} else {
-		match = matches[0]
+		found = searchUp(r, v, searchStart, v.Buf.Start())
+		if !found {
+			found = searchUp(r, v, v.Buf.End(), searchStart)
+		}
 	}
-
-	if match[0] == match[1] {
-		return
+	if found {
+		lastSearch = searchStr
+	} else {
+		v.Cursor.ResetSelection()
 	}
-
-	v.Cursor.SetSelectionStart(FromCharPos(charPos+runePos(match[0], str), v.Buf))
-	v.Cursor.SetSelectionEnd(FromCharPos(charPos+runePos(match[1], str), v.Buf))
-	v.Cursor.Loc = v.Cursor.CurSelection[1]
-	if v.Relocate() {
-		v.matches = Match(v)
-	}
-	lastSearch = searchStr
 }

cmd/micro/settings.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"errors"
 	"io/ioutil"
 	"os"
@@ -8,8 +9,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/flynn/json5"
 	"github.com/zyedidia/glob"
-	"github.com/zyedidia/json5/encoding/json5"
 )
 
 type optionValidator func(string, interface{}) error
@@ -17,6 +18,8 @@ type optionValidator func(string, interface{}) error
 // The options that the user can set
 var globalSettings map[string]interface{}
 
+var invalidSettings bool
+
 // Options with validators
 var optionValidators = map[string]optionValidator{
 	"tabsize":      validatePositiveValue,
@@ -24,10 +27,12 @@ var optionValidators = map[string]optionValidator{
 	"scrollspeed":  validateNonNegativeValue,
 	"colorscheme":  validateColorscheme,
 	"colorcolumn":  validateNonNegativeValue,
+	"fileformat":   validateLineEnding,
 }
 
 // InitGlobalSettings initializes the options map and sets all options to their default values
 func InitGlobalSettings() {
+	invalidSettings = false
 	defaults := DefaultGlobalSettings()
 	var parsed map[string]interface{}
 
@@ -38,12 +43,14 @@ func InitGlobalSettings() {
 		if !strings.HasPrefix(string(input), "null") {
 			if err != nil {
 				TermMessage("Error reading settings.json file: " + err.Error())
+				invalidSettings = true
 				return
 			}
 
 			err = json5.Unmarshal(input, &parsed)
 			if err != nil {
 				TermMessage("Error reading settings.json:", err.Error())
+				invalidSettings = true
 			}
 		} else {
 			writeSettings = true
@@ -71,6 +78,7 @@ func InitGlobalSettings() {
 // InitLocalSettings scans the json in settings.json and sets the options locally based
 // on whether the buffer matches the glob
 func InitLocalSettings(buf *Buffer) {
+	invalidSettings = false
 	var parsed map[string]interface{}
 
 	filename := configDir + "/settings.json"
@@ -78,12 +86,14 @@ func InitLocalSettings(buf *Buffer) {
 		input, err := ioutil.ReadFile(filename)
 		if err != nil {
 			TermMessage("Error reading settings.json file: " + err.Error())
+			invalidSettings = true
 			return
 		}
 
 		err = json5.Unmarshal(input, &parsed)
 		if err != nil {
 			TermMessage("Error reading settings.json:", err.Error())
+			invalidSettings = true
 		}
 	}
 
@@ -106,6 +116,11 @@ func InitLocalSettings(buf *Buffer) {
 
 // WriteSettings writes the settings to the specified filename as JSON
 func WriteSettings(filename string) error {
+	if invalidSettings {
+		// Do not write the settings if there was an error when reading them
+		return nil
+	}
+
 	var err error
 	if _, e := os.Stat(configDir); e == nil {
 		parsed := make(map[string]interface{})
@@ -124,6 +139,7 @@ func WriteSettings(filename string) error {
 				err = json5.Unmarshal(input, &parsed)
 				if err != nil {
 					TermMessage("Error reading settings.json:", err.Error())
+					invalidSettings = true
 				}
 
 				for k, v := range parsed {
@@ -136,7 +152,7 @@ func WriteSettings(filename string) error {
 			}
 		}
 
-		txt, _ := json5.MarshalIndent(parsed, "", "    ")
+		txt, _ := json.MarshalIndent(parsed, "", "    ")
 		err = ioutil.WriteFile(filename, append(txt, '\n'), 0644)
 	}
 	return err
@@ -196,13 +212,17 @@ func DefaultGlobalSettings() map[string]interface{} {
 		"splitBottom":    true,
 		"statusline":     true,
 		"syntax":         true,
+		"tabmovement":    false,
 		"tabsize":        float64(4),
 		"tabstospaces":   false,
+		"termtitle":      false,
 		"pluginchannels": []string{
 			"https://raw.githubusercontent.com/micro-editor/plugin-channel/master/channel.json",
 		},
 		"pluginrepos": []string{},
 		"useprimary":  true,
+		"fileformat":  "unix",
+		"mouse":       true,
 	}
 }
 
@@ -230,9 +250,12 @@ func DefaultLocalSettings() map[string]interface{} {
 		"splitBottom":    true,
 		"statusline":     true,
 		"syntax":         true,
+		"tabmovement":    false,
 		"tabsize":        float64(4),
 		"tabstospaces":   false,
 		"useprimary":     true,
+		"fileformat":     "unix",
+		"mouse":          true,
 	}
 }
 
@@ -277,13 +300,11 @@ func SetOption(option, value string) error {
 	globalSettings[option] = nativeValue
 
 	if option == "colorscheme" {
-		LoadSyntaxFiles()
+		// LoadSyntaxFiles()
+		InitColorscheme()
 		for _, tab := range tabs {
 			for _, view := range tab.views {
 				view.Buf.UpdateRules()
-				if view.Buf.Settings["syntax"].(bool) {
-					view.matches = Match(view)
-				}
 			}
 		}
 	}
@@ -341,16 +362,31 @@ func SetLocalOption(option, value string, view *View) error {
 
 	if option == "statusline" {
 		view.ToggleStatusLine()
-		if buf.Settings["syntax"].(bool) {
-			view.matches = Match(view)
-		}
 	}
 
 	if option == "filetype" {
-		LoadSyntaxFiles()
+		// LoadSyntaxFiles()
+		InitColorscheme()
 		buf.UpdateRules()
-		if buf.Settings["syntax"].(bool) {
-			view.matches = Match(view)
+	}
+
+	if option == "fileformat" {
+		buf.IsModified = true
+	}
+
+	if option == "syntax" {
+		if !nativeValue.(bool) {
+			buf.ClearMatches()
+		} else {
+			buf.highlighter.HighlightStates(buf)
+		}
+	}
+
+	if option == "mouse" {
+		if !nativeValue.(bool) {
+			screen.DisableMouse()
+		} else {
+			screen.EnableMouse()
 		}
 	}
 
@@ -426,3 +462,17 @@ func validateColorscheme(option string, value interface{}) error {
 
 	return nil
 }
+
+func validateLineEnding(option string, value interface{}) error {
+	endingType, ok := value.(string)
+
+	if !ok {
+		return errors.New("Expected string type for file format")
+	}
+
+	if endingType != "unix" && endingType != "dos" {
+		return errors.New("File format must be either 'unix' or 'dos'")
+	}
+
+	return nil
+}

cmd/micro/split_tree.go

@@ -1,6 +1,6 @@
 package main
 
-// SpltType specifies whether a split is horizontal or vertical
+// SplitType specifies whether a split is horizontal or vertical
 type SplitType bool
 
 const (
@@ -255,7 +255,6 @@ func (s *SplitTree) ResizeSplits() {
 			}
 
 			n.view.ToggleTabbar()
-			n.view.matches = Match(n.view)
 		} else if n, ok := node.(*SplitTree); ok {
 			if s.kind == VerticalSplit {
 				if !n.lockWidth {

cmd/micro/statusline.go

@@ -36,6 +36,8 @@ func (sline *Statusline) Display() {
 	// Add the filetype
 	file += " " + sline.view.Buf.FileType()
 
+	file += " " + sline.view.Buf.Settings["fileformat"].(string)
+
 	rightText := ""
 	if len(helpBinding) > 0 {
 		rightText = helpBinding + " for help "

cmd/micro/tab.go

@@ -6,6 +6,8 @@ import (
 	"github.com/zyedidia/tcell"
 )
 
+var tabBarOffset int
+
 type Tab struct {
 	// This contains all the views in this tab
 	// There is generally only one view per tab, but you can have
@@ -87,13 +89,17 @@ func TabbarString() (string, map[int]int) {
 		} else {
 			str += " "
 		}
-		str += t.views[t.CurView].Buf.GetName()
+		buf := t.views[t.CurView].Buf
+		str += buf.GetName()
+		if buf.IsModified {
+			str += " +"
+		}
 		if i == curTab {
 			str += "]"
 		} else {
 			str += " "
 		}
-		indicies[len(str)-1] = i + 1
+		indicies[Count(str)-1] = i + 1
 		str += " "
 	}
 	return str, indicies
@@ -118,7 +124,7 @@ func TabbarHandleMouseEvent(event tcell.Event) bool {
 				return false
 			}
 			str, indicies := TabbarString()
-			if x >= len(str) {
+			if x+tabBarOffset >= len(str) {
 				return false
 			}
 			var tabnum int
@@ -128,7 +134,7 @@ func TabbarHandleMouseEvent(event tcell.Event) bool {
 			}
 			sort.Ints(keys)
 			for _, k := range keys {
-				if x <= k {
+				if x+tabBarOffset <= k {
 					tabnum = indicies[k] - 1
 					break
 				}
@@ -147,7 +153,7 @@ func DisplayTabs() {
 		return
 	}
 
-	str, _ := TabbarString()
+	str, indicies := TabbarString()
 
 	tabBarStyle := defStyle.Reverse(true)
 	if style, ok := colorscheme["tabbar"]; ok {
@@ -157,6 +163,98 @@ func DisplayTabs() {
 	// Maybe there is a unicode filename?
 	fileRunes := []rune(str)
 	w, _ := screen.Size()
+	tooWide := (w < len(fileRunes))
+
+	// if the entire tab-bar is longer than the screen is wide,
+	// then it should be truncated appropriately to keep the
+	// active tab visible on the UI.
+	if tooWide == true {
+		// first we have to work out where the selected tab is
+		// out of the total length of the tab bar. this is done
+		// by extracting the hit-areas from the indicies map
+		// that was constructed by `TabbarString()`
+		var keys []int
+		for offset := range indicies {
+			keys = append(keys, offset)
+		}
+		// sort them to be in ascending order so that values will
+		// correctly reflect the displayed ordering of the tabs
+		sort.Ints(keys)
+		// record the offset of each tab and the previous tab so
+		// we can find the position of the tab's hit-box.
+		previousTabOffset := 0
+		currentTabOffset := 0
+		for _, k := range keys {
+			tabIndex := indicies[k] - 1
+			if tabIndex == curTab {
+				currentTabOffset = k
+				break
+			}
+			// this is +2 because there are two padding spaces that aren't accounted
+			// for in the display. please note that this is for cosmetic purposes only.
+			previousTabOffset = k + 2
+		}
+		// get the width of the hitbox of the active tab, from there calculate the offsets
+		// to the left and right of it to approximately center it on the tab bar display.
+		centeringOffset := (w - (currentTabOffset - previousTabOffset))
+		leftBuffer := previousTabOffset - (centeringOffset / 2)
+		rightBuffer := currentTabOffset + (centeringOffset / 2)
+
+		// check to make sure we haven't overshot the bounds of the string,
+		// if we have, then take that remainder and put it on the left side
+		overshotRight := rightBuffer - len(fileRunes)
+		if overshotRight > 0 {
+			leftBuffer = leftBuffer + overshotRight
+		}
+
+		overshotLeft := leftBuffer - 0
+		if overshotLeft < 0 {
+			leftBuffer = 0
+			rightBuffer = leftBuffer + (w - 1)
+		} else {
+			rightBuffer = leftBuffer + (w - 2)
+		}
+
+		if rightBuffer > len(fileRunes)-1 {
+			rightBuffer = len(fileRunes) - 1
+		}
+
+		// construct a new buffer of text to put the
+		// newly formatted tab bar text into.
+		var displayText []rune
+
+		// if the left-side of the tab bar isn't at the start
+		// of the constructed tab bar text, then show that are
+		// more tabs to the left by displaying a "+"
+		if leftBuffer != 0 {
+			displayText = append(displayText, '+')
+		}
+		// copy the runes in from the original tab bar text string
+		// into the new display buffer
+		for x := leftBuffer; x < rightBuffer; x++ {
+			displayText = append(displayText, fileRunes[x])
+		}
+		// if there is more text to the right of the right-most
+		// column in the tab bar text, then indicate there are more
+		// tabs to the right by displaying a "+"
+		if rightBuffer < len(fileRunes)-1 {
+			displayText = append(displayText, '+')
+		}
+
+		// now store the offset from zero of the left-most text
+		// that is being displayed. This is to ensure that when
+		// clicking on the tab bar, the correct tab gets selected.
+		tabBarOffset = leftBuffer
+
+		// use the constructed buffer as the display buffer to print
+		// onscreen.
+		fileRunes = displayText
+	} else {
+		tabBarOffset = 0
+	}
+
+	// iterate over the width of the terminal display and for each column,
+	// write a character into the tab display area with the appropriate style.
 	for x := 0; x < w; x++ {
 		if x < len(fileRunes) {
 			screen.SetContent(x, 0, fileRunes[x], nil, tabBarStyle)

cmd/micro/util.go

@@ -36,11 +36,7 @@ func NumOccurrences(s string, c byte) int {
 
 // Spaces returns a string with n spaces
 func Spaces(n int) string {
-	var str string
-	for i := 0; i < n; i++ {
-		str += " "
-	}
-	return str
+	return strings.Repeat(" ", n)
 }
 
 // Min takes the min of two ints
@@ -59,6 +55,12 @@ func Max(a, b int) int {
 	return b
 }
 
+func FSize(f *os.File) int64 {
+	fi, _ := f.Stat()
+	// get the size
+	return fi.Size()
+}
+
 // IsWordChar returns whether or not the string is a 'word character'
 // If it is a unicode character, then it does not match
 // Word characters are defined as [A-Za-z0-9_]
@@ -76,6 +78,16 @@ func IsWhitespace(c rune) bool {
 	return c == ' ' || c == '\t' || c == '\n'
 }
 
+// IsStrWhitespace returns true if the given string is all whitespace
+func IsStrWhitespace(str string) bool {
+	for _, c := range str {
+		if !IsWhitespace(c) {
+			return false
+		}
+	}
+	return true
+}
+
 // Contains returns whether or not a string array contains a given string
 func Contains(list []string, a string) bool {
 	for _, b := range list {
@@ -251,11 +263,16 @@ func Abs(n int) int {
 	return n
 }
 
-// FuncName returns the name of a given function object
+// FuncName returns the full name of a given function object
 func FuncName(i interface{}) string {
 	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
 }
 
+// ShortFuncName returns the name only of a given function object
+func ShortFuncName(i interface{}) string {
+	return strings.TrimPrefix(runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name(), "main.(*View).")
+}
+
 // SplitCommandArgs separates multiple command arguments which may be quoted.
 // The returned slice contains at least one string
 func SplitCommandArgs(input string) []string {

cmd/micro/view.go

@@ -6,17 +6,21 @@ import (
 	"strings"
 	"time"
 
-	"github.com/mattn/go-runewidth"
 	"github.com/mitchellh/go-homedir"
 	"github.com/zyedidia/tcell"
 )
 
-type ViewType int
+type ViewType struct {
+	kind     int
+	readonly bool // The file cannot be edited
+	scratch  bool // The file cannot be saved
+}
 
-const (
-	vtDefault ViewType = iota
-	vtHelp
-	vtLog
+var (
+	vtDefault = ViewType{0, false, false}
+	vtHelp    = ViewType{1, true, true}
+	vtLog     = ViewType{2, true, true}
+	vtScratch = ViewType{3, false, true}
 )
 
 // The View struct stores information about a view into a buffer.
@@ -84,8 +88,7 @@ type View struct {
 	// Same here, just to keep track for mouse move events
 	tripleClick bool
 
-	// Syntax highlighting matches
-	matches SyntaxMatches
+	cellview *CellView
 
 	splitNode *LeafNode
 }
@@ -105,6 +108,7 @@ func NewViewWidthHeight(buf *Buffer, w, h int) *View {
 
 	v.Width = w
 	v.Height = h
+	v.cellview = new(CellView)
 
 	v.ToggleTabbar()
 
@@ -165,7 +169,7 @@ func (v *View) paste(clip string) {
 	}
 	clip = strings.Replace(clip, "\n", "\n"+leadingWS, -1)
 	v.Buf.Insert(v.Cursor.Loc, clip)
-	v.Cursor.Loc = v.Cursor.Loc.Move(Count(clip), v.Buf)
+	// v.Cursor.Loc = v.Cursor.Loc.Move(Count(clip), v.Buf)
 	v.freshClip = false
 	messenger.Message("Pasted clipboard")
 }
@@ -183,9 +187,9 @@ func (v *View) ScrollUp(n int) {
 // ScrollDown scrolls the view down n lines (if possible)
 func (v *View) ScrollDown(n int) {
 	// Try to scroll by n but if it would overflow, scroll by 1
-	if v.Topline+n <= v.Buf.NumLines-v.Height {
+	if v.Topline+n <= v.Buf.NumLines {
 		v.Topline += n
-	} else if v.Topline < v.Buf.NumLines-v.Height {
+	} else if v.Topline < v.Buf.NumLines-1 {
 		v.Topline++
 	}
 }
@@ -195,18 +199,19 @@ func (v *View) ScrollDown(n int) {
 // causing them to lose the unsaved changes
 func (v *View) CanClose() bool {
 	if v.Type == vtDefault && v.Buf.IsModified {
-		var char rune
+		var choice bool
 		var canceled bool
 		if v.Buf.Settings["autosave"].(bool) {
-			char = 'y'
+			choice = true
 		} else {
-			char, canceled = messenger.LetterPrompt("Save changes to "+v.Buf.GetName()+" before closing? (y,n,esc) ", 'y', 'n')
+			choice, canceled = messenger.YesNoPrompt("Save changes to " + v.Buf.GetName() + " before closing? (y,n,esc) ")
 		}
 		if !canceled {
-			if char == 'y' {
+			//if char == 'y' {
+			if choice {
 				v.Save(true)
 				return true
-			} else if char == 'n' {
+			} else {
 				return true
 			}
 		}
@@ -230,8 +235,6 @@ func (v *View) OpenBuffer(buf *Buffer) {
 	v.Center(false)
 	v.messages = make(map[string][]GutterMessage)
 
-	v.matches = Match(v)
-
 	// Set mouseReleased to true because we assume the mouse is not being pressed when
 	// the editor is opened
 	v.mouseReleased = true
@@ -243,15 +246,22 @@ func (v *View) Open(filename string) {
 	home, _ := homedir.Dir()
 	filename = strings.Replace(filename, "~", home, 1)
 	file, err := os.Open(filename)
+	fileInfo, _ := os.Stat(filename)
+
+	if err == nil && fileInfo.IsDir() {
+		messenger.Error(filename, " is a directory")
+		return
+	}
+
 	defer file.Close()
 
 	var buf *Buffer
 	if err != nil {
 		messenger.Message(err.Error())
 		// File does not exist -- create an empty buffer with that name
-		buf = NewBuffer(strings.NewReader(""), filename)
+		buf = NewBufferFromString("", filename)
 	} else {
-		buf = NewBuffer(file, filename)
+		buf = NewBuffer(file, FSize(file), filename)
 	}
 	v.OpenBuffer(buf)
 }
@@ -269,7 +279,6 @@ func (v *View) ReOpen() {
 		screen.Clear()
 		v.Buf.ReOpen()
 		v.Relocate()
-		v.matches = Match(v)
 	}
 }
 
@@ -441,6 +450,45 @@ func (v *View) MoveToMouseClick(x, y int) {
 	v.Cursor.LastVisualX = v.Cursor.GetVisualX()
 }
 
+func (v *View) ExecuteActions(actions []func(*View, bool) bool) bool {
+	relocate := false
+	readonlyBindingsList := []string{"Delete", "Insert", "Backspace", "Cut", "Play", "Paste", "Move", "Add", "DuplicateLine", "Macro"}
+	for _, action := range actions {
+		readonlyBindingsResult := false
+		funcName := ShortFuncName(action)
+		if v.Type.readonly == true {
+			// check for readonly and if true only let key bindings get called if they do not change the contents.
+			for _, readonlyBindings := range readonlyBindingsList {
+				if strings.Contains(funcName, readonlyBindings) {
+					readonlyBindingsResult = true
+				}
+			}
+		}
+		if !readonlyBindingsResult {
+			// call the key binding
+			relocate = action(v, true) || relocate
+			// Macro
+			if funcName != "ToggleMacro" && funcName != "PlayMacro" {
+				if recordingMacro {
+					curMacro = append(curMacro, action)
+				}
+			}
+		}
+	}
+
+	return relocate
+}
+
+func (v *View) SetCursor(c *Cursor) bool {
+	if c == nil {
+		return false
+	}
+	v.Cursor = c
+	v.Buf.curCursor = c.Num
+
+	return true
+}
+
 // HandleEvent handles an event passed by the main loop
 func (v *View) HandleEvent(event tcell.Event) {
 	// This bool determines whether the view is relocated at the end of the function
@@ -450,129 +498,112 @@ func (v *View) HandleEvent(event tcell.Event) {
 	v.Buf.CheckModTime()
 
 	switch e := event.(type) {
-	case *tcell.EventResize:
-		// Window resized
-		tabs[v.TabNum].Resize()
 	case *tcell.EventKey:
 		// Check first if input is a key binding, if it is we 'eat' the input and don't insert a rune
 		isBinding := false
-		if e.Key() != tcell.KeyRune || e.Modifiers() != 0 {
-			for key, actions := range bindings {
-				if e.Key() == key.keyCode {
-					if e.Key() == tcell.KeyRune {
-						if e.Rune() != key.r {
-							continue
-						}
+		for key, actions := range bindings {
+			if e.Key() == key.keyCode {
+				if e.Key() == tcell.KeyRune {
+					if e.Rune() != key.r {
+						continue
 					}
-					if e.Modifiers() == key.modifiers {
+				}
+				if e.Modifiers() == key.modifiers {
+					for _, c := range v.Buf.cursors {
+						ok := v.SetCursor(c)
+						if !ok {
+							break
+						}
 						relocate = false
 						isBinding = true
-						for _, action := range actions {
-							relocate = action(v, true) || relocate
-							funcName := FuncName(action)
-							if funcName != "main.(*View).ToggleMacro" && funcName != "main.(*View).PlayMacro" {
-								if recordingMacro {
-									curMacro = append(curMacro, action)
-								}
-							}
-						}
-						break
+						relocate = v.ExecuteActions(actions) || relocate
 					}
+					v.SetCursor(&v.Buf.Cursor)
+					v.Buf.MergeCursors()
+					break
 				}
 			}
 		}
 		if !isBinding && e.Key() == tcell.KeyRune {
-			// Insert a character
-			if v.Cursor.HasSelection() {
-				v.Cursor.DeleteSelection()
-				v.Cursor.ResetSelection()
-			}
-			v.Buf.Insert(v.Cursor.Loc, string(e.Rune()))
-			v.Cursor.Right()
+			// Check viewtype if readonly don't insert a rune (readonly help and log view etc.)
+			if v.Type.readonly == false {
+				for _, c := range v.Buf.cursors {
+					v.SetCursor(c)
 
-			for pl := range loadedPlugins {
-				_, err := Call(pl+".onRune", string(e.Rune()), v)
-				if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-					TermMessage(err)
+					// Insert a character
+					if v.Cursor.HasSelection() {
+						v.Cursor.DeleteSelection()
+						v.Cursor.ResetSelection()
+					}
+					v.Buf.Insert(v.Cursor.Loc, string(e.Rune()))
+
+					for pl := range loadedPlugins {
+						_, err := Call(pl+".onRune", string(e.Rune()), v)
+						if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
+							TermMessage(err)
+						}
+					}
+
+					if recordingMacro {
+						curMacro = append(curMacro, e.Rune())
+					}
 				}
-			}
-
-			if recordingMacro {
-				curMacro = append(curMacro, e.Rune())
+				v.SetCursor(&v.Buf.Cursor)
 			}
 		}
 	case *tcell.EventPaste:
-		if !PreActionCall("Paste", v) {
-			break
+		// Check viewtype if readonly don't paste (readonly help and log view etc.)
+		if v.Type.readonly == false {
+			if !PreActionCall("Paste", v) {
+				break
+			}
+
+			for _, c := range v.Buf.cursors {
+				v.SetCursor(c)
+				v.paste(e.Text())
+			}
+			v.SetCursor(&v.Buf.Cursor)
+
+			PostActionCall("Paste", v)
 		}
-
-		v.paste(e.Text())
-
-		PostActionCall("Paste", v)
 	case *tcell.EventMouse:
-		x, y := e.Position()
-		x -= v.lineNumOffset - v.leftCol + v.x
-		y += v.Topline - v.y
 		// Don't relocate for mouse events
 		relocate = false
 
 		button := e.Buttons()
 
-		switch button {
-		case tcell.Button1:
-			// Left click
-			if v.mouseReleased {
-				v.MoveToMouseClick(x, y)
-				if time.Since(v.lastClickTime)/time.Millisecond < doubleClickThreshold {
-					if v.doubleClick {
-						// Triple click
-						v.lastClickTime = time.Now()
-
-						v.tripleClick = true
-						v.doubleClick = false
-
-						v.Cursor.SelectLine()
-						v.Cursor.CopySelection("primary")
-					} else {
-						// Double click
-						v.lastClickTime = time.Now()
-
-						v.doubleClick = true
-						v.tripleClick = false
-
-						v.Cursor.SelectWord()
-						v.Cursor.CopySelection("primary")
+		for key, actions := range bindings {
+			if button == key.buttons && e.Modifiers() == key.modifiers {
+				for _, c := range v.Buf.cursors {
+					ok := v.SetCursor(c)
+					if !ok {
+						break
 					}
-				} else {
-					v.doubleClick = false
-					v.tripleClick = false
-					v.lastClickTime = time.Now()
-
-					v.Cursor.OrigSelection[0] = v.Cursor.Loc
-					v.Cursor.CurSelection[0] = v.Cursor.Loc
-					v.Cursor.CurSelection[1] = v.Cursor.Loc
+					relocate = v.ExecuteActions(actions) || relocate
 				}
-				v.mouseReleased = false
-			} else if !v.mouseReleased {
-				v.MoveToMouseClick(x, y)
-				if v.tripleClick {
-					v.Cursor.AddLineToSelection()
-				} else if v.doubleClick {
-					v.Cursor.AddWordToSelection()
-				} else {
-					v.Cursor.SetSelectionEnd(v.Cursor.Loc)
-					v.Cursor.CopySelection("primary")
+				v.SetCursor(&v.Buf.Cursor)
+				v.Buf.MergeCursors()
+			}
+		}
+
+		for key, actions := range mouseBindings {
+			if button == key.buttons && e.Modifiers() == key.modifiers {
+				for _, action := range actions {
+					action(v, true, e)
 				}
 			}
-		case tcell.Button2:
-			// Middle mouse button was clicked,
-			// We should paste primary
-			v.PastePrimary(true)
+		}
+
+		switch button {
 		case tcell.ButtonNone:
 			// Mouse event with no click
 			if !v.mouseReleased {
 				// Mouse was just released
 
+				x, y := e.Position()
+				x -= v.lineNumOffset - v.leftCol + v.x
+				y += v.Topline - v.y
+
 				// Relocating here isn't really necessary because the cursor will
 				// be in the right place from the last mouse event
 				// However, if we are running in a terminal that doesn't support mouse motion
@@ -586,22 +617,24 @@ func (v *View) HandleEvent(event tcell.Event) {
 				}
 				v.mouseReleased = true
 			}
-		case tcell.WheelUp:
-			// Scroll up
-			scrollspeed := int(v.Buf.Settings["scrollspeed"].(float64))
-			v.ScrollUp(scrollspeed)
-		case tcell.WheelDown:
-			// Scroll down
-			scrollspeed := int(v.Buf.Settings["scrollspeed"].(float64))
-			v.ScrollDown(scrollspeed)
 		}
 	}
 
 	if relocate {
 		v.Relocate()
+		// We run relocate again because there's a bug with relocating with softwrap
+		// when for example you jump to the bottom of the buffer and it tries to
+		// calculate where to put the topline so that the bottom line is at the bottom
+		// of the terminal and it runs into problems with visual lines vs real lines.
+		// This is (hopefully) a temporary solution
+		v.Relocate()
 	}
 }
 
+func (v *View) mainCursor() bool {
+	return v.Buf.curCursor == len(v.Buf.cursors)-1
+}
+
 // GutterMessage creates a message in this view's gutter
 func (v *View) GutterMessage(section string, lineN int, msg string, kind int) {
 	lineN--
@@ -638,7 +671,7 @@ func (v *View) openHelp(helpPage string) {
 	if data, err := FindRuntimeFile(RTHelp, helpPage).Data(); err != nil {
 		TermMessage("Unable to load help text", helpPage, "\n", err)
 	} else {
-		helpBuffer := NewBuffer(strings.NewReader(string(data)), helpPage+".md")
+		helpBuffer := NewBufferFromString(string(data), helpPage+".md")
 		helpBuffer.name = "Help"
 
 		if v.Type == vtHelp {
@@ -650,34 +683,23 @@ func (v *View) openHelp(helpPage string) {
 	}
 }
 
-func (v *View) drawCell(x, y int, ch rune, combc []rune, style tcell.Style) {
-	if x >= v.x && x < v.x+v.Width && y >= v.y && y < v.y+v.Height {
-		screen.SetContent(x, y, ch, combc, style)
-	}
-}
-
-// DisplayView renders the view to the screen
 func (v *View) DisplayView() {
+	if v.Buf.Settings["softwrap"].(bool) && v.leftCol != 0 {
+		v.leftCol = 0
+	}
+
 	if v.Type == vtLog {
 		// Log views should always follow the cursor...
 		v.Relocate()
 	}
 
-	if v.Buf.Settings["syntax"].(bool) {
-		v.matches = Match(v)
-	}
-
-	// The charNum we are currently displaying
-	// starts at the start of the viewport
-	charNum := Loc{0, v.Topline}
-
-	// Convert the length of buffer to a string, and get the length of the string
-	// We are going to have to offset by that amount
-	maxLineLength := len(strconv.Itoa(v.Buf.NumLines))
+	// We need to know the string length of the largest line number
+	// so we can pad appropriately when displaying line numbers
+	maxLineNumLength := len(strconv.Itoa(v.Buf.NumLines))
 
 	if v.Buf.Settings["ruler"] == true {
 		// + 1 for the little space after the line number
-		v.lineNumOffset = maxLineLength + 1
+		v.lineNumOffset = maxLineNumLength + 1
 	} else {
 		v.lineNumOffset = 0
 	}
@@ -693,44 +715,52 @@ func (v *View) DisplayView() {
 		v.lineNumOffset += 2
 	}
 
+	divider := 0
 	if v.x != 0 {
 		// One space for the extra split divider
 		v.lineNumOffset++
+		divider = 1
 	}
 
-	// These represent the current screen coordinates
-	screenX, screenY := v.x, v.y-1
+	xOffset := v.x + v.lineNumOffset
+	yOffset := v.y
 
-	highlightStyle := defStyle
-	curLineN := 0
+	height := v.Height
+	width := v.Width
+	left := v.leftCol
+	top := v.Topline
 
-	// ViewLine is the current line from the top of the viewport
-	for viewLine := 0; viewLine < v.Height; viewLine++ {
-		screenY++
-		screenX = v.x
+	v.cellview.Draw(v.Buf, top, height, left, width-v.lineNumOffset)
 
-		// This is the current line number of the buffer that we are drawing
-		curLineN = viewLine + v.Topline
-
-		if screenY-v.y >= v.Height {
-			break
+	screenX := v.x
+	realLineN := top - 1
+	visualLineN := 0
+	var line []*Char
+	for visualLineN, line = range v.cellview.lines {
+		var firstChar *Char
+		if len(line) > 0 {
+			firstChar = line[0]
 		}
 
-		if v.x != 0 {
-			// Draw the split divider
-			v.drawCell(screenX, screenY, '|', nil, defStyle.Reverse(true))
-			screenX++
-		}
-
-		// If the buffer is smaller than the view height we have to clear all this space
-		if curLineN >= v.Buf.NumLines {
-			for i := screenX; i < v.x+v.Width; i++ {
-				v.drawCell(i, screenY, ' ', nil, defStyle)
+		var softwrapped bool
+		if firstChar != nil {
+			if firstChar.realLoc.Y == realLineN {
+				softwrapped = true
 			}
-
-			continue
+			realLineN = firstChar.realLoc.Y
+		} else {
+			realLineN++
 		}
-		line := v.Buf.Line(curLineN)
+
+		colorcolumn := int(v.Buf.Settings["colorcolumn"].(float64))
+		if colorcolumn != 0 {
+			style := GetColor("color-column")
+			fg, _, _ := style.Decompose()
+			st := defStyle.Background(fg)
+			screen.SetContent(xOffset+colorcolumn, yOffset+visualLineN, ' ', nil, st)
+		}
+
+		screenX = v.x
 
 		// If there are gutter messages we need to display the '>>' symbol here
 		if hasGutterMessages {
@@ -738,7 +768,7 @@ func (v *View) DisplayView() {
 			msgOnLine := false
 			for k := range v.messages {
 				for _, msg := range v.messages[k] {
-					if msg.lineNum == curLineN {
+					if msg.lineNum == realLineN {
 						msgOnLine = true
 						gutterStyle := defStyle
 						switch msg.kind {
@@ -755,11 +785,11 @@ func (v *View) DisplayView() {
 								gutterStyle = style
 							}
 						}
-						v.drawCell(screenX, screenY, '>', nil, gutterStyle)
+						screen.SetContent(screenX, yOffset+visualLineN, '>', nil, gutterStyle)
 						screenX++
-						v.drawCell(screenX, screenY, '>', nil, gutterStyle)
+						screen.SetContent(screenX, yOffset+visualLineN, '>', nil, gutterStyle)
 						screenX++
-						if v.Cursor.Y == curLineN && !messenger.hasPrompt {
+						if v.Cursor.Y == realLineN && !messenger.hasPrompt {
 							messenger.Message(msg.msg)
 							messenger.gutterMessage = true
 						}
@@ -768,11 +798,11 @@ func (v *View) DisplayView() {
 			}
 			// If there is no message on this line we just display an empty offset
 			if !msgOnLine {
-				v.drawCell(screenX, screenY, ' ', nil, defStyle)
+				screen.SetContent(screenX, yOffset+visualLineN, ' ', nil, defStyle)
 				screenX++
-				v.drawCell(screenX, screenY, ' ', nil, defStyle)
+				screen.SetContent(screenX, yOffset+visualLineN, ' ', nil, defStyle)
 				screenX++
-				if v.Cursor.Y == curLineN && messenger.gutterMessage {
+				if v.Cursor.Y == realLineN && messenger.gutterMessage {
 					messenger.Reset()
 					messenger.gutterMessage = false
 				}
@@ -786,202 +816,177 @@ func (v *View) DisplayView() {
 				lineNumStyle = style
 			}
 			if style, ok := colorscheme["current-line-number"]; ok {
-				if curLineN == v.Cursor.Y && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() {
+				if realLineN == v.Cursor.Y && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() {
 					lineNumStyle = style
 				}
 			}
 
-			lineNum := strconv.Itoa(curLineN + 1)
+			lineNum := strconv.Itoa(realLineN + 1)
 
 			// Write the spaces before the line number if necessary
-			for i := 0; i < maxLineLength-len(lineNum); i++ {
-				v.drawCell(screenX, screenY, ' ', nil, lineNumStyle)
+			for i := 0; i < maxLineNumLength-len(lineNum); i++ {
+				screen.SetContent(screenX+divider, yOffset+visualLineN, ' ', nil, lineNumStyle)
 				screenX++
 			}
-			// Write the actual line number
-			for _, ch := range lineNum {
-				v.drawCell(screenX, screenY, ch, nil, lineNumStyle)
-				screenX++
+			if softwrapped && visualLineN != 0 {
+				// Pad without the line number because it was written on the visual line before
+				for range lineNum {
+					screen.SetContent(screenX+divider, yOffset+visualLineN, ' ', nil, lineNumStyle)
+					screenX++
+				}
+			} else {
+				// Write the actual line number
+				for _, ch := range lineNum {
+					screen.SetContent(screenX+divider, yOffset+visualLineN, ch, nil, lineNumStyle)
+					screenX++
+				}
 			}
 
 			// Write the extra space
-			v.drawCell(screenX, screenY, ' ', nil, lineNumStyle)
+			screen.SetContent(screenX+divider, yOffset+visualLineN, ' ', nil, lineNumStyle)
 			screenX++
 		}
 
-		// Now we actually draw the line
-		colN := 0
-		strWidth := 0
-		tabSize := int(v.Buf.Settings["tabsize"].(float64))
-		for _, ch := range line {
-			if v.Buf.Settings["softwrap"].(bool) {
-				if screenX-v.x >= v.Width {
-					screenY++
+		var lastChar *Char
+		cursorSet := false
+		for _, char := range line {
+			if char != nil {
+				lineStyle := char.style
 
-					x := 0
-					if hasGutterMessages {
-						v.drawCell(v.x+x, screenY, ' ', nil, defStyle)
-						x++
-						v.drawCell(v.x+x, screenY, ' ', nil, defStyle)
-						x++
-					}
-					for i := 0; i < v.lineNumOffset; i++ {
-						screen.SetContent(v.x+i+x, screenY, ' ', nil, lineNumStyle)
-					}
-					screenX = v.x + v.lineNumOffset
-				}
-			}
-
-			if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN && colN == v.Cursor.X {
-				v.DisplayCursor(screenX-v.leftCol, screenY)
-			}
-
-			lineStyle := defStyle
-
-			if v.Buf.Settings["syntax"].(bool) {
-				// Syntax highlighting is enabled
-				highlightStyle = v.matches[viewLine][colN]
-			}
-
-			if v.Cursor.HasSelection() &&
-				(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
-					charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
-				// The current character is selected
-				lineStyle = defStyle.Reverse(true)
-
-				if style, ok := colorscheme["selection"]; ok {
-					lineStyle = style
-				}
-			} else {
-				lineStyle = highlightStyle
-			}
-
-			// We need to display the background of the linestyle with the correct color if cursorline is enabled
-			// and this is the current view and there is no selection on this line and the cursor is on this line
-			if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
-				if style, ok := colorscheme["cursor-line"]; ok {
+				colorcolumn := int(v.Buf.Settings["colorcolumn"].(float64))
+				if colorcolumn != 0 && char.visualLoc.X == colorcolumn {
+					style := GetColor("color-column")
 					fg, _, _ := style.Decompose()
 					lineStyle = lineStyle.Background(fg)
 				}
+
+				charLoc := char.realLoc
+				for _, c := range v.Buf.cursors {
+					v.SetCursor(c)
+					if v.Cursor.HasSelection() &&
+						(charLoc.GreaterEqual(v.Cursor.CurSelection[0]) && charLoc.LessThan(v.Cursor.CurSelection[1]) ||
+							charLoc.LessThan(v.Cursor.CurSelection[0]) && charLoc.GreaterEqual(v.Cursor.CurSelection[1])) {
+						// The current character is selected
+						lineStyle = defStyle.Reverse(true)
+
+						if style, ok := colorscheme["selection"]; ok {
+							lineStyle = style
+						}
+					}
+				}
+				v.SetCursor(&v.Buf.Cursor)
+
+				if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num &&
+					!v.Cursor.HasSelection() && v.Cursor.Y == realLineN {
+					style := GetColor("cursor-line")
+					fg, _, _ := style.Decompose()
+					lineStyle = lineStyle.Background(fg)
+				}
+
+				screen.SetContent(xOffset+char.visualLoc.X, yOffset+char.visualLoc.Y, char.drawChar, nil, lineStyle)
+
+				for i, c := range v.Buf.cursors {
+					v.SetCursor(c)
+					if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
+						v.Cursor.Y == char.realLoc.Y && v.Cursor.X == char.realLoc.X && (!cursorSet || i != 0) {
+						ShowMultiCursor(xOffset+char.visualLoc.X, yOffset+char.visualLoc.Y, i)
+						cursorSet = true
+					}
+				}
+				v.SetCursor(&v.Buf.Cursor)
+
+				lastChar = char
 			}
-
-			if ch == '\t' {
-				// If the character we are displaying is a tab, we need to do a bunch of special things
-
-				// First the user may have configured an `indent-char` to be displayed to show that this
-				// is a tab character
-				lineIndentStyle := defStyle
-				if style, ok := colorscheme["indent-char"]; ok && v.Buf.Settings["indentchar"].(string) != " " {
-					lineIndentStyle = style
-				}
-				if v.Cursor.HasSelection() &&
-					(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
-						charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
-
-					lineIndentStyle = defStyle.Reverse(true)
-
-					if style, ok := colorscheme["selection"]; ok {
-						lineIndentStyle = style
-					}
-				}
-				if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
-					if style, ok := colorscheme["cursor-line"]; ok {
-						fg, _, _ := style.Decompose()
-						lineIndentStyle = lineIndentStyle.Background(fg)
-					}
-				}
-				// Here we get the indent char
-				indentChar := []rune(v.Buf.Settings["indentchar"].(string))
-				if screenX-v.x-v.leftCol >= v.lineNumOffset {
-					v.drawCell(screenX-v.leftCol, screenY, indentChar[0], nil, lineIndentStyle)
-				}
-				// Now the tab has to be displayed as a bunch of spaces
-				visLoc := strWidth
-				remainder := tabSize - (visLoc % tabSize)
-				for i := 0; i < remainder-1; i++ {
-					screenX++
-					if screenX-v.x-v.leftCol >= v.lineNumOffset {
-						v.drawCell(screenX-v.leftCol, screenY, ' ', nil, lineStyle)
-					}
-				}
-				strWidth += remainder
-			} else if runewidth.RuneWidth(ch) > 1 {
-				if screenX-v.x-v.leftCol >= v.lineNumOffset {
-					v.drawCell(screenX, screenY, ch, nil, lineStyle)
-				}
-				for i := 0; i < runewidth.RuneWidth(ch)-1; i++ {
-					screenX++
-					if screenX-v.x-v.leftCol >= v.lineNumOffset {
-						v.drawCell(screenX-v.leftCol, screenY, '<', nil, lineStyle)
-					}
-				}
-				strWidth += StringWidth(string(ch), tabSize)
-			} else {
-				if screenX-v.x-v.leftCol >= v.lineNumOffset {
-					v.drawCell(screenX-v.leftCol, screenY, ch, nil, lineStyle)
-				}
-				strWidth += StringWidth(string(ch), tabSize)
-			}
-			charNum = charNum.Move(1, v.Buf)
-			screenX++
-			colN++
-		}
-		// Here we are at a newline
-
-		if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN && colN == v.Cursor.X {
-			v.DisplayCursor(screenX-v.leftCol, screenY)
 		}
 
-		// The newline may be selected, in which case we should draw the selection style
-		// with a space to represent it
+		lastX := 0
+		var realLoc Loc
+		var visualLoc Loc
+		var cx, cy int
+		if lastChar != nil {
+			lastX = xOffset + lastChar.visualLoc.X + lastChar.width
+			for i, c := range v.Buf.cursors {
+				v.SetCursor(c)
+				if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
+					v.Cursor.Y == lastChar.realLoc.Y && v.Cursor.X == lastChar.realLoc.X+1 {
+					ShowMultiCursor(lastX, yOffset+lastChar.visualLoc.Y, i)
+					cx, cy = lastX, yOffset+lastChar.visualLoc.Y
+				}
+			}
+			v.SetCursor(&v.Buf.Cursor)
+			realLoc = Loc{lastChar.realLoc.X + 1, realLineN}
+			visualLoc = Loc{lastX - xOffset, lastChar.visualLoc.Y}
+		} else if len(line) == 0 {
+			for i, c := range v.Buf.cursors {
+				v.SetCursor(c)
+				if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
+					v.Cursor.Y == realLineN {
+					ShowMultiCursor(xOffset, yOffset+visualLineN, i)
+					cx, cy = xOffset, yOffset+visualLineN
+				}
+			}
+			v.SetCursor(&v.Buf.Cursor)
+			lastX = xOffset
+			realLoc = Loc{0, realLineN}
+			visualLoc = Loc{0, visualLineN}
+		}
+
 		if v.Cursor.HasSelection() &&
-			(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
-				charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
-
+			(realLoc.GreaterEqual(v.Cursor.CurSelection[0]) && realLoc.LessThan(v.Cursor.CurSelection[1]) ||
+				realLoc.LessThan(v.Cursor.CurSelection[0]) && realLoc.GreaterEqual(v.Cursor.CurSelection[1])) {
+			// The current character is selected
 			selectStyle := defStyle.Reverse(true)
 
 			if style, ok := colorscheme["selection"]; ok {
 				selectStyle = style
 			}
-			v.drawCell(screenX, screenY, ' ', nil, selectStyle)
-			screenX++
+			screen.SetContent(xOffset+visualLoc.X, yOffset+visualLoc.Y, ' ', nil, selectStyle)
 		}
 
-		charNum = charNum.Move(1, v.Buf)
+		if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num &&
+			!v.Cursor.HasSelection() && v.Cursor.Y == realLineN {
+			for i := lastX; i < xOffset+v.Width-v.lineNumOffset; i++ {
+				style := GetColor("cursor-line")
+				fg, _, _ := style.Decompose()
+				style = style.Background(fg)
+				if !(tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && i == cx && yOffset+visualLineN == cy) {
+					screen.SetContent(i, yOffset+visualLineN, ' ', nil, style)
+				}
+			}
+		}
+	}
 
-		for i := 0; i < v.Width; i++ {
-			lineStyle := defStyle
-			if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
-				if style, ok := colorscheme["cursor-line"]; ok {
-					fg, _, _ := style.Decompose()
-					lineStyle = lineStyle.Background(fg)
-				}
-			}
-			if screenX-v.x-v.leftCol+i >= v.lineNumOffset {
-				colorcolumn := int(v.Buf.Settings["colorcolumn"].(float64))
-				if colorcolumn != 0 && screenX-v.lineNumOffset+i == colorcolumn-1 {
-					if style, ok := colorscheme["color-column"]; ok {
-						fg, _, _ := style.Decompose()
-						lineStyle = lineStyle.Background(fg)
-					}
-				}
-				v.drawCell(screenX-v.leftCol+i, screenY, ' ', nil, lineStyle)
-			}
+	if divider != 0 {
+		dividerStyle := defStyle
+		if style, ok := colorscheme["divider"]; ok {
+			dividerStyle = style
+		}
+		for i := 0; i < v.Height; i++ {
+			screen.SetContent(v.x, yOffset+i, '|', nil, dividerStyle.Reverse(true))
 		}
 	}
 }
 
-// DisplayCursor draws the current buffer's cursor to the screen
-func (v *View) DisplayCursor(x, y int) {
-	// screen.ShowCursor(v.x+v.Cursor.GetVisualX()+v.lineNumOffset-v.leftCol, y)
-	screen.ShowCursor(x, y)
+// ShowMultiCursor will display a cursor at a location
+// If i == 0 then the terminal cursor will be used
+// Otherwise a fake cursor will be drawn at the position
+func ShowMultiCursor(x, y, i int) {
+	if i == 0 {
+		screen.ShowCursor(x, y)
+	} else {
+		r, _, _, _ := screen.GetContent(x, y)
+		screen.SetContent(x, y, r, nil, defStyle.Reverse(true))
+	}
 }
 
 // Display renders the view, the cursor, and statusline
 func (v *View) Display() {
+	if globalSettings["termtitle"].(bool) {
+		screen.SetTitle("micro: " + v.Buf.GetName())
+	}
 	v.DisplayView()
 	// Don't draw the cursor if it is out of the viewport or if it has a selection
-	if (v.Cursor.Y-v.Topline < 0 || v.Cursor.Y-v.Topline > v.Height-1) || v.Cursor.HasSelection() {
+	if v.Num == tabs[curTab].CurView && (v.Cursor.Y-v.Topline < 0 || v.Cursor.Y-v.Topline > v.Height-1 || v.Cursor.HasSelection()) {
 		screen.HideCursor()
 	}
 	_, screenH := screen.Size()

data/com.github.zyedidia.micro.metainfo.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component>
+  <id>com.github.zyedidia.micro</id>
+  <name>Micro Text Editor</name>
+  <summary>A modern and intuitive terminal-based text editor</summary>
+  <url type="homepage">https://micro-editor.github.io</url>
+  <url type="bugtracker">https://github.com/zyedidia/micro</url>
+  <metadata_license>MIT</metadata_license>
+   <categories>
+     <category>Development</category>
+	 <category>TextEditor</category>
+   </categories>
+
+  <provides>
+​    <binary>micro</binary>
+​  </provides>
+​  <releases>
+​    <release version="1.2.0" date="2017-05-28" />
+​  </releases>
+​  <developer_name>Zachary Yedidia</developer_name>
+  <screenshots>
+​  <screenshot type="default">
+​    <caption>Micro Text Editor editing its source code.</caption>
+​    <image type="source">https://raw.githubusercontent.com/zyedidia/micro/master/assets/micro-solarized.png</image>
+​  </screenshot>
+​ </screenshots>
+​</component>

runtime/README.md

@@ -1,5 +1,5 @@
 # Runtime files for Micro
 
 This directory will be embedded in the Go binary for portability, but it may just as well be put in `~/.config/micro`. If you would like to make your own colorschemes
-and syntax files, you can put in in `~/.config/micro/colorschemes` and `~/.config/micro/syntax` respectively.
+and syntax files, you can put them in `~/.config/micro/colorschemes` and `~/.config/micro/syntax` respectively.
 

runtime/colorschemes/atom-dark-tc.micro

@@ -4,7 +4,7 @@ color-link identifier "#F9EE98,#1D1F21"
 color-link constant "#FF73FD,#1D1F21"
 color-link constant.string "#A8FF60,#1D1F21"
 color-link statement "#96CBFE,#1D1F21"
-color-link symbol "#96CBFE,#1DF121"
+color-link symbol "#96CBFE,#1D1F21"
 color-link preproc "#62B1FE,#1D1F21"
 color-link type "#C6C5FE,#1D1F21"
 color-link special "#A6E22E,#1D1F21"
@@ -12,6 +12,7 @@ color-link underlined "#D33682,#1D1F21"
 color-link error "bold #FF4444,#1D1F21"
 color-link todo "bold #FF8844,#1D1F21"
 color-link statusline "#1D1F21,#C5C8C6"
+color-link tabbar "#1D1F21,#C5C8C6"
 color-link indent-char "#505050,#1D1F21"
 color-link line-number "#656866,#232526"
 color-link current-line-number "#656866,#1D1F21"
@@ -19,3 +20,7 @@ color-link gutter-error "#FF4444,#1D1F21"
 color-link gutter-warning "#EEEE77,#1D1F21"
 color-link cursor-line "#2D2F31"
 color-link color-column "#2D2F31"
+#color-link symbol.brackets "#96CBFE,#1D1F21"
+#No extended types (bool in C, etc.)
+#color-link type.extended "default"
+#Plain brackets

runtime/colorschemes/bubblegum.micro

@@ -12,10 +12,13 @@ color-link special "167,231"
 color-link error "231, 160"
 color-link underlined "underline 241,231"
 color-link todo "246,231"
-
 color-link statusline "241,254"
+color-link tabbar "241,254"
 color-link gutter-error "197,231"
 color-link gutter-warning "134,231"
 color-link line-number "246,254"
 color-link cursor-line "254"
 color-link color-column "254"
+#No extended types (bool in C, &c.) and plain brackets
+color-link type.extended "default"
+color-link symbol.brackets "default"

runtime/colorschemes/cmc-16.micro

@@ -0,0 +1,40 @@
+#CaptainMcClellan's personal color scheme.
+#16 colour version.
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.bool "bold cyan"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.string "yellow"
+color-link constant.string.url "underline blue, white"
+#color-link constant.number "constant"
+color-link constant.specialChar "bold magenta"
+color-link identifier "bold red"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+#color-link identifier.class "bold green"
+color-link identifier.class "bold white"
+color-link statement "bold yellow"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link symbol.tag "bold blue"
+color-link symbol.tag.extended "bold green"
+color-link preproc "bold cyan"
+color-link type "green"
+color-link type.keyword "bold green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "bold ,brightred"
+color-link todo "underline black,brightyellow"
+color-link indent-char ",brightgreen"
+color-link line-number "green"
+color-link line-number.scrollbar "green"
+color-link statusline "white,blue"
+color-link tabbar "white,blue"
+color-link current-line-number "red"
+color-link current-line-number.scroller "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "cyan"
+color-link underlined.url "underline blue, white"
+color-link divider "blue"

runtime/colorschemes/cmc-paper.micro

@@ -0,0 +1,37 @@
+#CaptainMcClellan's personal color scheme.
+#Paper version
+color-link default "black,white"
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.bool "bold cyan"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.string "bold yellow"
+color-link constant.string.url "underline blue, white"
+color-link constant.number "constant"
+color-link constant.specialChar "bold magenta"
+color-link identifier "bold red"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+color-link identifier.class "bold green"
+color-link preproc "bold cyan"
+color-link statement "bold yellow"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "green"
+color-link type.keyword "bold green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo "black,brightyellow"
+color-link indent-char ",brightgreen"
+color-link line-number "green"
+color-link line-number.scrollbar "green"
+color-link statusline "white,blue"
+color-link tabbar "white,blue"
+color-link current-line-number "red"
+color-link current-line-number.scroller "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "cyan"
+color-link underlined.url "underline blue, white"

runtime/colorschemes/cmc-tc.micro

@@ -0,0 +1,36 @@
+#CaptainMcClellan's personal colour scheme.
+#Full colour edition.
+color-link default "#aaaaaa,#1e2124"
+color-link comment "bold #555555"
+color-link constant "#008888"
+#color-link constant.string "#888800"
+color-link constant.string "#a85700"
+color-link constant.specialChar "bold #ccccff"
+color-link identifier "bold #e34234"
+color-link identifier.macro "bold #e34234"
+color-link identifier.var "bold #5757ff"
+color-link identifier.class "bold #ffffff"
+color-link statement "bold #ffff55"
+color-link symbol "#722f37"
+color-link symbol.brackets "#4169e1"
+color-link symbol.tag "#5757ff"
+color-link preproc "bold #55ffff"
+color-link type "#3eb489"
+color-link type.keyword "bold #bdecb6"
+color-link special "#b57edc"
+color-link ignore "default"
+color-link error "bold ,#e34234"
+color-link todo "bold underline #888888,#f26522"
+color-link indent-char ",#bdecb6"
+color-link line-number "#bdecb6,#36393e"
+color-link line-number.scrollbar "#3eb489"
+color-link statusline "#aaaaaa,#8a496b"
+color-link tabbar "#aaaaaa,#8a496b"
+color-link current-line-number "bold #e34234,#424549"
+color-link current-line-number.scroller "red"
+color-link gutter-error ",#e34234"
+color-link gutter-warning "#e34234"
+color-link color-column "#f26522"
+color-link constant.bool "bold #55ffff"
+color-link constant.bool.true "bold #85ff85"
+color-link constant.bool.false "bold #ff8585"

runtime/colorschemes/codeblocks-paper.micro

@@ -0,0 +1,25 @@
+#A colorscheme based on Code::Blocks IDE
+#but with a white background.
+color-link default "black,white"
+color-link comment "bold black"
+color-link constant "blue"
+color-link constant.number "bold magenta"
+color-link constant.string "bold blue"
+color-link identifier "black"
+color-link preproc "green"
+color-link statement "blue"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "blue"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "bold white,brightred"
+color-link todo "bold black,brightyellow"
+color-link indent-char "bold black"
+color-link line-number "black,white"
+color-link statusline "white,red"
+color-link tabbar "white,red"
+color-link current-line-number "red,black"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "black"

runtime/colorschemes/codeblocks.micro

@@ -0,0 +1,23 @@
+#Theme based on Code::Blocks IDE's default syntax highlighting.
+color-link comment "bold black"
+color-link constant "blue"
+color-link constant.string "bold blue"
+color-link constant.number "bold magenta"
+color-link identifier "default"
+color-link preproc "green"
+color-link statement "blue"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "blue"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo "bold black,brightyellow"
+color-link indent-char "bold black"
+color-link line-number "black,white"
+color-link statusline "white,red"
+color-link tabbar "white,red"
+color-link current-line-number "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "white"

runtime/colorschemes/darcula.micro

@@ -0,0 +1,27 @@
+color-link default "#CCCCCC,#242424"
+color-link comment "#707070,#242424"
+color-link identifier "#FFC66D,#242424"
+color-link constant "#7A9EC2,#242424"
+color-link constant.string "#6A8759,#242424"
+color-link constant.string.char "#6A8759,#242424"
+color-link statement "#CC8242,#242424"
+color-link symbol "#CCCCCC,#242424"
+color-link preproc "#CC8242,#242424"
+color-link type "#CC8242,#242424"
+color-link special "#CC8242,#242424"
+color-link underlined "#D33682,#242424"
+color-link error "bold #CB4B16,#242424"
+color-link todo "bold #D33682,#242424"
+color-link statusline "#242424,#CCCCCC"
+color-link tabbar "#242424,#CCCCCC"
+color-link indent-char "#4F4F4F,#242424"
+color-link line-number "#666666,#242424"
+color-link current-line-number "#666666,#242424"
+color-link gutter-error "#CB4B16,#242424"
+color-link gutter-warning "#E6DB74,#242424"
+color-link cursor-line "#2C2C2C"
+color-link color-column "#2C2C2C"
+#No extended types; Plain brackets.
+color-link type.extended "default"
+#color-link symbol.brackets "default"
+color-link symbol.tag "#AE81FF,#242424"

runtime/colorschemes/default.micro

@@ -1,4 +1,3 @@
-# This is the monokai colorscheme
 color-link default "#F8F8F2,#282828"
 color-link comment "#75715E,#282828"
 color-link identifier "#66D9EF,#282828"
@@ -14,6 +13,7 @@ color-link underlined "#D33682,#282828"
 color-link error "bold #CB4B16,#282828"
 color-link todo "bold #D33682,#282828"
 color-link statusline "#282828,#F8F8F2"
+color-link tabbar "#282828,#F8F8F2"
 color-link indent-char "#505050,#282828"
 color-link line-number "#AAAAAA,#323232"
 color-link current-line-number "#AAAAAA,#282828"
@@ -21,3 +21,7 @@ color-link gutter-error "#CB4B16,#282828"
 color-link gutter-warning "#E6DB74,#282828"
 color-link cursor-line "#323232"
 color-link color-column "#323232"
+#No extended types; Plain brackets.
+color-link type.extended "default"
+#color-link symbol.brackets "default"
+color-link symbol.tag "#AE81FF,#282828"

runtime/colorschemes/flamepoint-tc.micro

@@ -0,0 +1,30 @@
+#Flamepoint theme
+#By CaptainMcClellan
+color-link default ""
+color-link comment ""
+color-link constant ""
+color-link constant.bool ""
+color-link constant.bool.true ""
+color-link constant.bool.false ""
+color-link constant.number ""
+color-link constant.specialChar ""
+color-link constant.string ""
+color-link constant.string.url "underline"
+color-link identifier ""
+color-link identifier.var ""
+color-link preproc ""
+color-link special ""
+color-link statement ""
+color-link symbol ""
+color-link symbol.brackets ""
+color-link symbol.tag ""
+color-link type ""
+color-link type.keyword ""
+color-link error ""
+color-link todo ""
+color-link cursor-line "" 
+color-link statusline ""
+color-link tabbar ""
+color-link color-column ""
+color-link gutter-error ""
+color-link gutter-warning ""

runtime/colorschemes/funky-cactus-tc.micro

@@ -0,0 +1 @@
+#Funky Cactus theme in true colour.

runtime/colorschemes/funky-cactus.micro

@@ -0,0 +1,31 @@
+#Funky Cactus theme
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.bool "bold cyan"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.string "yellow"
+color-link constant.number "constant"
+color-link constant.specialChar "bold magenta"
+color-link identifier "bold red"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+color-link identifier.class "bold green"
+color-link preproc "bold cyan"
+color-link statement "bold yellow"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "green"
+color-link type.keyword "bold green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "bold ,brightred"
+color-link todo "underline ,brightyellow"
+color-link indent-char "bold ,brightgreen"
+color-link line-number "green"
+color-link statusline "black,green"
+color-link tabbar "black,magenta"
+color-link current-line-number "bold magenta" 
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "bold green"

runtime/colorschemes/gameboy-tc.micro

@@ -0,0 +1,23 @@
+#Gameboy theme
+color-link default "#3f3f3f,#bfc180"
+color-link comment "#7d7343"
+color-link constant "#7d7343"
+color-link identifier "#ddde7d"
+color-link preproc "#ddde7d,#7d7343"
+color-link special "#7d7343"
+color-link statement "#7d7343"
+color-link symbol "#7d7343"
+color-link type "#7d7343"
+color-link error "#ddde7d,#7d7343"
+color-link todo "#7d7343,#ddde7d"
+color-link statusline "#ddde7d,#7d7343"
+color-link tabbar "#ddde7d,#7d7343"
+color-link color-column "#7d7343"
+color-link line-number "#ddde7d,#7d7343"
+color-link current-line-number "#3f3f3f,#bfc180"
+color-link gutter-error "#ddde7d,#7d7343"
+color-link gutter-warning "default"
+#3f3f3f
+#7d7343
+#bfc180
+#ddde76

runtime/colorschemes/geany-alt-tc.micro

@@ -0,0 +1,21 @@
+#Geany Alternate theme
+color-link default "#000000,#fefefe"
+color-link comment "#808080"
+color-link constant "default"
+color-link constant.bool "#003030"
+color-link constant.number "#300008"
+color-link constant.string "#008000"
+color-link identifier "default"
+color-link preproc "#bbbb77"
+color-link special "#003030"
+color-link statement "#003030"
+color-link symbol "#300008"
+color-link symbol.tag "bold #4e9d71"
+color-link type "#003030"
+color-link error "#a52a2a"
+color-link todo "#ffa500"
+color-link line-number "#000000,#d0d0d0"
+color-link current-line-number "#000000,#d0d0d0"
+color-link color-column "#c2ebc2"
+color-link cursor-line "#f0f0f0"
+color-link type.extended "default"

runtime/colorschemes/geany.micro

@@ -0,0 +1,23 @@
+#Geany
+color-link comment "red"
+color-link constant "default"
+color-link constant.number
+color-link constant.string "bold yellow"
+color-link identifier "default"
+color-link preproc "cyan"
+color-link special "blue"
+color-link statement "blue"
+color-link symbol "default"
+color-link symbol.tag "bold blue"
+color-link type "blue"
+color-link type.extended "default"
+color-link error "red"
+color-link todo "bold cyan"
+color-link indent-char "bold black"
+color-link line-number ""
+color-link current-line-number ""
+color-link statusline "black,white"
+color-link tabbar "black,white"
+color-link color-column "bold geren"
+color-link gutter-error ",red"
+color-link gutter-warning "red"

runtime/colorschemes/github-tc.micro

@@ -0,0 +1,24 @@
+#True color theme based on Github's syntax highlighting.
+#Warning, this is based on how it rendered in my Firefox!
+#Yours may look different.
+color-link comment "bold #969896"
+color-link constant "#0086B9"
+color-link constant.number "#0086B9"
+color-link constant.specialChar "bold #1836BD"
+color-link constant.string "bold #1836BD"
+color-link constant.bool "#0086B9"
+color-link identifier "#A71D5D"
+color-link preproc "bold #A71D5D"
+color-link special "#A71D5D"
+color-link statement "#A71D5D"
+color-link symbol "default"
+color-link type "#A71D5D"
+color-link error "bold ,#E34234"
+color-link todo "white"
+color-link indent-char "default"
+color-link line-number "bold #969896"
+color-link current-line-number "bold #969896"
+color-link gutter-error "bold ,#E34234"
+color-link gutter-warning "bold #f26522"
+color-link statusline "bold #c8c9cb,#24292e"
+color-link tabbar "bold #c8c9cb,#24292e"

runtime/colorschemes/github.micro

@@ -0,0 +1,24 @@
+#Theme based on Github's syntax highlighting.
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.number "cyan"
+color-link constant.specialChar "bold blue"
+color-link constant.string "bold blue"
+color-link constant.bool "cyan"
+color-link identifier "magenta"
+color-link preproc "bold magenta"
+color-link special "magenta"
+color-link statement "magenta"
+color-link symbol "default"
+color-link type "magenta"
+color-link error "bold ,brightred"
+color-link todo "white"
+color-link indent-char "default"
+color-link line-number "bold black"
+color-link current-line-number "bold black"
+color-link gutter-error ",red"
+color-link gutter-warning "bold yellow"
+color-link statusline "bold white,black"
+color-link tabbar "bold white,black"
+#Plain brackets.
+#color-link symbol.brackets "default"

runtime/colorschemes/gruvbox-tc.micro

@@ -17,3 +17,5 @@ color-link line-number "#665c54,#282828"
 color-link current-line-number "#665c54,#3c3836"
 color-link cursor-line "#3c3836"
 color-link color-column "#79740e"
+color-link statusline "#ebdbb2,#665c54"
+color-link tabbar "#ebdbb2,#665c54"

runtime/colorschemes/gruvbox.micro

@@ -15,3 +15,5 @@ color-link line-number "243,237"
 color-link current-line-number "172,237"
 color-link cursor-line "237"
 color-link color-column "237"
+color-link statusline "223,237"
+color-link tabbar "223,237"

runtime/colorschemes/mc.micro

@@ -0,0 +1,25 @@
+#Midnight Commander inspired theme.
+color-link default "white,blue"
+color-link comment "bold black"
+color-link constant "bold white"
+color-link constant.string "bold yellow"
+color-link identifier "bold red"
+color-link statement "bold cyan"
+color-link symbol "white"
+color-link symbol.brackets "white"
+color-link symbol.tag "bold green"
+color-link preproc "black,cyan"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo ",brightyellow"
+color-link indent-char ",cyan"
+color-link line-number "green"
+color-link statusline "black,cyan"
+color-link tabbar "black,cyan"
+color-link current-line-number "black,cyan"
+color-link cursor-line "black,cyan"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "cyan"

runtime/colorschemes/monochrome-paper.micro

@@ -0,0 +1,5 @@
+#Monochrome Paper theme.
+#Edit your files on a white background without colors.
+color-link default "black,white"
+color-link statusline "white,black"
+color-link tabbar "white,black"

runtime/colorschemes/monochrome.micro

@@ -0,0 +1,3 @@
+#Monochrome
+#This makes micro use only the terminal's default
+# foreground and background colours.

runtime/colorschemes/monokai.micro

@@ -13,6 +13,7 @@ color-link underlined "#D33682,#282828"
 color-link error "bold #CB4B16,#282828"
 color-link todo "bold #D33682,#282828"
 color-link statusline "#282828,#F8F8F2"
+color-link tabbar "#282828,#F8F8F2"
 color-link indent-char "#505050,#282828"
 color-link line-number "#AAAAAA,#323232"
 color-link current-line-number "#AAAAAA,#282828"
@@ -20,3 +21,7 @@ color-link gutter-error "#CB4B16,#282828"
 color-link gutter-warning "#E6DB74,#282828"
 color-link cursor-line "#323232"
 color-link color-column "#323232"
+#No extended types; Plain brackets.
+color-link type.extended "default"
+#color-link symbol.brackets "default"
+color-link symbol.tag "#AE81FF,#282828"

runtime/colorschemes/nano.micro

@@ -0,0 +1,30 @@
+#Colorscheme styled after default Debian nano.
+color-link comment "bold blue"
+color-link comment.bright "cyan"
+color-link constant "red"
+color-link constant.bool "yellow"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.number "default"
+color-link constant.specialChar "bold magenta"
+color-link constant.string "bold yellow"
+color-link identifier "bold blue"
+color-link identifier.macro "bold red"
+color-link statement "bold green" 
+color-link symbol "green"
+#color-link symbol.tag "blue"
+color-link preproc "brightcyan"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "white,black"
+color-link todo "bold cyan"
+color-link indent-char ",green"
+color-link line-number "default"
+color-link current-line-number "default"
+color-link gutter-error ",white"
+color-link gutter-warning "white"
+color-link cursor-line "default"
+color-link color-column "white"
+#No extended types ( bool in C ); Plain brackets
+color-link type.extended "default"

runtime/colorschemes/nes-tc.micro

@@ -0,0 +1,30 @@
+#NES
+#A color theme only using NES pallette colours
+color-link default ""
+color-link comment ""
+color-link constant ""
+color-link constant.bool ""
+color-link constant.bool.true ""
+color-link constant.bool.false ""
+color-link constant.number ""
+color-link constant.specialChar ""
+color-link constant.string ""
+color-link constant.string.url "underline"
+color-link identifier ""
+color-link identifier.var ""
+color-link preproc ""
+color-link special ""
+color-link statement ""
+color-link symbol ""
+color-link symbol.brackets ""
+color-link symbol.tag ""
+color-link type ""
+color-link type.keyword ""
+color-link error ""
+color-link todo ""
+color-link cursor-line "" 
+color-link statusline ""
+color-link tabbar ""
+color-link color-column ""
+color-link gutter-error ""
+color-link gutter-warning ""

runtime/colorschemes/paper-tc.micro

@@ -0,0 +1,22 @@
+#Paper theme, true color edition
+#Edit on an *actual* white background!
+color-link default "#000000,#efefef"
+color-link comment ""
+color-link constant ""
+color-link constant.string ""
+color-link constant.string.url "underline #0000dd"
+color-link identifier "" 
+color-link identifier.var ""
+color-link special ""
+color-link statement ""
+color-link symbol ""
+color-link symbol.brackets ""
+color-link symbol.tag ""
+color-link type ""
+color-link statusline ""
+color-link tabbar ""
+color-link error ""
+color-link todo ""
+color-link color-column ""
+color-link gutter-error ""
+color-link gutter-warning ""

runtime/colorschemes/paper.micro

@@ -0,0 +1,27 @@
+#Paper theme, Edit on a white background.
+color-link default "black,white"
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.string "bold green"
+color-link identifier "blue"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+color-link identifier.class "bold green"
+color-link statement "green"
+color-link symbol "red"
+color-link symbol.brackets "default"
+color-link symbol.tag "bold blue"
+color-link preproc "bold cyan"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo ",brightyellow"
+color-link indent-char ",brightgreen"
+color-link line-number "black"
+color-link statusline "white,black"
+color-link tabbar "white,black"
+color-link current-line-number "blue"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "black"

runtime/colorschemes/simple.micro

@@ -14,5 +14,12 @@ color-link line-number "yellow"
 color-link current-line-number "red"
 color-link gutter-error ",red"
 color-link gutter-warning "red"
-color-link cursor-line "white"
+#Cursor line causes readability issues. Disabled for now.
+#color-link cursor-line "white,black"
 color-link color-column "white"
+#No extended types. (bool in C)
+color-link type.extended "default"
+#No bracket highlighting.
+color-link symbol.brackets "default"
+#Color shebangs the comment color
+color-link preproc.shebang "comment"

runtime/colorschemes/solarized-tc.micro

@@ -2,19 +2,23 @@ color-link default "#839496,#002833"
 color-link comment "#586E75,#002833"
 color-link identifier "#268BD2,#002833"
 color-link constant "#2AA198,#002833"
+color-link constant.specialChar "#DC322F,#002833"
 color-link statement "#859900,#002833"
 color-link symbol "#859900,#002833"
 color-link preproc "#CB4B16,#002833"
 color-link type "#B58900,#002833"
-color-link special "#DC322F,#002833"
+color-link special "#268BD2,#002833"
 color-link underlined "#D33682,#002833"
 color-link error "bold #CB4B16,#002833"
 color-link todo "bold #D33682,#002833"
 color-link statusline "#003541,#839496"
-color-link indent-char "#586E75,#002833"
+color-link tabbar "#003541,#839496"
+color-link indent-char "#003541,#002833"
 color-link line-number "#586E75,#003541"
 color-link current-line-number "#586E75,#002833"
 color-link gutter-error "#003541,#CB4B16"
 color-link gutter-warning "#CB4B16,#002833"
 color-link cursor-line "#003541"
 color-link color-column "#003541"
+color-link type.extended "#839496,#002833"
+color-link symbol.brackets "#839496,#002833"

runtime/colorschemes/solarized.micro

@@ -1,19 +1,23 @@
-color-link comment "brightgreen"
+color-link comment "bold brightgreen"
 color-link constant "cyan"
+color-link constant.specialChar "red"
 color-link identifier "blue"
 color-link statement "green"
 color-link symbol "green"
 color-link preproc "brightred"
 color-link type "yellow"
-color-link special "red"
+color-link special "blue"
 color-link underlined "magenta"
 color-link error "bold brightred"
 color-link todo "bold magenta"
 color-link statusline "black,brightblue"
+color-link tabbar "black,brightblue"
 color-link indent-char "black"
-color-link line-number "brightgreen,black"
-color-link current-line-number "brightgreen,default"
+color-link line-number "bold brightgreen,black"
+color-link current-line-number "bold brightgreen,default"
 color-link gutter-error "black,brightred"
 color-link gutter-warning "brightred,default"
 color-link cursor-line "black"
 color-link color-column "black"
+color-link type.extended "default"
+color-link symbol.brackets "default"

runtime/colorschemes/symbian-tc.micro

@@ -0,0 +1,23 @@
+#Symbian
+color-link default "#000000,#ff8a00"
+color-link comment "#8c0000"
+color-link constant "#8c0000"
+color-link identifier "#ffff8c"
+color-link preproc "#ffff8c,#8c0000"
+color-link special "#8c0000"
+color-link statement "#8c0000"
+color-link symbol "#8c0000"
+color-link type "#8c0000"
+color-link error "#ffff8c,#8c0000"
+color-link todo "#8c0000,#ffff8c"
+color-link statusline "#ffff8c,#8c0000"
+color-link tabbar "#ffff8c,#8c0000"
+color-link color-column "#8c0000"
+color-link line-number "#ffff8c,#8c0000"
+color-link current-line-number "#000000,#ff8a00"
+color-link gutter-error "#ffff8c,#8c0000"
+color-link gutter-warning "default"
+#000000
+#8c0000
+#ff8a00
+#ffff8c

runtime/colorschemes/zenburn.micro

@@ -13,6 +13,7 @@ color-link underlined "188,237"
 color-link error "115,236"
 color-link todo "bold 254,237"
 color-link statusline "186,236"
+color-link tabbar "186,236"
 color-link indent-char "238,237"
 color-link line-number "248,238"
 color-link gutter-error "237,174"

runtime/help/colors.md

@@ -5,13 +5,18 @@ This help page aims to cover two aspects of micro's syntax highlighting engine:
 - How to create colorschemes and use them
 - How to create syntax files to add to the list of languages micro can highlight
 
-### Colorschemes
+## Colorschemes
 
 Micro comes with a number of colorschemes by default. Here is the list:
 
 * simple: this is the simplest colorscheme. It uses 16 colors which are
   set by your terminal
 
+* mc: A 16-color theme based on the look and feel of GNU Midnight Commander.
+  This will look great used in conjunction with Midnight Commander.
+  
+* nano: A 16-color theme loosely based on GNU nano's syntax highlighting.   
+  
 * monokai: this is the monokai colorscheme; you may recognize it as
   Sublime Text's default colorscheme. It requires true color to
   look perfect, but the 256 color approximation looks very good as well.
@@ -29,15 +34,47 @@ Micro comes with a number of colorschemes by default. Here is the list:
 * atom-dark-tc: this colorscheme is based off of Atom's "dark" colorscheme.
   It requires true color to look good.
 
+* cmc-16: A very nice 16-color theme. Written by contributor CaptainMcClellan
+  (Collin Warren.) Licensed under the same license as the rest of the themes.
+
+* cmc-paper: Basically cmc-16, but on a white background. ( Actually light grey on most 
+  ANSI (16-color) terminals.)
+
+* cmc-tc: A true colour variant of the cmc theme. 
+  It requires true color to look its best. Use cmc-16 if your terminal doesn't support true color.
+
+* codeblocks: A colorscheme based on the Code::Blocks IDE's default syntax highlighting.
+
+* codeblocks-paper: Same as codeblocks, but on a white background. ( Actually light grey. )
+
+* github-tc: A colorscheme based on Github's syntax highlighting. Requires true color to look its best.
+
+* paper-tc: A nice minimalist theme with a light background, good for editing documents on.
+  Requires true color to look its best. Not to be confused with `-paper` suffixed themes.
+
+* geany: Colorscheme based on geany's default highlighting.
+
+* geany-alt-tc: Based on an alternate theme bundled with geany. 
+
+* flamepoint-tc: A fire inspired, high intensity true color theme written by CaptainMcClellan.
+  As with all the other `-tc` suffixed themes, it looks its best on a
+
 To enable one of these colorschemes just press CtrlE in micro and type `set colorscheme solarized`.
-(or whichever one you choose).
+(or whichever one you choose). You can also use `set colorscheme monochrome` if you'd prefer
+to have just the terminal's default foreground and background colors. 
+Note: This provides no syntax highlighting!
+
+See `help gimmickcolors` for a list of some true colour themes that are more 
+just for fun than for serious use. ( Though feel free if you want! )
 
 ---
 
+### Creating a Colorscheme
+
 Micro's colorschemes are also extremely simple to create. The default ones can be found
 [here](https://github.com/zyedidia/micro/tree/master/runtime/colorschemes).
 
-They are only about 18 lines in total.
+They are only about 18-30 lines in total.
 
 Basically to create the colorscheme you need to link highlight groups with actual colors.
 This is done using the `color-link` command.
@@ -84,7 +121,8 @@ If the user's terminal supports true color, then you can also specify colors exa
 their hex codes. If the terminal is not true color but micro is told to use a true color colorscheme
 it will attempt to map the colors to the available 256 colors.
 
-Generally colorschemes which require true color terminals to look good are marked with a `-tc` suffix.
+Generally colorschemes which require true color terminals to look good are marked with a `-tc` suffix
+and colorschemes which supply a white background are marked with a `-paper` suffix.
 
 ---
 
@@ -102,57 +140,165 @@ Here is a list of the colorscheme groups that you can use:
 * underlined
 * error
 * todo
-* statusline (color of the statusline)
-* indent-char (color of the character which indicates tabs if the option is enabled)
+* statusline ( Color of the statusline)
+* tabbar ( Color of the tabbar that lists open files.)
+* indent-char ( Color of the character which indicates tabs if the option is enabled)
 * line-number
 * gutter-error
 * gutter-warning
 * cursor-line
 * current-line-number
 * color-column
+* ignore
+* divider ( Color of the divider between vertical splits. )
 
-Colorschemes can be placed in the `~/.config/micro/colorschemes` directory to be used.
-
-### Syntax files
-
-The syntax files specify how to highlight certain languages.
-
-The first statement in a syntax file will probably the syntax statement. This tells micro
-what language the syntax file is for and how to detect a file in that language.
-
-Essentially, it's just
-
-```
-syntax "Name of language" "\.extension$"
-```
-
-For the extension, micro will just compare that regex to the filename and if it matches then it
-will use the syntax rules defined in the remainder of the file.
-
-There is also a possibility to use a header statement which is a regex that micro will compare
-with the first line of the file. This is almost only used for shebangs at the top of shell scripts
-which don't have any extension (see sh.micro for an example).
+Colorschemes must be placed in the `~/.config/micro/colorschemes` directory to be used.
 
 ---
 
-The rest of a syntax file is very simple and is essentially a list of regexes specifying how to highlight
-different expressions.
+In addition to the main colorscheme groups, there are subgroups that you can
+specify by adding `.subgroup` to the group. If you're creating your own
+custom syntax files, you can make use of your own subgroups.
 
-It is recommended that when creating a syntax file you use the colorscheme groups (see above) to
-highlight different expressions. You may also hard code colors, but that may not look good depending
-on what terminal colorscheme the user has installed.
+If micro can't match the subgroup, it'll default to the root group, so 
+it's safe and recommended to use subgroups in your custom syntax files.
 
-Here is an example to highlight comments (expressions starting with `//`):
+For example if `constant.string` is found in your colorscheme, micro will
+use that for highlighting strings. If it's not found, it will use constant 
+instead. Micro tries to match the largest set of groups it can find in the
+colorscheme definitions, so if, for examle `constant.bool.true` is found then
+micro will use that. If `constant.bool.true` is not found but `constant.bool`
+is found micro will use `constant.bool`. If not, it uses `constant`. 
+
+Here's a list of subgroups used in micro's built-in syntax files.
+
+* comment.bright ( Some filetypes have distinctions between types of comments.)
+* constant.bool
+* constant.bool.true
+* constant.bool.false
+* constant.number 
+* constant.specialChar
+* constant.string
+* constant.string.url 
+* identifier.class ( Also used for functions. )
+* identifier.macro
+* identifier.var
+* preproc.shebang ( The #! at the beginning of a file that tells the os what script interpreter to use. )
+* symbol.brackets ( {}()[] and sometimes <> )
+* symbol.operator ( Color operator symbols differently. )
+* symbol.tag ( For html tags, among other things.)
+* type.keyword ( If you want a special highlight for keywords like `private` )
+
+In the future, plugins may also be able to use color groups for styling.
+
+## Syntax files
+
+The syntax files is written in yaml-format and specify how to highlight languages.
+
+Micro's builtin syntax highlighting tries very hard to be sane, sensible
+and provide ample coverage of the meaningful elements of a language. Micro has
+syntax files built int for over 100 languages now. However, there may be 
+situations where you find Micro's highlighting to be insufficient or not to
+your liking. Good news is you can create syntax files (.micro extension), place them in 
+`~/.config/micro/syntax` and Micro will use those instead.
+
+### Filetype defintion
+
+You must start the syntax file by declaring the filetype:
 
 ```
-color comment "//.*"
+filetype: go
 ```
 
-This will highlight the regex `//.*` in the color that the user's colorscheme has linked to the comment
-group.
+#### Detect definition
 
-Note that this regex only matches the current line. Here is an example for multiline comments (`/* comment */`):
+Then you must provide information about how to detect the filetype:
 
 ```
-color comment start="/\*" end="\*/"
+detect:
+    filename: "\\.go$"
+```
+
+Micro will match this regex against a given filename to detect the filetype. You may also
+provide an optional `header` regex that will check the first line of the file. For example:
+
+```
+detect:
+    filename: "\\.ya?ml$"
+    header: "%YAML"
+```
+
+#### Syntax rules
+
+Next you must provide the syntax highlighting rules. There are two types of rules: patterns and regions.
+A pattern is matched on a single line and usually a single word as well. A region highlights between two
+patterns over multiple lines and may have rules of its own inside the region.
+
+Here are some example patterns in Go:
+
+```
+rules:
+    - special: "\\b(break|case|continue|default|go|goto|range|return)\\b"
+    - statement: "\\b(else|for|if|switch)\\b"
+    - preproc: "\\b(package|import|const|var|type|struct|func|go|defer|iota)\\b"
+```
+
+The order of patterns does matter as patterns lower in the file will overwrite the ones defined above them.
+
+And here are some example regions for Go:
+
+```
+- constant.string:
+    start: "\""
+    end: "\""
+    rules:
+        - constant.specialChar: "%."
+        - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
+        - constant.specialChar: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
+
+- comment:
+    start: "//"
+    end: "$"
+    rules:
+        - todo: "(TODO|XXX|FIXME):?"
+
+- comment:
+    start: "/\\*"
+    end: "\\*/"
+    rules:
+        - todo: "(TODO|XXX|FIXME):?"
+```
+
+Notice how the regions may contain rules inside of them. Any inner rules that are matched are then skipped when searching
+for the end of the region. For example, when highlighting `"foo \" bar"`, since `\"` is matched by an inner rule in the
+region, it is skipped. Likewise for `"foo \\" bar`, since `\\` is matched by an inner rule, it is skipped, and then the `"`
+is found and the string ends at the correct place.
+
+You may also explicitly mark skip regexes if you don't want them to be highlighted. For example:
+
+```
+- constant.string:
+    start: "\""
+    end: "\""
+    skip: "\\."
+    rules: []
+```
+
+#### Includes
+
+You may also include rules from other syntax files as embedded languages. For example, the following is possible
+for html:
+
+```
+- default:
+    start: "<script.*?>"
+    end: "</script.*?>"
+    rules:
+        - include: "javascript"
+
+- default:
+    start: "<style.*?>"
+    end: "</style.*?>"
+    rules:
+        - include: "css"
 ```

runtime/help/commands.md

@@ -10,12 +10,17 @@ Here are the possible commands that you can use.
 
 * `replace "search" "value" flags`: This will replace `search` with `value`. 
    The `flags` are optional.
-   At this point, there is only one flag: `c`, which enables `check` mode 
-   which asks if you'd like to perform the replacement each time.
+   At this point, there is only one flag: `-a`, which replaces all occurrences
+   at once.
 
    Note that `search` must be a valid regex.  If one of the arguments
    does not have any spaces in it, you may omit the quotes.
 
+* `replaceall "search" "value"`: This will replace `search` with `value` without
+    user confirmation.
+
+    See `replace` command for more information.
+
 * `set option value`: sets the option to value. See the `options` help topic
    for a list of options you can set.
 
@@ -42,6 +47,10 @@ Here are the possible commands that you can use.
 
 * `tab filename`: opens the given file in a new tab.
 
+* `tabswitch tab`: This command will switch to the specified tab.
+   The `tab` can either be a tab number, or a name of a tab.
+                     
+
 * `log`: opens a log of all messages and debug statements.
 
 * `plugin install plugin_name`: installs the given plugin.

runtime/help/defaultkeys.md

@@ -0,0 +1,126 @@
+# Default Keys
+
+Below are simple charts of the default hotkeys and their functions.
+For more information about binding custom hotkeys or changing
+default bindings, please run `> help keybindings`
+
+Please remember that *all* keys here are rebindable!
+If you don't like it, you can change it!
+
+# Power user
+
+| Key       | Description of function                                                                           |
+|--------   |-------------------------------------------------------------------------------------------------- |
+| Ctrl+E    | Open a command prompt for running commands (see `> help commands` for a list of valid commands).  |
+| Tab       | In command prompt, it will autocomplete if possible.                                              |
+| Ctrl+B    | Run a shell command (this will close micro while your command executes).                          |
+
+# Navigation
+
+| Key                       | Description of function                                                                   |
+|-------------------------- |------------------------------------------------------------------------------------------ |
+| Arrows                    | Move the cursor around                                                                    |
+| Shift+arrows              | Move and select text                                                                      |
+| Home or CtrlLeftArrow     | Move to the beginning of the current line                                                 |
+| End or CtrlRightArrow     | Move to the end of the current line                                                       |
+| AltLeftArrow              | Move cursor one word left                                                                 |
+| AltRightArrow             | Move cursor one word right                                                                |
+| PageUp                    | Move cursor up one page                                                                   |
+| PageDown                  | Move cursor down one page                                                                 |
+| CtrlHome or CtrlUpArrow   | Move cursor to start of document                                                          |
+| CtrlEnd or CtrlDownArrow  | Move cursor to end of document                                                            |
+| Ctrl+L                    | Jump to a line in the file (prompts with #)                                               |
+| Ctrl+W                    | Cycle between splits in the current tab (use `> vsplit` or `> hsplit` to create a split)  |
+
+# Tabs
+
+| Key     | Description of function   |
+|-------- |-------------------------  |
+| Ctrl+T  | Open a new tab            |
+| Alt+,   | Previous tab              |
+| Alt+.   | Next tab                  |
+
+# Find Operations
+
+| Key       | Description of function                   |
+|--------   |------------------------------------------ |
+| Ctrl+F    | Find (opens prompt)                       |
+| Ctrl+N    | Find next instance of current search      |
+| Ctrl+P    | Find previous instance of current search  |
+
+# File Operations
+
+| Key       | Description of function                                           |
+|--------   |----------------------------------------------------------------   |
+| Ctrl+Q    | Close current file (quits micro if this is the last file open)    |
+| Ctrl+O    | Open a file (prompts for filename)                                |
+| Ctrl+S    | Save current file                                                 |
+
+# Text operations
+
+| Key                               | Description of function                   |
+|---------------------------------  |------------------------------------------ |
+| AltShiftRightArrow                | Select word right                         |
+| AltShiftLeftArrow                 | Select word left                          |
+| ShiftHome or CtrlShiftLeftArrow   | Select to start of current line           |
+| ShiftEnd or CtrlShiftRightArrow   | Select to end of current line             |
+| CtrlShiftUpArrow                  | Select to start of file                   |
+| CtrlShiftDownArrow                | Select to end of file                     |
+| Ctrl+X                            | Cut selected text                         |
+| Ctrl+C                            | Copy selected text                        |
+| Ctrl+V                            | Paste                                     |
+| Ctrl+K                            | Cut current line                          |
+| Ctrl+D                            | Duplicate current line                    |
+| Ctrl+Z                            | Undo                                      |
+| Ctrl+Y                            | Redo                                      |
+| AltUpArrow                        | Move current line or selected lines up    |
+| AltDownArrow                      | Move current line of selected lines down  |
+| AltBackspace or AltCtrl+H         | Delete word left                          |
+| Ctrl+A                            | Select all                                |
+
+# Macros
+
+| Key       | Description of function                                                           |
+|--------   |---------------------------------------------------------------------------------- |
+| Ctrl+U    | Toggle macro recording (press Ctrl+U to start recording and press again to stop)  |
+| Ctrl+J    | Run latest recorded macro                                                         |
+
+# Multiple cursors
+
+| Key               | Description of function                                                                       |
+|----------------   |---------------------------------------------------------------------------------------------- |
+| Alt+N             | Create new multiple cursor from selection (will select current word if no current selection)  |
+| Alt+P             | Remove latest multiple cursor                                                                 |
+| Alt+C             | Remove all multiple cursors (cancel)                                                          |
+| Alt+X             | Skip multiple cursor selection                                                                |
+| Ctrl-MouseLeft    | Place a multiple cursor at any location                                                       |
+
+# Other
+
+| Key       | Description of function                                                               |
+|--------   |-----------------------------------------------------------------------------------    |
+| Ctrl+G    | Open help file                                                                        |
+| Ctrl+H    | Backspace (old terminals do not support the backspace key and use Ctrl+H instead)     |
+| Ctrl+R    | Toggle the line number ruler                                                          |
+
+# Emacs style actions
+
+| Key       | Description of function   |
+|-------    |-------------------------  |
+| Alt+F     | Next word                 |
+| Alt+B     | Previous word             |
+| Alt+A     | Move to start of line     |
+| Alt+E     | Move to end of line       |
+
+# Function keys.
+
+Warning! The function keys may not work in all terminals! 
+
+| Key   | Description of function   |
+|-----  |-------------------------  |
+| F1    | Open help                 |
+| F2    | Save                      |
+| F3    | Find                      |
+| F4    | Quit                      |
+| F7    | Find                      |
+| F10   | Quit                      |

runtime/help/gimmickcolors.md

@@ -0,0 +1,14 @@
+# Gimmick colors
+
+We have included a few colorschemes that are for fun:
+
+* funky-cactus: I don't know why I made this. (Written by CaptainMcClellan)
+* gameboy-tc: Colorscheme based on the olive green original Gameboy!
+* nes-tc: A colorscheme and syntax highlighting using only colors in the 
+  Nintendo Entertainment System color palette.
+* symbian-tc: Colorscheme based on SymbOS's GUI.
+* matrix: Pretend it's 1981 with a colorscheme based on a monochrome
+  IBM 5151. ( Does not include the ghosting and trailing. )
+
+Check the plugin repo periodically for gimmick-color extension packs
+and genuine additional themes.

runtime/help/help.md

@@ -1,5 +1,6 @@
 # Micro help text
 
+Thank you for downloading and using micro.
 Micro is a terminal-based text editor that aims to be easy to use and intuitive, 
 while also taking advantage of the full capabilities of modern terminals.
 
@@ -12,9 +13,11 @@ See the next section for more information about documentation and help.
 Press CtrlQ to quit, and CtrlS to save. Press CtrlE to start typing commands
 and you can see which commands are available by pressing tab, or by
 viewing the help topic `> help commands`. When I write `> ...` I mean press
-CtrlE and then type whatever is there.
+CtrlE and then type whatever is there. 
 
-Move the cursor around with the mouse or the arrow keys.
+Move the cursor around with the mouse or the arrow keys. Type `> help defaultkeys` to 
+get a quick, easy overview of the default hotkeys and what they do. For more info
+on rebinding keys, see type `> help keybindings`
 
 If the colorscheme doesn't look good, you can change it with `> set colorscheme ...`.
 You can press tab to see the available colorschemes, or see more information with
@@ -34,6 +37,7 @@ Here are the possible help topics that you can read:
 
 * tutorial: A brief tutorial which gives an overview of all the other help topics
 * keybindings: Gives a full list of the default keybindings as well as how to rebind them
+* defaultkeys: Gives a more straight-forward list of the hotkey commands and what they do.
 * commands: Gives a list of all the commands and what they do
 * options: Gives a list of all the options you can customize
 * plugins: Explains how micro's plugin system works and how to create your own plugins

runtime/help/keybindings.md

@@ -1,89 +1,15 @@
 # Keybindings
 
-Here are the default keybindings in json format. You can rebind them to your liking, following the same format.
+Micro has a plethora of hotkeys that make it easy and powerful to use and all
+hotkeys are fully customizable to your liking.
+Custom keybindings are stored internally in micro if changed with the `>bind` command or
+you can also be added in the file `~/.config/micro/bindings.json` as discussed below.
+For a list of the default keybindings in the json format used by micro, please see
+the end of this file. For a more user-friendly list with explanations of what the default
+hotkeys are and what they do, please see `>help defaultkeys`
 
-```json
-{
-    "Up":             "CursorUp",
-    "Down":           "CursorDown",
-    "Right":          "CursorRight",
-    "Left":           "CursorLeft",
-    "ShiftUp":        "SelectUp",
-    "ShiftDown":      "SelectDown",
-    "ShiftLeft":      "SelectLeft",
-    "ShiftRight":     "SelectRight",
-    "AltLeft":        "WordLeft",
-    "AltRight":       "WordRight",
-    "AltShiftRight":  "SelectWordRight",
-    "AltShiftLeft":   "SelectWordLeft",
-    "AltUp":          "MoveLinesUp",
-    "AltDown":        "MoveLinesDown",
-    "CtrlLeft":       "StartOfLine",
-    "CtrlRight":      "EndOfLine",
-    "CtrlShiftLeft":  "SelectToStartOfLine",
-    "CtrlShiftRight": "SelectToEndOfLine",
-    "CtrlUp":         "CursorStart",
-    "CtrlDown":       "CursorEnd",
-    "CtrlShiftUp":    "SelectToStart",
-    "CtrlShiftDown":  "SelectToEnd",
-    "Enter":          "InsertNewline",
-    "Space":          "InsertSpace",
-    "CtrlH":          "Backspace",
-    "Backspace":      "Backspace",
-    "Alt-CtrlH":      "DeleteWordLeft",
-    "Alt-Backspace":  "DeleteWordLeft",
-    "Tab":            "IndentSelection,InsertTab",
-    "Backtab":        "OutdentSelection",
-    "CtrlO":          "OpenFile",
-    "CtrlS":          "Save",
-    "CtrlF":          "Find",
-    "CtrlN":          "FindNext",
-    "CtrlP":          "FindPrevious",
-    "CtrlZ":          "Undo",
-    "CtrlY":          "Redo",
-    "CtrlC":          "Copy",
-    "CtrlX":          "Cut",
-    "CtrlK":          "CutLine",
-    "CtrlD":          "DuplicateLine",
-    "CtrlV":          "Paste",
-    "CtrlA":          "SelectAll",
-    "CtrlT":          "AddTab",
-    "CtrlRightSq":    "PreviousTab",
-    "CtrlBackslash":  "NextTab",
-    "Home":           "StartOfLine",
-    "End":            "EndOfLine",
-    "CtrlHome":       "CursorStart",
-    "CtrlEnd":        "CursorEnd",
-    "PageUp":         "CursorPageUp",
-    "PageDown":       "CursorPageDown",
-    "CtrlG":          "ToggleHelp",
-    "CtrlR":          "ToggleRuler",
-    "CtrlL":          "JumpLine",
-    "Delete":         "Delete",
-    "CtrlB":          "ShellMode",
-    "CtrlQ":          "Quit",
-    "CtrlE":          "CommandMode",
-    "CtrlW":          "NextSplit",
-    "CtrlU":          "ToggleMacro",
-    "CtrlJ":          "PlayMacro",
-
-    // Emacs-style keybindings
-    "Alt-f": "WordRight",
-    "Alt-b": "WordLeft",
-    "Alt-a": "StartOfLine",
-    "Alt-e": "EndOfLine",
-    "Alt-p": "CursorUp",
-    "Alt-n": "CursorDown",
-
-    // Integration with file managers
-    "F1":  "ToggleHelp",
-    "F2":  "Save",
-    "F4":  "Quit",
-    "F7":  "Find",
-    "F10": "Quit",
-    "Esc": "Escape",
-}
-```
+If `~/.config/micro/bindings.json` does not exist, you can simply create it.
+Micro will know what to do with it.
 
 You can use the alt keys + arrows to move word by word.
 Ctrl left and right move the cursor to the start and end of the line, and
@@ -106,6 +32,9 @@ following in the `bindings.json` file.
 }
 ```
 
+In addition to editing your `~/.config/micro/bindings.json`, you can run
+`>bind <keycombo> <action>` For a list of bindable actions, see below.
+
 You can also chain commands when rebinding. For example, if you want Alt-s to save
 and quit you can bind it like so:
 
@@ -159,6 +88,7 @@ Delete
 Center
 InsertTab
 Save
+SaveAll
 SaveAs
 Find
 FindNext
@@ -201,9 +131,22 @@ HSplit
 PreviousSplit
 ToggleMacro
 PlayMacro
+Suspend (Linux only)
+ScrollUp
+ScrollDown
+SpawnMultiCursor
+RemoveMultiCursor
+RemoveAllMultiCursors
+SkipMultiCursor
 UnbindKey
 ```
 
+You can also bind some mouse actions (these must be bound to mouse buttons)
+```
+MousePress
+MouseMultiCursor
+```
+
 Here is the list of all possible keys you can bind:
 
 ```
@@ -332,6 +275,117 @@ Escape
 Enter
 ```
 
+You can also bind some mouse buttons (they may be bound to normal actions or mouse actions)
+
+```
+MouseLeft
+MouseMiddle
+MouseRight
+MouseWheelUp
+MouseWheelDown
+MouseWheelLeft
+MouseWheelRight
+```
+
+# Default keybinding configuration.
+
+```json
+{
+    "Up":             "CursorUp",
+    "Down":           "CursorDown",
+    "Right":          "CursorRight",
+    "Left":           "CursorLeft",
+    "ShiftUp":        "SelectUp",
+    "ShiftDown":      "SelectDown",
+    "ShiftLeft":      "SelectLeft",
+    "ShiftRight":     "SelectRight",
+    "AltLeft":        "WordLeft",
+    "AltRight":       "WordRight",
+    "AltUp":          "MoveLinesUp",
+    "AltDown":        "MoveLinesDown",
+    "AltShiftRight":  "SelectWordRight",
+    "AltShiftLeft":   "SelectWordLeft",
+    "CtrlLeft":       "StartOfLine",
+    "CtrlRight":      "EndOfLine",
+    "CtrlShiftLeft":  "SelectToStartOfLine",
+    "ShiftHome":      "SelectToStartOfLine",
+    "CtrlShiftRight": "SelectToEndOfLine",
+    "ShiftEnd":       "SelectToEndOfLine",
+    "CtrlUp":         "CursorStart",
+    "CtrlDown":       "CursorEnd",
+    "CtrlShiftUp":    "SelectToStart",
+    "CtrlShiftDown":  "SelectToEnd",
+    "Enter":          "InsertNewline",
+    "CtrlH":          "Backspace",
+    "Backspace":      "Backspace",
+    "Alt-CtrlH":      "DeleteWordLeft",
+    "Alt-Backspace":  "DeleteWordLeft",
+    "Tab":            "IndentSelection,InsertTab",
+    "Backtab":        "OutdentSelection,OutdentLine",
+    "CtrlO":          "OpenFile",
+    "CtrlS":          "Save",
+    "CtrlF":          "Find",
+    "CtrlN":          "FindNext",
+    "CtrlP":          "FindPrevious",
+    "CtrlZ":          "Undo",
+    "CtrlY":          "Redo",
+    "CtrlC":          "Copy",
+    "CtrlX":          "Cut",
+    "CtrlK":          "CutLine",
+    "CtrlD":          "DuplicateLine",
+    "CtrlV":          "Paste",
+    "CtrlA":          "SelectAll",
+    "CtrlT":          "AddTab",
+    "Alt,":           "PreviousTab",
+    "Alt.":           "NextTab",
+    "Home":           "StartOfLine",
+    "End":            "EndOfLine",
+    "CtrlHome":       "CursorStart",
+    "CtrlEnd":        "CursorEnd",
+    "PageUp":         "CursorPageUp",
+    "PageDown":       "CursorPageDown",
+    "CtrlG":          "ToggleHelp",
+    "CtrlR":          "ToggleRuler",
+    "CtrlL":          "JumpLine",
+    "Delete":         "Delete",
+    "CtrlB":          "ShellMode",
+    "CtrlQ":          "Quit",
+    "CtrlE":          "CommandMode",
+    "CtrlW":          "NextSplit",
+    "CtrlU":          "ToggleMacro",
+    "CtrlJ":          "PlayMacro",
+
+    // Emacs-style keybindings
+    "Alt-f": "WordRight",
+    "Alt-b": "WordLeft",
+    "Alt-a": "StartOfLine",
+    "Alt-e": "EndOfLine",
+
+    // Integration with file managers
+    "F1":  "ToggleHelp",
+    "F2":  "Save",
+    "F3":  "Find",
+    "F4":  "Quit",
+    "F7":  "Find",
+    "F10": "Quit",
+    "Esc": "Escape",
+
+    // Mouse bindings
+    "MouseWheelUp":   "ScrollUp",
+    "MouseWheelDown": "ScrollDown",
+    "MouseLeft":      "MousePress",
+    "MouseMiddle":    "PastePrimary",
+    "Ctrl-MouseLeft": "MouseMultiCursor",
+
+    // Multiple cursors bindings
+    "Alt-n": "SpawnMultiCursor",
+    "Alt-p": "RemoveMultiCursor",
+    "Alt-c": "RemoveAllMultiCursors",
+    "Alt-x": "SkipMultiCursor",
+}
+```
+
+# Final notes
 Note: On some old terminal emulators and on Windows machines, `CtrlH` should be used
 for backspace.
 

runtime/help/options.md

@@ -65,6 +65,11 @@ Here are the options that you can set:
 
 	default value: `off`
 
+* `tabmovement`: navigate spaces at the beginning of lines as if they are tabs (e.g. move over 4 spaces at once).
+   This option only does anything if `tabstospaces` is on.
+
+    default value: `off`
+
 * `autoindent`: when creating a new line use the same indentation as the 
    previous line
 
@@ -140,6 +145,22 @@ Here are the options that you can set:
 
 	default value: `on`
 
+* `keepautoindent`: when using autoindent, whitespace is added for you. This option determines if
+   when you move to the next line without any insertions the whitespace that was added should be deleted.
+   By default the autoindent whitespace is deleted if the line was left empty.
+
+    default value: `off`
+
+* `termtitle`: defines whether or not your terminal's title will be set by micro when opened.
+
+    default value: `off`
+
+* `mouse`: whether to enable mouse support. When mouse support is disabled, usually the terminal will be able
+   to access mouse events which can be useful if you want to copy from the terminal instead of from micro (if
+   over ssh for example, because the terminal has access to the local clipboard and micro does not).
+
+    default value: `on`
+
 ---
 
 Default plugin options:
@@ -152,6 +173,19 @@ Default plugin options:
 
 	default value: `on`
 
+* `ftoptions`: by default, micro will set some options based on the filetype. At the moment, micro will
+   use tabs for makefiles and spaces for python files regardless of your settings. If you would like to
+   disable this behavior turn this option off.
+
+	default value: `on`
+
+* `fileformat`: this determines what kind of line endings micro will use for the file. Unix line endings
+   are just `\n` (lf) whereas dos line endings are `\r\n` (crlf). The two possible values for this option
+   are `unix` and `dos`. The fileformat will be automatically detected and displayed on the statusline but
+   this option is useful if you would like to change the line endings or if you are starting a new file.
+
+    default value: `unix`
+
 Any option you set in the editor will be saved to the file 
 ~/.config/micro/settings.json so, in effect, your configuration file will be 
 created for you. If you'd like to take your configuration with you to another

runtime/help/plugins.md

@@ -21,6 +21,16 @@ This is almost always the current view, which you can get with `CurView()` as we
 
 All available actions are listed in the keybindings section of the help.
 
+For callbacks to mouse actions, you are also given the event info:
+
+```lua
+function onMousePress(view, event)
+    local x, y = event:Position()
+
+    return false
+end
+```
+
 These functions should also return a boolean specifying whether the view
 should be relocated to the cursor or not after the action is complete.
 
@@ -61,9 +71,11 @@ as Go's GOOS variable, so `darwin`, `windows`, `linux`, `freebsd`...)
 
 * `Loc(x, y int) Loc`: returns a new `Loc` struct
 
-* `JoinPaths(dir... string) string` combines multiple directories to a full path
+* `WorkingDirectory() string`: returns a rooted path name to the current working directory
 
-* `DirectoryName(path string)` returns all but the last element of path ,typically the path's directory
+* `JoinPaths(dir... string) string`: combines multiple directories to a full path
+
+* `DirectoryName(path string)`: returns all but the last element of path ,typically the path's directory
 
 * `GetOption(name string)`: returns the value of the requested option
 
@@ -130,10 +142,31 @@ The possible methods which you can call using the `messenger` variable are:
 
 * `messenger.Message(msg ...interface{})`
 * `messenger.Error(msg ...interface{})`
-* `messenger.YesNoPrompt(prompt string) (bool, bool)`
+* `messenger.YesNoPrompt(prompt string) (bool,bool)`
 * `messenger.Prompt(prompt, historyType string, completionType Completion) (string, bool)`
+* `messenger.AddLog(msg ...interface{})`
 
-If you want a standard prompt, just use `messenger.Prompt(prompt, "", 0)`
+## Note 
+`golang` function signatures use `.` and lua uses `:` so
+```go
+messenger.Message()
+```
+ turns to
+ ```lua
+ messenger:Message()
+ ```
+
+If you want a standard prompt, just use
+```lua
+messenger:Prompt(prompt, "", 0)
+```
+
+Debug or logging your plugin can be done with below lua example code.
+```lua
+messenger:AddLog("Message goes here ",pluginVariableToPrintHere)
+```
+In Micro Editor to see your plugin logging output press `ctrl E` then type `log`
+A logging window will open and any logging sent from your plugin will be displayed here.
 
 # Adding help files, syntax files, or colorschemes in your plugin
 
@@ -156,25 +189,25 @@ See this example to learn how to use `MakeCompletion` and `MakeCommand`
 
 ```lua
 local function StartsWith(String,Start)
-  String = String:upper()
-  Start = Start:upper() 
-  return string.sub(String,1,string.len(Start))==Start
+    String = String:upper()
+    Start = Start:upper() 
+    return string.sub(String,1,string.len(Start))==Start
 end
 
 function complete(input)
-  local allCompletions = {"Hello", "World", "Foo", "Bar"}
-  local result = {}
-   
-  for i,v in pairs(allCompletions) do
-  if StartsWith(v, input) then
-       table.insert(result, v)
-     end
-   end
-   return result
+    local allCompletions = {"Hello", "World", "Foo", "Bar"}
+    local result = {}
+
+    for i,v in pairs(allCompletions) do
+        if StartsWith(v, input) then
+            table.insert(result, v)
+        end
+    end
+    return result
 end
 
 function foo(arg)
-  messenger:Message(arg)
+    messenger:Message(arg)
 end
 
 MakeCommand("foo", "example.foo", MakeCompletion("example.complete"))