Exemple #1
0
func bodyDiff(win *acme.Win, ffile string) (bool, error) {
	tf, err := os.Open(ffile)
	if err != nil {
		return false, err
	}
	defer tf.Close()
	win.Seek("body", 0, 0)
	fr := bufio.NewReader(tf)
	br := bufio.NewReader(&bodyReader{win})
	for {
		fb, errf := fr.ReadByte()
		if errf != nil && errf != io.EOF {
			return false, errf
		}
		bb, errb := br.ReadByte()
		if errb != nil && errb != io.EOF {
			return false, errb
		}
		if fb != bb {
			return true, nil
		}
		if errf == io.EOF && errb == io.EOF {
			return false, nil
		}
	}
}
Exemple #2
0
func readFilename(win *acme.Win) (string, error) {
	b, err := win.ReadAll("tag")
	if err != nil {
		return "", err
	}
	tag := string(b)
	i := strings.Index(tag, " ")
	if i == -1 {
		return "", fmt.Errorf("cannot get filename from tag")
	}
	return tag[0:i], nil
}
Exemple #3
0
func events(win *acme.Win, rerun chan<- struct{}) {
	for e := range win.EventChan() {
		debugPrint("Acme event: %+v\n", e)
		switch e.C2 {
		case 'x', 'X':
			switch string(e.Text) {
			case "Get":
				kill()
				rerun <- struct{}{}

			case "Del":
				kill()
				if err := win.Ctl("delete"); err != nil {
					log.Fatalln("Failed to delete the window:", err)
				}

			default:
				win.WriteEvent(e)
			}

		default:
			win.WriteEvent(e)
		}
	}
	os.Exit(0)
}
Exemple #4
0
// We would use win.ReadAll except for a bug in acme
// where it crashes when reading trying to read more
// than the negotiated 9P message size.
func readBody(win *acme.Win) ([]byte, error) {
	var body []byte
	buf := make([]byte, 8000)
	for {
		n, err := win.Read("body", buf)
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		body = append(body, buf[0:n]...)
	}
	return body, nil
}
Exemple #5
0
// We would use io.Copy except for a bug in acme
// where it crashes when reading trying to read more
// than the negotiated 9P message size.
func copyBody(w io.Writer, win *acme.Win) error {
	buf := make([]byte, 8000)
	for {
		n, err := win.Read("body", buf)
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
		if _, err := w.Write(buf[0:n]); err != nil {
			return fmt.Errorf("write error: %v", err)
		}
	}
	return nil
}
Exemple #6
0
func writeEvents(w *acme.Win, wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		select {
		case e, ok := <-w.EventChan():
			if !ok {
				return
			}
			w.WriteEvent(e)
			if string(e.Text) == "Del" {
				return
			}
		}

	}
}
Exemple #7
0
func writeData(win *acme.Win, data []byte) error {
	if len(data) == 0 {
		_, err := win.Write("data", nil)
		return err
	}
	for len(data) > 0 {
		d := data
		if len(d) > 8000 {
			d = trimIncompleteRune(d[0:8000])
		}
		n, err := win.Write("data", d)
		if err != nil {
			return err
		}
		data = data[n:]
	}
	return nil
}
Exemple #8
0
func events(w *acme.Win) <-chan string {
	c := make(chan string, 10)
	go func() {
		for e := range w.EventChan() {
			switch e.C2 {
			case 'x', 'X': // execute
				if string(e.Text) == "Del" {
					w.Ctl("delete")
				}
				w.WriteEvent(e)
			case 'l', 'L': // look
				w.Ctl("clean")
				c <- string(e.Text)
			}
		}
		w.CloseFiles()
		close(c)
	}()
	return c
}
Exemple #9
0
func reloadShowAddr(win *acme.Win, off int) error {
	if err := win.Ctl("get"); err != nil {
		return err
	}
	if err := win.Addr("#%d", off); err != nil {
		return err
	}
	return win.Ctl("dot=addr\nshow")
}
Exemple #10
0
func readAddr(win *acme.Win) (q0, q1 int, err error) {
	if _, _, err := win.ReadAddr(); err != nil {
		return 0, 0, err
	}
	if err := win.Ctl("addr=dot"); err != nil {
		return 0, 0, err
	}
	return win.ReadAddr()
}
Exemple #11
0
func readAddr(win *acme.Win) (q0, q1 int, err error) {
	// This first read is bogus.
	// Acme zeroes the win's address the first time addr is opened.
	// So, we need to open it before setting addr=dot,
	// lest we just read back a zero address.
	if _, _, err := win.ReadAddr(); err != nil {
		return 0, 0, err
	}
	if err := win.Ctl("addr=dot\n"); err != nil {
		return 0, 0, err
	}
	return win.ReadAddr()
}
Exemple #12
0
func writeBody(win *acme.Win, ffile string) error {
	if err := win.Ctl("nomark"); err != nil {
		fmt.Fprintf(os.Stderr, "failed to set nomark: %s", err)
	}
	defer func() {
		if err := win.Ctl("mark"); err != nil {
			fmt.Fprintf(os.Stderr, "failed to set mark: %s", err)
		}
	}()
	tf, err := os.Open(ffile)
	if err != nil {
		return err
	}
	defer tf.Close()
	if err := win.Addr("0,$"); err != nil {
		return err
	}
	_, err = io.Copy(dataWriter{win}, tf)
	return err
}
Exemple #13
0
func selection(win *acme.Win, body []byte) (int, int, error) {
	if _, _, err := win.ReadAddr(); err != nil {
		return 0, 0, err
	}
	if err := win.Ctl("addr=dot"); err != nil {
		return 0, 0, err
	}
	q0, q1, err := win.ReadAddr()
	if err != nil {
		return 0, 0, err
	}
	off0, err := byteOff(q0, bytes.NewReader(body))
	if err != nil {
		return 0, 0, err
	}
	off1, err := byteOff(q1, bytes.NewReader(body))
	if err != nil {
		return 0, 0, err
	}
	return off0, off1, nil
}
Exemple #14
0
func showAddr(win *acme.Win, q0, q1 int) error {
	if err := win.Addr("#%d,#%d", q0, q1); err != nil {
		return err
	}
	return win.Ctl("dot=addr\nshow\n")
}