Fix handling of +LINE:COL syntax

Fixes #1685

diff --git a/cmd/micro/micro.go b/cmd/micro/micro.go
index 5eb62097192419c5b830c78483312ed2a7878f50..b3a3aa49022f6923c91960f63c6d2e9789351479 100644 (file)
--- a/cmd/micro/micro.go
+++ b/cmd/micro/micro.go
@@ -8,6 +8,7 @@ import (
        "regexp"
        "runtime"
        "sort"
+       "strconv"
        "time"
 
        "github.com/go-errors/errors"
@@ -155,18 +156,31 @@ func LoadInput() []*buffer.Buffer {
        }
 
        files := make([]string, 0, len(args))
-       flagStartPos := ""
-       flagr := regexp.MustCompile(`^\+\d+(:\d+)?$`)
+       flagStartPos := buffer.Loc{-1, -1}
+       flagr := regexp.MustCompile(`^\+(\d+)(?::(\d+))?$`)
        for _, a := range args {
-               if flagr.MatchString(a) {
-                       flagStartPos = a[1:]
-               } else {
-                       if flagStartPos != "" {
-                               files = append(files, a+":"+flagStartPos)
-                               flagStartPos = ""
-                       } else {
-                               files = append(files, a)
+               match := flagr.FindStringSubmatch(a)
+               if len(match) == 3 && match[2] != "" {
+                       line, err := strconv.Atoi(match[1])
+                       if err != nil {
+                               screen.TermMessage(err)
+                               continue
+                       }
+                       col, err := strconv.Atoi(match[2])
+                       if err != nil {
+                               screen.TermMessage(err)
+                               continue
                        }
+                       flagStartPos = buffer.Loc{col, line - 1}
+               } else if len(match) == 3 && match[2] == "" {
+                       line, err := strconv.Atoi(match[1])
+                       if err != nil {
+                               screen.TermMessage(err)
+                               continue
+                       }
+                       flagStartPos = buffer.Loc{0, line - 1}
+               } else {
+                       files = append(files, a)
                }
        }
 
@@ -174,7 +188,7 @@ func LoadInput() []*buffer.Buffer {
                // Option 1
                // We go through each file and load it
                for i := 0; i < len(files); i++ {
-                       buf, err := buffer.NewBufferFromFile(files[i], btype)
+                       buf, err := buffer.NewBufferFromFileAtLoc(files[i], btype, flagStartPos)
                        if err != nil {
                                screen.TermMessage(err)
                                continue
@@ -191,10 +205,10 @@ func LoadInput() []*buffer.Buffer {
                        screen.TermMessage("Error reading from stdin: ", err)
                        input = []byte{}
                }
-               buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, btype))
+               buffers = append(buffers, buffer.NewBufferFromStringAtLoc(string(input), filename, btype, flagStartPos))
        } else {
                // Option 3, just open an empty buffer
-               buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, btype))
+               buffers = append(buffers, buffer.NewBufferFromStringAtLoc(string(input), filename, btype, flagStartPos))
        }
 
        return buffers

diff --git a/internal/buffer/buffer.go b/internal/buffer/buffer.go
index def60b134904936f480c9eac458607f4d678a2e4..1830cea545eccbee96d49f7876605edc9f5b5508 100644 (file)
--- a/internal/buffer/buffer.go
+++ b/internal/buffer/buffer.go
@@ -191,17 +191,22 @@ type Buffer struct {
        StartCursor Loc
 }
 
-// NewBufferFromFile opens a new buffer using the given path
-// It will also automatically handle `~`, and line/column with filename:l:c
-// It will return an empty buffer if the path does not exist
-// and an error if the file is a directory
-func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
+// NewBufferFromFileAtLoc opens a new buffer with a given cursor location
+// If cursorLoc is {-1, -1} the location does not overwrite what the cursor location
+// would otherwise be (start of file, or saved cursor position if `savecursor` is
+// enabled)
+func NewBufferFromFileAtLoc(path string, btype BufType, cursorLoc Loc) (*Buffer, error) {
        var err error
-       var cursorPos []string
        filename := path
-       if config.GetGlobalOption("parsecursor").(bool) {
-               filename, cursorPos = util.GetPathAndCursorPosition(path)
+       if config.GetGlobalOption("parsecursor").(bool) && cursorLoc.X == -1 && cursorLoc.Y == -1 {
+               var cursorPos []string
+               filename, cursorPos = util.GetPathAndCursorPosition(filename)
+               cursorLoc, err = ParseCursorLocation(cursorPos)
+               if err != nil {
+                       cursorLoc = Loc{-1, -1}
+               }
        }
+
        filename, err = util.ReplaceHome(filename)
        if err != nil {
                return nil, err
@@ -216,11 +221,6 @@ func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
 
        defer file.Close()
 
-       cursorLoc, cursorerr := ParseCursorLocation(cursorPos)
-       if cursorerr != nil {
-               cursorLoc = Loc{-1, -1}
-       }
-
        var buf *Buffer
        if err != nil {
                // File does not exist -- create an empty buffer with that name
@@ -232,6 +232,19 @@ func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
        return buf, nil
 }
 
+// NewBufferFromFile opens a new buffer using the given path
+// It will also automatically handle `~`, and line/column with filename:l:c
+// It will return an empty buffer if the path does not exist
+// and an error if the file is a directory
+func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
+       return NewBufferFromFileAtLoc(path, btype, Loc{-1, -1})
+}
+
+// NewBufferFromStringAtLoc creates a new buffer containing the given string with a cursor loc
+func NewBufferFromStringAtLoc(text, path string, btype BufType, cursorLoc Loc) *Buffer {
+       return NewBuffer(strings.NewReader(text), int64(len(text)), path, cursorLoc, btype)
+}
+
 // NewBufferFromString creates a new buffer containing the given string
 func NewBufferFromString(text, path string, btype BufType) *Buffer {
        return NewBuffer(strings.NewReader(text), int64(len(text)), path, Loc{-1, -1}, btype)