diff --git a/Gopkg.lock b/Gopkg.lock new file mode 100644 index 0000000..abc1a1d --- /dev/null +++ b/Gopkg.lock @@ -0,0 +1,148 @@ +# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. + + +[[projects]] + name = "github.com/Luzifer/go_helpers" + packages = [ + "accessLogger", + "http" + ] + revision = "e31c3a2659d3f4901f696692cfe98bd0eb5168f9" + version = "v2.2.0" + +[[projects]] + name = "github.com/Luzifer/rconfig" + packages = ["."] + revision = "7aef1d393c1e2d0758901853b59981c7adc67c7e" + version = "v1.2.0" + +[[projects]] + name = "github.com/Sirupsen/logrus" + packages = ["."] + revision = "3ec0642a7fb6488f65b06f9040adc67e3990296a" + +[[projects]] + branch = "master" + name = "github.com/Wessie/appdirs" + packages = ["."] + revision = "6573e894f8e294cbae0c4e45c25ff9f2e2918a4e" + +[[projects]] + name = "github.com/didip/tollbooth" + packages = [ + ".", + "config", + "errors", + "libstring" + ] + revision = "e11ced12e0e0bbfedbc1783fcf0a5ec7f9dc4856" + +[[projects]] + branch = "master" + name = "github.com/flopp/go-coordsparser" + packages = ["."] + revision = "845bca739e263e1cd38de25024a47b4d6acbfc1f" + +[[projects]] + name = "github.com/flopp/go-staticmaps" + packages = ["."] + revision = "e8779c98399f6efad291d6504990daceeb9940a9" + +[[projects]] + name = "github.com/fogleman/gg" + packages = ["."] + revision = "ee8994ff90057955c428a5a949da5d064bf3ce6b" + +[[projects]] + name = "github.com/golang/freetype" + packages = [ + "raster", + "truetype" + ] + revision = "38b4c392adc5eed94207994c4848fff99f4ac234" + +[[projects]] + name = "github.com/golang/geo" + packages = [ + "r1", + "r2", + "r3", + "s1", + "s2" + ] + revision = "f65fe014169924880aa2c95d7707c2da435534b9" + +[[projects]] + name = "github.com/gorilla/context" + packages = ["."] + revision = "1c83b3eabd45b6d76072b66b746c20815fb2872d" + +[[projects]] + name = "github.com/gorilla/mux" + packages = ["."] + revision = "49c024275504f0341e5a9971eb7ba7fa3dc7af40" + +[[projects]] + name = "github.com/lucasb-eyer/go-colorful" + packages = ["."] + revision = "c900de9dbbc73129068f5af6a823068fc5f2308c" + +[[projects]] + name = "github.com/patrickmn/go-cache" + packages = ["."] + revision = "7ac151875ffb48b9f3ccce9ea20f020b0c1596c8" + +[[projects]] + name = "github.com/spf13/pflag" + packages = ["."] + revision = "c7e63cf4530bcd3ba943729cee0efeff2ebea63f" + +[[projects]] + branch = "master" + name = "github.com/tkrajina/gpxgo" + packages = ["gpx"] + revision = "7848cf26f5a58b4a4e23b89a4b67cfc3d52dd042" + +[[projects]] + name = "golang.org/x/image" + packages = [ + "draw", + "font", + "font/basicfont", + "font/plan9font", + "math/f64", + "math/fixed" + ] + revision = "97680175a5267bb8b31f1923e7a66df98013b11a" + +[[projects]] + name = "golang.org/x/net" + packages = ["context"] + revision = "dfe83d419c9403b40b19d08cdba2afec27b002f7" + +[[projects]] + name = "golang.org/x/sys" + packages = ["unix"] + revision = "8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9" + +[[projects]] + name = "golang.org/x/time" + packages = ["rate"] + revision = "8be79e1e0910c292df4e79c241bb7e8f7e725959" + +[[projects]] + name = "gopkg.in/validator.v2" + packages = ["."] + revision = "07ffaad256c8e957050ad83d6472eb97d785013d" + +[[projects]] + name = "gopkg.in/yaml.v2" + packages = ["."] + revision = "31c299268d302dd0aa9a0dcf765a3d58971ac83f" + +[solve-meta] + analyzer-name = "dep" + analyzer-version = 1 + inputs-digest = "3d56f50ffce992752c5b104c169174827eb4cb480ed07f718d3ce4f84bd1244e" + solver-name = "gps-cdcl" + solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml new file mode 100644 index 0000000..e7c17e8 --- /dev/null +++ b/Gopkg.toml @@ -0,0 +1,38 @@ +# Gopkg.toml example +# +# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html +# for detailed Gopkg.toml documentation. +# +# required = ["github.com/user/thing/cmd/thing"] +# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] +# +# [[constraint]] +# name = "github.com/user/project" +# version = "1.0.0" +# +# [[constraint]] +# name = "github.com/user/project2" +# branch = "dev" +# source = "github.com/myfork/project2" +# +# [[override]] +# name = "github.com/x/y" +# version = "2.4.0" +# +# [prune] +# non-go = false +# go-tests = true +# unused-packages = true + + +[[constraint]] + name = "github.com/Luzifer/go_helpers" + version = "2.2.0" + +[[constraint]] + name = "github.com/Luzifer/rconfig" + version = "1.2.0" + +[prune] + go-tests = true + unused-packages = true diff --git a/vendor/github.com/golang/freetype/raster/raster.go b/vendor/github.com/golang/freetype/raster/raster.go index 995925e..7e6cd4e 100644 --- a/vendor/github.com/golang/freetype/raster/raster.go +++ b/vendor/github.com/golang/freetype/raster/raster.go @@ -13,7 +13,7 @@ // the Freetype "smooth" module, and the Anti-Grain Geometry library. A // description of the area/coverage algorithm is at // http://projects.tuxee.net/cl-vectors/section-the-cl-aa-algorithm -package raster +package raster // import "github.com/golang/freetype/raster" import ( "strconv" diff --git a/vendor/github.com/golang/freetype/testdata/COPYING b/vendor/github.com/golang/freetype/testdata/COPYING new file mode 100644 index 0000000..78c6065 --- /dev/null +++ b/vendor/github.com/golang/freetype/testdata/COPYING @@ -0,0 +1,42 @@ +Luxi fonts copyright (c) 2001 by Bigelow & Holmes Inc. Luxi font +instruction code copyright (c) 2001 by URW++ GmbH. All Rights +Reserved. Luxi is a registered trademark of Bigelow & Holmes Inc. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of these Fonts and associated documentation files (the "Font +Software"), to deal in the Font Software, including without +limitation the rights to use, copy, merge, publish, distribute, +sublicense, and/or sell copies of the Font Software, and to permit +persons to whom the Font Software is furnished to do so, subject to +the following conditions: + +The above copyright and trademark notices and this permission notice +shall be included in all copies of one or more of the Font Software. + +The Font Software may not be modified, altered, or added to, and in +particular the designs of glyphs or characters in the Fonts may not +be modified nor may additional glyphs or characters be added to the +Fonts. This License becomes null and void when the Fonts or Font +Software have been modified. + +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL +BIGELOW & HOLMES INC. OR URW++ GMBH. BE LIABLE FOR ANY CLAIM, DAMAGES +OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, +INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR +INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT +SOFTWARE. + +Except as contained in this notice, the names of Bigelow & Holmes +Inc. and URW++ GmbH. shall not be used in advertising or otherwise to +promote the sale, use or other dealings in this Font Software without +prior written authorization from Bigelow & Holmes Inc. and URW++ GmbH. + +For further information, contact: + +info@urwpp.de +or +design@bigelowandholmes.com diff --git a/vendor/github.com/golang/freetype/truetype/truetype.go b/vendor/github.com/golang/freetype/truetype/truetype.go index 9e943d3..613fc17 100644 --- a/vendor/github.com/golang/freetype/truetype/truetype.go +++ b/vendor/github.com/golang/freetype/truetype/truetype.go @@ -15,7 +15,7 @@ // // To measure a TrueType font in ideal FUnit space, use scale equal to // font.FUnitsPerEm(). -package truetype +package truetype // import "github.com/golang/freetype/truetype" import ( "fmt" diff --git a/vendor/golang.org/x/image/font/basicfont/basicfont.go b/vendor/golang.org/x/image/font/basicfont/basicfont.go index bcafa61..c6b2b68 100644 --- a/vendor/golang.org/x/image/font/basicfont/basicfont.go +++ b/vendor/golang.org/x/image/font/basicfont/basicfont.go @@ -5,7 +5,7 @@ //go:generate go run gen.go // Package basicfont provides fixed-size font faces. -package basicfont +package basicfont // import "golang.org/x/image/font/basicfont" import ( "image" diff --git a/vendor/golang.org/x/image/font/font.go b/vendor/golang.org/x/image/font/font.go index ec7a04b..a0a66d2 100644 --- a/vendor/golang.org/x/image/font/font.go +++ b/vendor/golang.org/x/image/font/font.go @@ -7,7 +7,7 @@ // // Other packages provide font face implementations. For example, a truetype // package would provide one based on .ttf font files. -package font +package font // import "golang.org/x/image/font" import ( "image" diff --git a/vendor/golang.org/x/image/font/plan9font/plan9font.go b/vendor/golang.org/x/image/font/plan9font/plan9font.go new file mode 100644 index 0000000..af57c55 --- /dev/null +++ b/vendor/golang.org/x/image/font/plan9font/plan9font.go @@ -0,0 +1,585 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package plan9font implements font faces for the Plan 9 font and subfont file +// formats. These formats are described at +// http://plan9.bell-labs.com/magic/man2html/6/font +package plan9font // import "golang.org/x/image/font/plan9font" + +import ( + "bytes" + "errors" + "fmt" + "image" + "image/color" + "log" + "strconv" + "strings" + + "golang.org/x/image/font" + "golang.org/x/image/math/fixed" +) + +// fontchar describes one character glyph in a subfont. +// +// For more detail, look for "struct Fontchar" in +// http://plan9.bell-labs.com/magic/man2html/2/cachechars +type fontchar struct { + x uint32 // X position in the image holding the glyphs. + top uint8 // First non-zero scan line. + bottom uint8 // Last non-zero scan line. + left int8 // Offset of baseline. + width uint8 // Width of baseline. +} + +func parseFontchars(p []byte) []fontchar { + fc := make([]fontchar, len(p)/6) + for i := range fc { + fc[i] = fontchar{ + x: uint32(p[0]) | uint32(p[1])<<8, + top: uint8(p[2]), + bottom: uint8(p[3]), + left: int8(p[4]), + width: uint8(p[5]), + } + p = p[6:] + } + return fc +} + +// subface implements font.Face for a Plan 9 subfont. +type subface struct { + firstRune rune // First rune in the subfont. + n int // Number of characters in the subfont. + height int // Inter-line spacing. + ascent int // Height above the baseline. + fontchars []fontchar // Character descriptions. + img *image.Alpha // Image holding the glyphs. +} + +func (f *subface) Close() error { return nil } +func (f *subface) Kern(r0, r1 rune) fixed.Int26_6 { return 0 } + +func (f *subface) Metrics() font.Metrics { + return font.Metrics{ + Height: fixed.I(f.height), + Ascent: fixed.I(f.ascent), + Descent: fixed.I(f.height - f.ascent), + } +} + +func (f *subface) Glyph(dot fixed.Point26_6, r rune) ( + dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) { + + r -= f.firstRune + if r < 0 || f.n <= int(r) { + return image.Rectangle{}, nil, image.Point{}, 0, false + } + i := &f.fontchars[r+0] + j := &f.fontchars[r+1] + + minX := int(dot.X+32)>>6 + int(i.left) + minY := int(dot.Y+32)>>6 + int(i.top) - f.ascent + dr = image.Rectangle{ + Min: image.Point{ + X: minX, + Y: minY, + }, + Max: image.Point{ + X: minX + int(j.x-i.x), + Y: minY + int(i.bottom) - int(i.top), + }, + } + return dr, f.img, image.Point{int(i.x), int(i.top)}, fixed.Int26_6(i.width) << 6, true +} + +func (f *subface) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) { + r -= f.firstRune + if r < 0 || f.n <= int(r) { + return fixed.Rectangle26_6{}, 0, false + } + i := &f.fontchars[r+0] + j := &f.fontchars[r+1] + + bounds = fixed.R( + int(i.left), + int(i.top)-f.ascent, + int(i.left)+int(j.x-i.x), + int(i.bottom)-f.ascent, + ) + return bounds, fixed.Int26_6(i.width) << 6, true +} + +func (f *subface) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) { + r -= f.firstRune + if r < 0 || f.n <= int(r) { + return 0, false + } + return fixed.Int26_6(f.fontchars[r].width) << 6, true +} + +// runeRange maps a single rune range [lo, hi] to a lazily loaded subface. Both +// ends of the range are inclusive. +type runeRange struct { + lo, hi rune + offset rune // subfont index that the lo rune maps to. + relFilename string + subface *subface + bad bool +} + +// face implements font.Face for a Plan 9 font. +// +// It maps multiple rune ranges to *subface values. Rune ranges may overlap; +// the first match wins. +type face struct { + height int + ascent int + readFile func(relFilename string) ([]byte, error) + runeRanges []runeRange +} + +func (f *face) Close() error { return nil } +func (f *face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 } + +func (f *face) Metrics() font.Metrics { + return font.Metrics{ + Height: fixed.I(f.height), + Ascent: fixed.I(f.ascent), + Descent: fixed.I(f.height - f.ascent), + } +} + +func (f *face) Glyph(dot fixed.Point26_6, r rune) ( + dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) { + + if s, rr := f.subface(r); s != nil { + return s.Glyph(dot, rr) + } + return image.Rectangle{}, nil, image.Point{}, 0, false +} + +func (f *face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) { + if s, rr := f.subface(r); s != nil { + return s.GlyphBounds(rr) + } + return fixed.Rectangle26_6{}, 0, false +} + +func (f *face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) { + if s, rr := f.subface(r); s != nil { + return s.GlyphAdvance(rr) + } + return 0, false +} + +func (f *face) subface(r rune) (*subface, rune) { + // Fall back on U+FFFD if we can't find r. + for _, rr := range [2]rune{r, '\ufffd'} { + // We have to do linear, not binary search. plan9port's + // lucsans/unicode.8.font says: + // 0x2591 0x2593 ../luc/Altshades.7.0 + // 0x2500 0x25ee ../luc/FormBlock.7.0 + // and the rune ranges overlap. + for i := range f.runeRanges { + x := &f.runeRanges[i] + if rr < x.lo || x.hi < rr || x.bad { + continue + } + if x.subface == nil { + data, err := f.readFile(x.relFilename) + if err != nil { + log.Printf("plan9font: couldn't read subfont %q: %v", x.relFilename, err) + x.bad = true + continue + } + sub, err := ParseSubfont(data, x.lo-x.offset) + if err != nil { + log.Printf("plan9font: couldn't parse subfont %q: %v", x.relFilename, err) + x.bad = true + continue + } + x.subface = sub.(*subface) + } + return x.subface, rr + } + } + return nil, 0 +} + +// ParseFont parses a Plan 9 font file. data is the contents of that font file, +// which gives relative filenames for subfont files. readFile returns the +// contents of those subfont files. It is similar to io/ioutil's ReadFile +// function, except that it takes a relative filename instead of an absolute +// one. +func ParseFont(data []byte, readFile func(relFilename string) ([]byte, error)) (font.Face, error) { + f := &face{ + readFile: readFile, + } + // TODO: don't use strconv, to avoid the conversions from []byte to string? + for first := true; len(data) > 0; first = false { + i := bytes.IndexByte(data, '\n') + if i < 0 { + return nil, errors.New("plan9font: invalid font: no final newline") + } + row := string(data[:i]) + data = data[i+1:] + if first { + height, s, ok := nextInt32(row) + if !ok { + return nil, fmt.Errorf("plan9font: invalid font: invalid header %q", row) + } + ascent, s, ok := nextInt32(s) + if !ok { + return nil, fmt.Errorf("plan9font: invalid font: invalid header %q", row) + } + if height < 0 || 0xffff < height || ascent < 0 || 0xffff < ascent { + return nil, fmt.Errorf("plan9font: invalid font: invalid header %q", row) + } + f.height, f.ascent = int(height), int(ascent) + continue + } + lo, s, ok := nextInt32(row) + if !ok { + return nil, fmt.Errorf("plan9font: invalid font: invalid row %q", row) + } + hi, s, ok := nextInt32(s) + if !ok { + return nil, fmt.Errorf("plan9font: invalid font: invalid row %q", row) + } + offset, s, _ := nextInt32(s) + + f.runeRanges = append(f.runeRanges, runeRange{ + lo: lo, + hi: hi, + offset: offset, + relFilename: s, + }) + } + return f, nil +} + +func nextInt32(s string) (ret int32, remaining string, ok bool) { + i := 0 + for ; i < len(s) && s[i] <= ' '; i++ { + } + j := i + for ; j < len(s) && s[j] > ' '; j++ { + } + n, err := strconv.ParseInt(s[i:j], 0, 32) + if err != nil { + return 0, s, false + } + for ; j < len(s) && s[j] <= ' '; j++ { + } + return int32(n), s[j:], true +} + +// ParseSubfont parses a Plan 9 subfont file. +// +// firstRune is the first rune in the subfont file. For example, the +// Phonetic.6.0 subfont, containing glyphs in the range U+0250 to U+02E9, would +// set firstRune to '\u0250'. +func ParseSubfont(data []byte, firstRune rune) (font.Face, error) { + data, m, err := parseImage(data) + if err != nil { + return nil, err + } + if len(data) < 3*12 { + return nil, errors.New("plan9font: invalid subfont: header too short") + } + n := atoi(data[0*12:]) + height := atoi(data[1*12:]) + ascent := atoi(data[2*12:]) + data = data[3*12:] + if len(data) != 6*(n+1) { + return nil, errors.New("plan9font: invalid subfont: data length mismatch") + } + + // Convert from plan9Image to image.Alpha, as the standard library's + // image/draw package works best when glyph masks are of that type. + img := image.NewAlpha(m.Bounds()) + for y := img.Rect.Min.Y; y < img.Rect.Max.Y; y++ { + i := img.PixOffset(img.Rect.Min.X, y) + for x := img.Rect.Min.X; x < img.Rect.Max.X; x++ { + img.Pix[i] = m.at(x, y) + i++ + } + } + + return &subface{ + firstRune: firstRune, + n: n, + height: height, + ascent: ascent, + fontchars: parseFontchars(data), + img: img, + }, nil +} + +// plan9Image implements that subset of the Plan 9 image feature set that is +// used by this font file format. +// +// Some features, such as the repl bit and a clip rectangle, are omitted for +// simplicity. +type plan9Image struct { + depth int // Depth of the pixels in bits. + width int // Width in bytes of a single scan line. + rect image.Rectangle // Extent of the image. + pix []byte // Pixel bits. +} + +func (m *plan9Image) byteoffset(x, y int) int { + a := y * m.width + if m.depth < 8 { + // We need to always round down, but Go rounds toward zero. + np := 8 / m.depth + if x < 0 { + return a + (x-np+1)/np + } + return a + x/np + } + return a + x*(m.depth/8) +} + +func (m *plan9Image) Bounds() image.Rectangle { return m.rect } +func (m *plan9Image) ColorModel() color.Model { return color.AlphaModel } + +func (m *plan9Image) At(x, y int) color.Color { + if (image.Point{x, y}).In(m.rect) { + return color.Alpha{m.at(x, y)} + } + return color.Alpha{0x00} +} + +func (m *plan9Image) at(x, y int) uint8 { + b := m.pix[m.byteoffset(x, y)] + switch m.depth { + case 1: + // CGrey, 1. + mask := uint8(1 << uint8(7-x&7)) + if (b & mask) != 0 { + return 0xff + } + return 0 + case 2: + // CGrey, 2. + shift := uint(x&3) << 1 + // Place pixel at top of word. + y := b << shift + y &= 0xc0 + // Replicate throughout. + y |= y >> 2 + y |= y >> 4 + return y + } + return 0 +} + +var compressed = []byte("compressed\n") + +func parseImage(data []byte) (remainingData []byte, m *plan9Image, retErr error) { + if !bytes.HasPrefix(data, compressed) { + return nil, nil, errors.New("plan9font: unsupported uncompressed format") + } + data = data[len(compressed):] + + const hdrSize = 5 * 12 + if len(data) < hdrSize { + return nil, nil, errors.New("plan9font: invalid image: header too short") + } + hdr, data := data[:hdrSize], data[hdrSize:] + + // Distinguish new channel descriptor from old ldepth. Channel descriptors + // have letters as well as numbers, while ldepths are a single digit + // formatted as %-11d. + new := false + for m := 0; m < 10; m++ { + if hdr[m] != ' ' { + new = true + break + } + } + if hdr[11] != ' ' { + return nil, nil, errors.New("plan9font: invalid image: bad header") + } + if !new { + return nil, nil, errors.New("plan9font: unsupported ldepth format") + } + + depth := 0 + switch s := strings.TrimSpace(string(hdr[:1*12])); s { + default: + return nil, nil, fmt.Errorf("plan9font: unsupported pixel format %q", s) + case "k1": + depth = 1 + case "k2": + depth = 2 + } + r := ator(hdr[1*12:]) + if r.Min.X > r.Max.X || r.Min.Y > r.Max.Y { + return nil, nil, errors.New("plan9font: invalid image: bad rectangle") + } + + width := bytesPerLine(r, depth) + m = &plan9Image{ + depth: depth, + width: width, + rect: r, + pix: make([]byte, width*r.Dy()), + } + + miny := r.Min.Y + for miny != r.Max.Y { + if len(data) < 2*12 { + return nil, nil, errors.New("plan9font: invalid image: data band too short") + } + maxy := atoi(data[0*12:]) + nb := atoi(data[1*12:]) + data = data[2*12:] + + if len(data) < nb { + return nil, nil, errors.New("plan9font: invalid image: data band length mismatch") + } + buf := data[:nb] + data = data[nb:] + + if maxy <= miny || r.Max.Y < maxy { + return nil, nil, fmt.Errorf("plan9font: bad maxy %d", maxy) + } + // An old-format image would flip the bits here, but we don't support + // the old format. + rr := r + rr.Min.Y = miny + rr.Max.Y = maxy + if err := decompress(m, rr, buf); err != nil { + return nil, nil, err + } + miny = maxy + } + return data, m, nil +} + +// Compressed data are sequences of byte codes. If the first byte b has the +// 0x80 bit set, the next (b^0x80)+1 bytes are data. Otherwise, these two bytes +// specify a previous string to repeat. +const ( + compShortestMatch = 3 // shortest match possible. + compWindowSize = 1024 // window size. +) + +var ( + errDecompressBufferTooSmall = errors.New("plan9font: decompress: buffer too small") + errDecompressPhaseError = errors.New("plan9font: decompress: phase error") +) + +func decompress(m *plan9Image, r image.Rectangle, data []byte) error { + if !r.In(m.rect) { + return errors.New("plan9font: decompress: bad rectangle") + } + bpl := bytesPerLine(r, m.depth) + mem := make([]byte, compWindowSize) + memi := 0 + omemi := -1 + y := r.Min.Y + linei := m.byteoffset(r.Min.X, y) + eline := linei + bpl + datai := 0 + for { + if linei == eline { + y++ + if y == r.Max.Y { + break + } + linei = m.byteoffset(r.Min.X, y) + eline = linei + bpl + } + if datai == len(data) { + return errDecompressBufferTooSmall + } + c := data[datai] + datai++ + if c >= 128 { + for cnt := c - 128 + 1; cnt != 0; cnt-- { + if datai == len(data) { + return errDecompressBufferTooSmall + } + if linei == eline { + return errDecompressPhaseError + } + m.pix[linei] = data[datai] + linei++ + mem[memi] = data[datai] + memi++ + datai++ + if memi == len(mem) { + memi = 0 + } + } + } else { + if datai == len(data) { + return errDecompressBufferTooSmall + } + offs := int(data[datai]) + ((int(c) & 3) << 8) + 1 + datai++ + if memi < offs { + omemi = memi + (compWindowSize - offs) + } else { + omemi = memi - offs + } + for cnt := (c >> 2) + compShortestMatch; cnt != 0; cnt-- { + if linei == eline { + return errDecompressPhaseError + } + m.pix[linei] = mem[omemi] + linei++ + mem[memi] = mem[omemi] + memi++ + omemi++ + if omemi == len(mem) { + omemi = 0 + } + if memi == len(mem) { + memi = 0 + } + } + } + } + return nil +} + +func ator(b []byte) image.Rectangle { + return image.Rectangle{atop(b), atop(b[2*12:])} +} + +func atop(b []byte) image.Point { + return image.Pt(atoi(b), atoi(b[12:])) +} + +func atoi(b []byte) int { + i := 0 + for ; i < len(b) && b[i] == ' '; i++ { + } + n := 0 + for ; i < len(b) && '0' <= b[i] && b[i] <= '9'; i++ { + n = n*10 + int(b[i]) - '0' + } + return n +} + +func bytesPerLine(r image.Rectangle, depth int) int { + if depth <= 0 || 32 < depth { + panic("invalid depth") + } + var l int + if r.Min.X >= 0 { + l = (r.Max.X*depth + 7) / 8 + l -= (r.Min.X * depth) / 8 + } else { + // Make positive before divide. + t := (-r.Min.X*depth + 7) / 8 + l = t + (r.Max.X*depth+7)/8 + } + return l +} diff --git a/vendor/golang.org/x/image/math/f64/f64.go b/vendor/golang.org/x/image/math/f64/f64.go index 61840bd..a1f7fc0 100644 --- a/vendor/golang.org/x/image/math/f64/f64.go +++ b/vendor/golang.org/x/image/math/f64/f64.go @@ -3,7 +3,7 @@ // license that can be found in the LICENSE file. // Package f64 implements float64 vector and matrix types. -package f64 +package f64 // import "golang.org/x/image/math/f64" // Vec2 is a 2-element vector. type Vec2 [2]float64 diff --git a/vendor/golang.org/x/image/math/fixed/fixed.go b/vendor/golang.org/x/image/math/fixed/fixed.go index cc7bac7..df3540a 100644 --- a/vendor/golang.org/x/image/math/fixed/fixed.go +++ b/vendor/golang.org/x/image/math/fixed/fixed.go @@ -3,7 +3,7 @@ // license that can be found in the LICENSE file. // Package fixed implements fixed-point integer types. -package fixed +package fixed // import "golang.org/x/image/math/fixed" import ( "fmt" diff --git a/vendor/golang.org/x/net/context/context.go b/vendor/golang.org/x/net/context/context.go index 27dcb95..f143ed6 100644 --- a/vendor/golang.org/x/net/context/context.go +++ b/vendor/golang.org/x/net/context/context.go @@ -34,7 +34,7 @@ // // See http://blog.golang.org/context for example code for a server that uses // Contexts. -package context +package context // import "golang.org/x/net/context" import "time" diff --git a/vendor/golang.org/x/sys/unix/syscall.go b/vendor/golang.org/x/sys/unix/syscall.go index 571e699..a0bcf84 100644 --- a/vendor/golang.org/x/sys/unix/syscall.go +++ b/vendor/golang.org/x/sys/unix/syscall.go @@ -19,7 +19,7 @@ // These calls return err == nil to indicate success; otherwise // err represents an operating system error describing the failure and // holds a value of type syscall.Errno. -package unix +package unix // import "golang.org/x/sys/unix" import "unsafe"