frame.Insert and frame.Delete working

README.md

@@ -1,3 +1,5 @@
+*NB: this is deprecated and will go away in a few days. See https://github.com/rjkroege/edwood instead.*
+
 # acme
 Go port of Rob Pike's Acme editor, based on the implementation in plan9port.
 
@@ -15,3 +17,10 @@ Go port of Rob Pike's Acme editor, based on the implementation in plan9port.
 ## Contributions
 
 Contributions are very welcome. Just submit a pull request and we'll review the code before merging it in. I intend to handle the bulk of the transliteration myself, but contributions for the refactor into idiomatic Go are more than welcome.
+
+# Build And Test
+[![Go Report Card](https://goreportcard.com/badge/github.com/rjkroege/acme)](https://goreportcard.com/report/github.com/rjkroege/acme)
+
+Project needs work. But I knew that.
+
+

acme.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	 "9fans.net/go/draw"
+	"9fans.net/go/draw"
 	"github.com/ProjectSerenity/acme/frame"
 	"image"
 )
@@ -59,9 +59,9 @@ func main() {
 	img, err := display.AllocImage(image.Rect(0, 0, 1024, 720), draw.RGB16, true, draw.Cyan)
 	if err != nil {
 		panic(err)
-	} 
+	}
 	f := frame.NewFrame(image.Rect(0, 0, 500, 600), display.DefaultFont, img, cols)
-	
+
 	for {
 		f.Tick(image.ZP, true)
 	}

buf_test.go

@@ -0,0 +1,8 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestBuf(t *testing.T) {
+}

dat.go

@@ -2,12 +2,7 @@ package main
 
 import (
 	"9fans.net/go/draw"
-	"bytes"
-	"fmt"
 	"image"
-	"io/ioutil"
-	"os"
-	"os/user"
 	"sync"
 	"unicode/utf8"
 )
@@ -35,12 +30,10 @@ const (
 	QWxdata
 	QMAX
 
-	Blockincr = 256
-	MaxBlock  = 8 * 1024
-	NRange    = 10
-	Infinity  = 0x7FFFFFFF
-
-	STACK = 65536
+	NRange = 10
+	//	Infinity  = 0x7FFFFFFF
+
+	//	STACK = 65536
 
 	Empty    = 0
 	Null     = '-'
@@ -57,8 +50,6 @@ const (
 )
 
 var (
-	blist *Block
-
 	globalincref bool
 	seq          uint
 	maxtab       uint /*size of a tab, in units of the '0' character */
@@ -129,107 +120,6 @@ type Range struct {
 	q0, q1 int
 }
 
-type Block struct {
-	addr uint   // disk address in bytes
-	n    uint   // number of used runes in block
-	next *Block // pointer to next in free list
-}
-
-type Disk struct {
-	fd   *os.File
-	addr uint
-	free [MaxBlock/Blockincr + 1]*Block
-}
-
-func NewDisk() *Disk {
-	d := new(Disk)
-	u, err := user.Current()
-	if err != nil {
-		panic(err)
-	}
-	tmp, err := ioutil.TempFile("/tmp", fmt.Sprintf("X%d.%.4sacme", os.Getpid(), u.Username))
-	if err != nil {
-		panic(err)
-	}
-	d.fd = tmp
-	return d
-}
-
-func ntosize(n uint) (uint, uint) {
-	if n > MaxBlock {
-		panic("internal error: ntosize")
-	}
-	size := n
-	if size&(Blockincr-1) != 0 {
-		size += Blockincr - (size & (Blockincr - 1))
-	}
-
-	// last bucket holds blocks of exactly Maxblock
-	ip := size / Blockincr
-	return size, ip
-}
-
-func (d *Disk) NewBlock(n uint) *Block {
-	size, i := ntosize(n)
-	b := d.free[i]
-	if b != nil {
-		d.free[i] = b.next
-	} else {
-		if blist == nil {
-			bl := new(Block)
-			blist = bl
-			for j := 0; j < 100-1; j++ {
-				bl.next = new(Block)
-				bl = bl.next
-			}
-		}
-		b = blist
-		blist = b.next
-		b.addr = d.addr
-		d.addr += size
-	}
-	b.n = n
-	return b
-}
-
-func (d *Disk) Release(b *Block) {
-	_, i := ntosize(b.n)
-	b.next = d.free[i]
-	d.free[i] = b
-}
-
-func (d *Disk) Read(b *Block, r []rune, n uint) {
-	if n > b.n {
-		panic("internal error: disk.Read")
-	}
-	// this is a simplified way of checking that b.n < MaxBlock
-	_, _ = ntosize(b.n)
-	buf := make([]byte, n)
-	if m, err := d.fd.ReadAt(buf, int64(b.addr)); err != nil {
-		panic(err)
-	} else if m != len(r) {
-		panic("read error from temp file")
-	}
-	copy(r, bytes.Runes(buf))
-}
-
-func (d *Disk) Write(bp **Block, r []rune, n uint) {
-	bl := *bp
-	size, _ := ntosize(bl.n)
-	nsize, _ := ntosize(n)
-	if size != nsize {
-		d.Release(bl)
-		bl = d.NewBlock(n)
-		*bp = bl
-	}
-	if m, err := d.fd.WriteAt([]byte(string(r)), int64(bl.addr)); err != nil {
-		panic(err)
-	} else if m != len(r) {
-		panic("write error to temp file")
-	}
-	bl.n = n
-}
-
 type Command struct {
 	pid           int
 	name          []rune

disk.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"unsafe"
+)
+
+// Acme stores blocks as (raw) runes. This does not align well with how Go
+// works where the language (rightly) tries to make sure that we don't do
+// non-portable C things.
+//
+// I have switched this to Acme-style raw rune handling to avoid multiple
+// copies and rune to byte conversion. This seems better in keeping with how
+// Acme actually should work. However, this is not perhaps the right way
+// to do it. It might be better to always store files in UTF8 (ideally as strings).
+
+const (
+	MaxBlock  = 8 * 1024
+	Blockincr = 256
+)
+
+type Block struct {
+	addr uint // disk address in bytes
+
+	// NB: in the C version, these are in a union together. Only one is
+	// used at a time.
+	n    uint   // number of used runes in block
+	next *Block // pointer to next in free list
+}
+
+// Disk is a singleton managing the file that Acme blocks. Blocks
+// are sized from 256B to 8K in 256B increments.
+type Disk struct {
+	fd    *os.File
+	addr  uint
+	free  [MaxBlock/Blockincr + 1]*Block // Disk-backed blocks bucketed by size
+	blist *Block                         // Empty block objects
+}
+
+// NewDisk creates a new backing on-disk file for Acme's paging.
+func NewDisk() *Disk {
+	// tmp, err := ioutil.TempFile("/tmp", fmt.Sprintf("X%d.%.4sacme", os.Getpid(), u.Username))
+	tmp, err := ioutil.TempFile("", "acme")
+	if err != nil {
+		panic(err)
+	}
+	return &Disk{
+		fd: tmp,
+	}
+}
+
+// ntosize computes the size of block to hold n bytes where n must be
+// MaxBlock and the index into the bucket array. The 0-th bucket holds
+// only 0-length blocks.
+func ntosize(n uint) (uint, uint) {
+	if n > MaxBlock {
+		panic("internal error: ntosize")
+	}
+	size := n
+	if size&(Blockincr-1) != 0 {
+		size += Blockincr - (size & (Blockincr - 1))
+	}
+
+	// last bucket holds blocks of exactly Maxblock
+	ip := size / Blockincr
+	return size, ip
+}
+
+func (d *Disk) NewBlock(n uint) *Block {
+	size, i := ntosize(n)
+	b := d.free[i]
+	if b != nil {
+		d.free[i] = b.next
+	} else {
+		if d.blist == nil {
+			// TODO(rjk): Is allocating 1/time really a perf bottleneck in go?
+			bl := new(Block)
+			d.blist = bl
+			for j := 0; j < 100-1; j++ {
+				bl.next = new(Block)
+				bl = bl.next
+			}
+		}
+		b = d.blist
+		d.blist = b.next
+		b.addr = d.addr
+		d.addr += size
+	}
+	b.n = n
+	return b
+}
+
+func (d *Disk) Release(b *Block) {
+	_, i := ntosize(b.n)
+	b.next = d.free[i]
+	d.free[i] = b
+}
+
+// TODO(rjk): Remove the n? Return an error?
+func (d *Disk) Read(b *Block, r []rune, n uint) {
+	if n > b.n {
+		panic("internal error: disk.Read")
+	}
+	// this is a simplified way of checking that b.n < MaxBlock
+	_, _ = ntosize(b.n)
+
+	// Test prior to defeating type safety.
+	if n > uint(len(r)) {
+		panic("internal error: disk Read, n greater than r")
+	}
+
+	uby, sz := makeAliasByteArray(r, n)
+	if m, err := d.fd.ReadAt(uby, int64(b.addr)); err != nil {
+		panic(err)
+	} else if m != sz*int(n) {
+		panic("read error from temp file, m !=  sz * n ")
+	}
+}
+
+func makeAliasByteArray(r []rune, un uint) ([]byte, int) {
+	n := int(un)
+	sz := int(unsafe.Sizeof(' '))
+	rhdr := (*reflect.SliceHeader)(unsafe.Pointer(&r))
+
+	uby := make([]byte, 0)
+	bhdr := (*reflect.SliceHeader)(unsafe.Pointer(&uby))
+	bhdr.Data = rhdr.Data
+	bhdr.Len = sz * n
+	bhdr.Cap = sz * n
+
+	return uby, sz
+}
+
+func (d *Disk) Write(bp **Block, r []rune, n uint) {
+	bl := *bp
+	size, _ := ntosize(bl.n)
+	nsize, _ := ntosize(n)
+	if size != nsize {
+		d.Release(bl)
+		bl = d.NewBlock(n)
+		*bp = bl
+	}
+
+	// Test prior to defeating type safety.
+	if n > uint(len(r)) {
+		panic("internal error: disk Write, n greater than r")
+	}
+
+	uby, sz := makeAliasByteArray(r, n)
+	if m, err := d.fd.WriteAt(uby, int64(bl.addr)); err != nil {
+		panic(err)
+	} else if m != int(n)*sz {
+		log.Println("write mismatch", m, int(n)*sz)
+		panic("write error to temp file")
+	}
+	bl.n = n
+}