taldir

codec.go (10626B)

---

 // Copyright 2017 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 catmsg
 
 import (
 	"errors"
 	"fmt"
 
 	"golang.org/x/text/language"
 )
 
 // A Renderer renders a Message.
 type Renderer interface {
 	// Render renders the given string. The given string may be interpreted as a
 	// format string, such as the one used by the fmt package or a template.
 	Render(s string)
 
 	// Arg returns the i-th argument passed to format a message. This method
 	// should return nil if there is no such argument. Messages need access to
 	// arguments to allow selecting a message based on linguistic features of
 	// those arguments.
 	Arg(i int) interface{}
 }
 
 // A Dictionary specifies a source of messages, including variables or macros.
 type Dictionary interface {
 	// Lookup returns the message for the given key. It returns false for ok if
 	// such a message could not be found.
 	Lookup(key string) (data string, ok bool)
 
 	// TODO: consider returning an interface, instead of a string. This will
 	// allow implementations to do their own message type decoding.
 }
 
 // An Encoder serializes a Message to a string.
 type Encoder struct {
 	// The root encoder is used for storing encoded variables.
 	root *Encoder
 	// The parent encoder provides the surrounding scopes for resolving variable
 	// names.
 	parent *Encoder
 
 	tag language.Tag
 
 	// buf holds the encoded message so far. After a message completes encoding,
 	// the contents of buf, prefixed by the encoded length, are flushed to the
 	// parent buffer.
 	buf []byte
 
 	// vars is the lookup table of variables in the current scope.
 	vars []keyVal
 
 	err    error
 	inBody bool // if false next call must be EncodeMessageType
 }
 
 type keyVal struct {
 	key    string
 	offset int
 }
 
 // Language reports the language for which the encoded message will be stored
 // in the Catalog.
 func (e *Encoder) Language() language.Tag { return e.tag }
 
 func (e *Encoder) setError(err error) {
 	if e.root.err == nil {
 		e.root.err = err
 	}
 }
 
 // EncodeUint encodes x.
 func (e *Encoder) EncodeUint(x uint64) {
 	e.checkInBody()
 	var buf [maxVarintBytes]byte
 	n := encodeUint(buf[:], x)
 	e.buf = append(e.buf, buf[:n]...)
 }
 
 // EncodeString encodes s.
 func (e *Encoder) EncodeString(s string) {
 	e.checkInBody()
 	e.EncodeUint(uint64(len(s)))
 	e.buf = append(e.buf, s...)
 }
 
 // EncodeMessageType marks the current message to be of type h.
 //
 // It must be the first call of a Message's Compile method.
 func (e *Encoder) EncodeMessageType(h Handle) {
 	if e.inBody {
 		panic("catmsg: EncodeMessageType not the first method called")
 	}
 	e.inBody = true
 	e.EncodeUint(uint64(h))
 }
 
 // EncodeMessage serializes the given message inline at the current position.
 func (e *Encoder) EncodeMessage(m Message) error {
 	e = &Encoder{root: e.root, parent: e, tag: e.tag}
 	err := m.Compile(e)
 	if _, ok := m.(*Var); !ok {
 		e.flushTo(e.parent)
 	}
 	return err
 }
 
 func (e *Encoder) checkInBody() {
 	if !e.inBody {
 		panic("catmsg: expected prior call to EncodeMessageType")
 	}
 }
 
 // stripPrefix indicates the number of prefix bytes that must be stripped to
 // turn a single-element sequence into a message that is just this single member
 // without its size prefix. If the message can be stripped, b[1:n] contains the
 // size prefix.
 func stripPrefix(b []byte) (n int) {
 	if len(b) > 0 && Handle(b[0]) == msgFirst {
 		x, n, _ := decodeUint(b[1:])
 		if 1+n+int(x) == len(b) {
 			return 1 + n
 		}
 	}
 	return 0
 }
 
 func (e *Encoder) flushTo(dst *Encoder) {
 	data := e.buf
 	p := stripPrefix(data)
 	if p > 0 {
 		data = data[1:]
 	} else {
 		// Prefix the size.
 		dst.EncodeUint(uint64(len(data)))
 	}
 	dst.buf = append(dst.buf, data...)
 }
 
 func (e *Encoder) addVar(key string, m Message) error {
 	for _, v := range e.parent.vars {
 		if v.key == key {
 			err := fmt.Errorf("catmsg: duplicate variable %q", key)
 			e.setError(err)
 			return err
 		}
 	}
 	scope := e.parent
 	// If a variable message is Incomplete, and does not evaluate to a message
 	// during execution, we fall back to the variable name. We encode this by
 	// appending the variable name if the message reports it's incomplete.
 
 	err := m.Compile(e)
 	if err != ErrIncomplete {
 		e.setError(err)
 	}
 	switch {
 	case len(e.buf) == 1 && Handle(e.buf[0]) == msgFirst: // empty sequence
 		e.buf = e.buf[:0]
 		e.inBody = false
 		fallthrough
 	case len(e.buf) == 0:
 		// Empty message.
 		if err := String(key).Compile(e); err != nil {
 			e.setError(err)
 		}
 	case err == ErrIncomplete:
 		if Handle(e.buf[0]) != msgFirst {
 			seq := &Encoder{root: e.root, parent: e}
 			seq.EncodeMessageType(msgFirst)
 			e.flushTo(seq)
 			e = seq
 		}
 		// e contains a sequence; append the fallback string.
 		e.EncodeMessage(String(key))
 	}
 
 	// Flush result to variable heap.
 	offset := len(e.root.buf)
 	e.flushTo(e.root)
 	e.buf = e.buf[:0]
 
 	// Record variable offset in current scope.
 	scope.vars = append(scope.vars, keyVal{key: key, offset: offset})
 	return err
 }
 
 const (
 	substituteVar = iota
 	substituteMacro
 	substituteError
 )
 
 // EncodeSubstitution inserts a resolved reference to a variable or macro.
 //
 // This call must be matched with a call to ExecuteSubstitution at decoding
 // time.
 func (e *Encoder) EncodeSubstitution(name string, arguments ...int) {
 	if arity := len(arguments); arity > 0 {
 		// TODO: also resolve macros.
 		e.EncodeUint(substituteMacro)
 		e.EncodeString(name)
 		for _, a := range arguments {
 			e.EncodeUint(uint64(a))
 		}
 		return
 	}
 	for scope := e; scope != nil; scope = scope.parent {
 		for _, v := range scope.vars {
 			if v.key != name {
 				continue
 			}
 			e.EncodeUint(substituteVar) // TODO: support arity > 0
 			e.EncodeUint(uint64(v.offset))
 			return
 		}
 	}
 	// TODO: refer to dictionary-wide scoped variables.
 	e.EncodeUint(substituteError)
 	e.EncodeString(name)
 	e.setError(fmt.Errorf("catmsg: unknown var %q", name))
 }
 
 // A Decoder deserializes and evaluates messages that are encoded by an encoder.
 type Decoder struct {
 	tag    language.Tag
 	dst    Renderer
 	macros Dictionary
 
 	err  error
 	vars string
 	data string
 
 	macroArg int // TODO: allow more than one argument
 }
 
 // NewDecoder returns a new Decoder.
 //
 // Decoders are designed to be reused for multiple invocations of Execute.
 // Only one goroutine may call Execute concurrently.
 func NewDecoder(tag language.Tag, r Renderer, macros Dictionary) *Decoder {
 	return &Decoder{
 		tag:    tag,
 		dst:    r,
 		macros: macros,
 	}
 }
 
 func (d *Decoder) setError(err error) {
 	if d.err == nil {
 		d.err = err
 	}
 }
 
 // Language returns the language in which the message is being rendered.
 //
 // The destination language may be a child language of the language used for
 // encoding. For instance, a decoding language of "pt-PT" is consistent with an
 // encoding language of "pt".
 func (d *Decoder) Language() language.Tag { return d.tag }
 
 // Done reports whether there are more bytes to process in this message.
 func (d *Decoder) Done() bool { return len(d.data) == 0 }
 
 // Render implements Renderer.
 func (d *Decoder) Render(s string) { d.dst.Render(s) }
 
 // Arg implements Renderer.
 //
 // During evaluation of macros, the argument positions may be mapped to
 // arguments that differ from the original call.
 func (d *Decoder) Arg(i int) interface{} {
 	if d.macroArg != 0 {
 		if i != 1 {
 			panic("catmsg: only macros with single argument supported")
 		}
 		i = d.macroArg
 	}
 	return d.dst.Arg(i)
 }
 
 // DecodeUint decodes a number that was encoded with EncodeUint and advances the
 // position.
 func (d *Decoder) DecodeUint() uint64 {
 	x, n, err := decodeUintString(d.data)
 	d.data = d.data[n:]
 	if err != nil {
 		d.setError(err)
 	}
 	return x
 }
 
 // DecodeString decodes a string that was encoded with EncodeString and advances
 // the position.
 func (d *Decoder) DecodeString() string {
 	size := d.DecodeUint()
 	s := d.data[:size]
 	d.data = d.data[size:]
 	return s
 }
 
 // SkipMessage skips the message at the current location and advances the
 // position.
 func (d *Decoder) SkipMessage() {
 	n := int(d.DecodeUint())
 	d.data = d.data[n:]
 }
 
 // Execute decodes and evaluates msg.
 //
 // Only one goroutine may call execute.
 func (d *Decoder) Execute(msg string) error {
 	d.err = nil
 	if !d.execute(msg) {
 		return ErrNoMatch
 	}
 	return d.err
 }
 
 func (d *Decoder) execute(msg string) bool {
 	saved := d.data
 	d.data = msg
 	ok := d.executeMessage()
 	d.data = saved
 	return ok
 }
 
 // executeMessageFromData is like execute, but also decodes a leading message
 // size and clips the given string accordingly.
 //
 // It reports the number of bytes consumed and whether a message was selected.
 func (d *Decoder) executeMessageFromData(s string) (n int, ok bool) {
 	saved := d.data
 	d.data = s
 	size := int(d.DecodeUint())
 	n = len(s) - len(d.data)
 	// Sanitize the setting. This allows skipping a size argument for
 	// RawString and method Done.
 	d.data = d.data[:size]
 	ok = d.executeMessage()
 	n += size - len(d.data)
 	d.data = saved
 	return n, ok
 }
 
 var errUnknownHandler = errors.New("catmsg: string contains unsupported handler")
 
 // executeMessage reads the handle id, initializes the decoder and executes the
 // message. It is assumed that all of d.data[d.p:] is the single message.
 func (d *Decoder) executeMessage() bool {
 	if d.Done() {
 		// We interpret no data as a valid empty message.
 		return true
 	}
 	handle := d.DecodeUint()
 
 	var fn Handler
 	mutex.Lock()
 	if int(handle) < len(handlers) {
 		fn = handlers[handle]
 	}
 	mutex.Unlock()
 	if fn == nil {
 		d.setError(errUnknownHandler)
 		d.execute(fmt.Sprintf("\x02$!(UNKNOWNMSGHANDLER=%#x)", handle))
 		return true
 	}
 	return fn(d)
 }
 
 // ExecuteMessage decodes and executes the message at the current position.
 func (d *Decoder) ExecuteMessage() bool {
 	n, ok := d.executeMessageFromData(d.data)
 	d.data = d.data[n:]
 	return ok
 }
 
 // ExecuteSubstitution executes the message corresponding to the substitution
 // as encoded by EncodeSubstitution.
 func (d *Decoder) ExecuteSubstitution() {
 	switch x := d.DecodeUint(); x {
 	case substituteVar:
 		offset := d.DecodeUint()
 		d.executeMessageFromData(d.vars[offset:])
 	case substituteMacro:
 		name := d.DecodeString()
 		data, ok := d.macros.Lookup(name)
 		old := d.macroArg
 		// TODO: support macros of arity other than 1.
 		d.macroArg = int(d.DecodeUint())
 		switch {
 		case !ok:
 			// TODO: detect this at creation time.
 			d.setError(fmt.Errorf("catmsg: undefined macro %q", name))
 			fallthrough
 		case !d.execute(data):
 			d.dst.Render(name) // fall back to macro name.
 		}
 		d.macroArg = old
 	case substituteError:
 		d.dst.Render(d.DecodeString())
 	default:
 		panic("catmsg: unreachable")
 	}
 }