csearch, cgrep: add -A, -B, -C, -V (cgrep only) flags

Also start on HTML output for a possible web interface.

cmd/cgrep: add -v flag

Author: rsc

cmd/cgrep/cgrep.go

@@ -14,11 +14,11 @@ import (
 	"github.com/google/codesearch/regexp"
 )
 
-var usageMessage = `usage: cgrep [-c] [-h] [-i] [-l] [-n] regexp [file...]
+var usageMessage = `usage: cgrep [-c] [-h] [-i] [-l] [-n] [-v] regexp [file...]
 
 Cgrep behaves like grep, searching for regexp, an RE2 (nearly PCRE) regular expression.
 
-The -c, -h, -i, -l, and -n flags are as in grep, although note that as per Go's
+The -c, -h, -i, -l, -n, and -v flags are as in grep, although note that as per Go's
 flag parsing convention, they cannot be combined: the option pair -i -n
 cannot be abbreviated to -in.
 `
@@ -37,6 +37,7 @@ func main() {
 	log.SetPrefix("cgrep: ")
 	var g regexp.Grep
 	g.AddFlags()
+	g.AddVFlag()
 	g.Stdout = os.Stdout
 	g.Stderr = os.Stderr
 	flag.Usage = usage

cmd/csearch/csearch.go

@@ -6,6 +6,7 @@ package main
 
 import (
 	"archive/zip"
+	"bytes"
 	"flag"
 	"fmt"
 	"log"
@@ -141,6 +142,10 @@ func Main() {
 
 	for _, fileid := range post {
 		name := ix.Name(fileid).String()
+		if g.L && (pat == "(?m)" || pat == "(?i)(?m)") {
+			g.Reader(bytes.NewReader(nil), name)
+			continue
+		}
 		file, err := os.Open(string(name))
 		if err != nil {
 			if i := strings.Index(name, ".zip#"); i >= 0 {

regexp/match.go

@@ -9,10 +9,13 @@ import (
 	"encoding/binary"
 	"flag"
 	"fmt"
+	"html"
 	"io"
 	"os"
 	"regexp/syntax"
 	"sort"
+	"strconv"
+	"strings"
 
 	"github.com/google/codesearch/sparse"
 )
@@ -338,9 +341,9 @@ func (m *matcher) matchString(b string, beginText, endText bool) (end int) {
 
 // isWordByte reports whether the byte c is a word character: ASCII only.
 // This is used to implement \b and \B.  This is not right for Unicode, but:
-//	- it's hard to get right in a byte-at-a-time matching world
-//	  (the DFA has only one-byte lookahead)
-//	- this crude approximation is the same one PCRE uses
+//   - it's hard to get right in a byte-at-a-time matching world
+//     (the DFA has only one-byte lookahead)
+//   - this crude approximation is the same one PCRE uses
 func isWordByte(c int) bool {
 	return 'A' <= c && c <= 'Z' ||
 		'a' <= c && c <= 'z' ||
@@ -358,8 +361,16 @@ type Grep struct {
 	C bool // C flag - print count of matches
 	N bool // N flag - print line numbers
 	H bool // H flag - do not print file names
+	V bool // V flag - print non-matching lines (only for cgrep, not csearch)
 
-	Match bool
+	HTML    bool // emit HTML output for csweb
+	Match   bool // were any matches found?
+	Matches int  // how many matches were found?
+	Limit   int  // stop after this many matches
+	Limited bool // stopped because of limit
+
+	PreContext  int // number of lines to print after
+	PostContext int // number of lines to print before
 
 	buf []byte
 }
@@ -369,12 +380,34 @@ func (g *Grep) AddFlags() {
 	flag.BoolVar(&g.C, "c", false, "print match counts only")
 	flag.BoolVar(&g.N, "n", false, "show line numbers")
 	flag.BoolVar(&g.H, "h", false, "omit file names")
+	flag.IntVar(&g.PreContext, "B", 0, "show `n` lines before match")
+	flag.IntVar(&g.PostContext, "A", 0, "show `n` lines after match")
+	flag.Func("C", "show `n` lines before and after match", func(s string) error {
+		n, err := strconv.Atoi(s)
+		if err != nil {
+			return err
+		}
+		g.PreContext = n
+		g.PostContext = n
+		return nil
+	})
+}
+
+func (g *Grep) AddVFlag() {
+	flag.BoolVar(&g.V, "v", false, "show non-matching lines")
+}
+
+func (g *Grep) esc(s string) string {
+	if g.HTML {
+		return html.EscapeString(s)
+	}
+	return s
 }
 
 func (g *Grep) File(name string) {
 	f, err := os.Open(name)
 	if err != nil {
-		fmt.Fprintf(g.Stderr, "%s\n", err)
+		fmt.Fprintf(g.Stderr, "%s\n", g.esc(err.Error()))
 		return
 	}
 	defer f.Close()
@@ -402,7 +435,7 @@ func (g *Grep) Reader(r io.Reader, name string) {
 	}
 	var (
 		buf        = g.buf[:0]
-		needLineno = g.N
+		needLineno = g.N || g.HTML
 		lineno     = 1
 		count      = 0
 		prefix     = ""
@@ -412,28 +445,40 @@ func (g *Grep) Reader(r io.Reader, name string) {
 	if !g.H {
 		prefix = name + ":"
 	}
+	chunkStart := 0
 	for {
 		n, err := io.ReadFull(r, buf[len(buf):cap(buf)])
 		buf = buf[:len(buf)+n]
 		end := len(buf)
 		if err == nil {
-			i := bytes.LastIndex(buf, nl)
-			if i >= 0 {
-				end = i + 1
+			// Stop scan before trailing fragment of a line;
+			// also stop before g.PostContext whole lines,
+			// so we know we'll have the context we need to print.
+			d := lineSuffixLen(buf, g.PostContext+1)
+			if d < len(buf) {
+				end = len(buf) - d
 			}
 		} else {
 			endText = true
 		}
-		chunkStart := 0
 		for chunkStart < end {
 			m1 := g.Regexp.Match(buf[chunkStart:end], beginText, endText) + chunkStart
 			beginText = false
 			if m1 < chunkStart {
 				break
 			}
 			g.Match = true
+			if g.Limit > 0 && g.Matches >= g.Limit {
+				g.Limited = true
+				return
+			}
+			g.Matches++
 			if g.L {
-				fmt.Fprintf(g.Stdout, "%s\n", name)
+				if g.HTML {
+					fmt.Fprintf(g.Stdout, "<a href=\"show/%s\">%s</a>\n", g.esc(name), g.esc(name))
+				} else {
+					fmt.Fprintf(g.Stdout, "%s\n", name)
+				}
 				return
 			}
 			lineStart := bytes.LastIndex(buf[chunkStart:m1], nl) + 1 + chunkStart
@@ -452,6 +497,18 @@ func (g *Grep) Reader(r io.Reader, name string) {
 			switch {
 			case g.C:
 				count++
+			case g.PreContext+g.PostContext > 0:
+				fmt.Fprintf(g.Stdout, "%s%d:\n", prefix, lineno)
+				before, match, after := lineContext(g.PreContext, g.PostContext, buf, lineStart, lineEnd)
+				for _, line := range before {
+					fmt.Fprintf(g.Stdout, "\t\t%s\n", line)
+				}
+				fmt.Fprintf(g.Stdout, "\t>>\t%s\n", match)
+				for _, line := range after {
+					fmt.Fprintf(g.Stdout, "\t\t%s\n", line)
+				}
+			case g.HTML:
+				fmt.Fprintf(g.Stdout, "<a href=\"/show/%s?q=%s#L%d\">%s:%d</a>:%s%s", g.esc(strings.ReplaceAll(name, "#", ">")), g.esc(g.Regexp.String()), lineno, g.esc(name), lineno, g.esc(string(line)), nl)
 			case g.N:
 				fmt.Fprintf(g.Stdout, "%s%d:%s%s", prefix, lineno, line, nl)
 			default:
@@ -465,16 +522,127 @@ func (g *Grep) Reader(r io.Reader, name string) {
 		if needLineno && err == nil {
 			lineno += countNL(buf[chunkStart:end])
 		}
-		n = copy(buf, buf[end:])
+		// Slide pre-context and unprocessed bytes down to start of buffer.
+		d := lineSuffixLen(buf[:end], g.PreContext)
+		if d == end {
+			// Not enough room; give up on context.
+			d = 0
+		}
+		n = copy(buf, buf[end-d:])
 		buf = buf[:n]
-		if len(buf) == 0 && err != nil {
+		chunkStart = d
+		if endText && err != nil {
 			if err != io.EOF && err != io.ErrUnexpectedEOF {
-				fmt.Fprintf(g.Stderr, "%s: %v\n", name, err)
+				fmt.Fprintf(g.Stderr, "%s: %v\n", g.esc(name), err)
 			}
 			break
 		}
 	}
 	if g.C && count > 0 {
-		fmt.Fprintf(g.Stdout, "%s: %d\n", name, count)
+		if g.HTML {
+			fmt.Fprintf(g.Stdout, "<a href=\"show/%s?q=%s\">%s</a>: %d\n", g.esc(name), g.esc(g.Regexp.String()), g.esc(name), count)
+		} else {
+			fmt.Fprintf(g.Stdout, "%s: %d\n", name, count)
+		}
+	}
+}
+
+func lineSuffixLen(buf []byte, n int) int {
+	end := len(buf)
+	for i := 0; i < n; i++ {
+		j := bytes.LastIndex(buf[:end], nl)
+		if j < 0 {
+			break
+		}
+		end = j
+	}
+	if j := bytes.LastIndex(buf[:end], nl); j >= 0 {
+		return len(buf) - (j + 1)
+	}
+	return len(buf)
+}
+
+func linePrefixLen(buf []byte, lines int) int {
+	start := 0
+	for i := 0; i < lines; i++ {
+		j := bytes.IndexByte(buf[start:], '\n')
+		if j < 0 {
+			return len(buf)
+		}
+		start += j + 1
+	}
+	return start
+}
+
+func lineContext(numBefore, numAfter int, buf []byte, lineStart, lineEnd int) (before [][]byte, line []byte, after [][]byte) {
+	beforeChunk := buf[lineStart-lineSuffixLen(buf[:lineStart], numBefore) : lineStart]
+	afterChunk := buf[lineEnd : lineEnd+linePrefixLen(buf[lineEnd:], numAfter)]
+
+	line = chomp(buf[lineStart:lineEnd])
+	before = bytes.SplitAfter(beforeChunk, nl)
+	if len(before[len(before)-1]) == 0 {
+		before = before[:len(before)-1]
+	}
+	for i := range before {
+		before[i] = chomp(before[i])
+	}
+	after = bytes.Split(afterChunk, nl)
+	if len(after[len(after)-1]) == 0 {
+		after = after[:len(after)-1]
+	}
+	for i := range after {
+		after[i] = chomp(after[i])
+	}
+
+	var prefix []byte
+	prefix = updatePrefix(prefix, line)
+	for _, l := range before {
+		prefix = updatePrefix(prefix, l)
+	}
+	for _, l := range after {
+		prefix = updatePrefix(prefix, l)
+	}
+
+	line = cutPrefix(line, prefix)
+	for i, l := range before {
+		before[i] = cutPrefix(l, prefix)
+	}
+	for i, l := range after {
+		after[i] = cutPrefix(l, prefix)
+	}
+	return
+}
+
+func updatePrefix(prefix, line []byte) []byte {
+	if prefix == nil {
+		i := 0
+		for i < len(line) && (line[i] == ' ' || line[i] == '\t') {
+			i++
+		}
+		return line[:i]
+	}
+
+	i := 0
+	for i < len(line) && i < len(prefix) && line[i] == prefix[i] {
+		i++
+	}
+	if i >= len(line) {
+		return prefix
+	}
+	return prefix[:i]
+}
+
+func cutPrefix(line, prefix []byte) []byte {
+	if len(prefix) > len(line) {
+		return nil
+	}
+	return line[len(prefix):]
+}
+
+func chomp(s []byte) []byte {
+	i := len(s)
+	for i > 0 && (s[i-1] == ' ' || s[i-1] == '\t' || s[i-1] == '\r' || s[i-1] == '\n') {
+		i--
 	}
+	return s[:i]
 }