mirror of
https://github.com/go-gitea/gitea.git
synced 2024-09-01 09:07:29 +02:00
792 lines
21 KiB
Go
Vendored
792 lines
21 KiB
Go
Vendored
// Copyright 2018 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 prototext
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"unicode/utf8"
|
|
|
|
"google.golang.org/protobuf/internal/encoding/messageset"
|
|
"google.golang.org/protobuf/internal/encoding/text"
|
|
"google.golang.org/protobuf/internal/errors"
|
|
"google.golang.org/protobuf/internal/flags"
|
|
"google.golang.org/protobuf/internal/genid"
|
|
"google.golang.org/protobuf/internal/pragma"
|
|
"google.golang.org/protobuf/internal/set"
|
|
"google.golang.org/protobuf/internal/strs"
|
|
"google.golang.org/protobuf/proto"
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
"google.golang.org/protobuf/reflect/protoregistry"
|
|
)
|
|
|
|
// Unmarshal reads the given []byte into the given proto.Message.
|
|
func Unmarshal(b []byte, m proto.Message) error {
|
|
return UnmarshalOptions{}.Unmarshal(b, m)
|
|
}
|
|
|
|
// UnmarshalOptions is a configurable textproto format unmarshaler.
|
|
type UnmarshalOptions struct {
|
|
pragma.NoUnkeyedLiterals
|
|
|
|
// AllowPartial accepts input for messages that will result in missing
|
|
// required fields. If AllowPartial is false (the default), Unmarshal will
|
|
// return error if there are any missing required fields.
|
|
AllowPartial bool
|
|
|
|
// DiscardUnknown specifies whether to ignore unknown fields when parsing.
|
|
// An unknown field is any field whose field name or field number does not
|
|
// resolve to any known or extension field in the message.
|
|
// By default, unmarshal rejects unknown fields as an error.
|
|
DiscardUnknown bool
|
|
|
|
// Resolver is used for looking up types when unmarshaling
|
|
// google.protobuf.Any messages or extension fields.
|
|
// If nil, this defaults to using protoregistry.GlobalTypes.
|
|
Resolver interface {
|
|
protoregistry.MessageTypeResolver
|
|
protoregistry.ExtensionTypeResolver
|
|
}
|
|
}
|
|
|
|
// Unmarshal reads the given []byte and populates the given proto.Message using options in
|
|
// UnmarshalOptions object.
|
|
func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
|
|
return o.unmarshal(b, m)
|
|
}
|
|
|
|
// unmarshal is a centralized function that all unmarshal operations go through.
|
|
// For profiling purposes, avoid changing the name of this function or
|
|
// introducing other code paths for unmarshal that do not go through this.
|
|
func (o UnmarshalOptions) unmarshal(b []byte, m proto.Message) error {
|
|
proto.Reset(m)
|
|
|
|
if o.Resolver == nil {
|
|
o.Resolver = protoregistry.GlobalTypes
|
|
}
|
|
|
|
dec := decoder{text.NewDecoder(b), o}
|
|
if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
|
|
return err
|
|
}
|
|
if o.AllowPartial {
|
|
return nil
|
|
}
|
|
return proto.CheckInitialized(m)
|
|
}
|
|
|
|
type decoder struct {
|
|
*text.Decoder
|
|
opts UnmarshalOptions
|
|
}
|
|
|
|
// newError returns an error object with position info.
|
|
func (d decoder) newError(pos int, f string, x ...interface{}) error {
|
|
line, column := d.Position(pos)
|
|
head := fmt.Sprintf("(line %d:%d): ", line, column)
|
|
return errors.New(head+f, x...)
|
|
}
|
|
|
|
// unexpectedTokenError returns a syntax error for the given unexpected token.
|
|
func (d decoder) unexpectedTokenError(tok text.Token) error {
|
|
return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())
|
|
}
|
|
|
|
// syntaxError returns a syntax error for given position.
|
|
func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
|
|
line, column := d.Position(pos)
|
|
head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
|
|
return errors.New(head+f, x...)
|
|
}
|
|
|
|
// unmarshalMessage unmarshals into the given protoreflect.Message.
|
|
func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
|
|
messageDesc := m.Descriptor()
|
|
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
|
|
return errors.New("no support for proto1 MessageSets")
|
|
}
|
|
|
|
if messageDesc.FullName() == genid.Any_message_fullname {
|
|
return d.unmarshalAny(m, checkDelims)
|
|
}
|
|
|
|
if checkDelims {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if tok.Kind() != text.MessageOpen {
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
}
|
|
|
|
var seenNums set.Ints
|
|
var seenOneofs set.Ints
|
|
fieldDescs := messageDesc.Fields()
|
|
|
|
for {
|
|
// Read field name.
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch typ := tok.Kind(); typ {
|
|
case text.Name:
|
|
// Continue below.
|
|
case text.EOF:
|
|
if checkDelims {
|
|
return text.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
default:
|
|
if checkDelims && typ == text.MessageClose {
|
|
return nil
|
|
}
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
|
|
// Resolve the field descriptor.
|
|
var name pref.Name
|
|
var fd pref.FieldDescriptor
|
|
var xt pref.ExtensionType
|
|
var xtErr error
|
|
var isFieldNumberName bool
|
|
|
|
switch tok.NameKind() {
|
|
case text.IdentName:
|
|
name = pref.Name(tok.IdentName())
|
|
fd = fieldDescs.ByName(name)
|
|
if fd == nil {
|
|
// The proto name of a group field is in all lowercase,
|
|
// while the textproto field name is the group message name.
|
|
gd := fieldDescs.ByName(pref.Name(strings.ToLower(string(name))))
|
|
if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == name {
|
|
fd = gd
|
|
}
|
|
} else if fd.Kind() == pref.GroupKind && fd.Message().Name() != name {
|
|
fd = nil // reset since field name is actually the message name
|
|
}
|
|
|
|
case text.TypeName:
|
|
// Handle extensions only. This code path is not for Any.
|
|
xt, xtErr = d.findExtension(pref.FullName(tok.TypeName()))
|
|
|
|
case text.FieldNumber:
|
|
isFieldNumberName = true
|
|
num := pref.FieldNumber(tok.FieldNumber())
|
|
if !num.IsValid() {
|
|
return d.newError(tok.Pos(), "invalid field number: %d", num)
|
|
}
|
|
fd = fieldDescs.ByNumber(num)
|
|
if fd == nil {
|
|
xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)
|
|
}
|
|
}
|
|
|
|
if xt != nil {
|
|
fd = xt.TypeDescriptor()
|
|
if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
|
|
return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
|
|
}
|
|
} else if xtErr != nil && xtErr != protoregistry.NotFound {
|
|
return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)
|
|
}
|
|
if flags.ProtoLegacy {
|
|
if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
|
|
fd = nil // reset since the weak reference is not linked in
|
|
}
|
|
}
|
|
|
|
// Handle unknown fields.
|
|
if fd == nil {
|
|
if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {
|
|
d.skipValue()
|
|
continue
|
|
}
|
|
return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())
|
|
}
|
|
|
|
// Handle fields identified by field number.
|
|
if isFieldNumberName {
|
|
// TODO: Add an option to permit parsing field numbers.
|
|
//
|
|
// This requires careful thought as the MarshalOptions.EmitUnknown
|
|
// option allows formatting unknown fields as the field number and the
|
|
// best-effort textual representation of the field value. In that case,
|
|
// it may not be possible to unmarshal the value from a parser that does
|
|
// have information about the unknown field.
|
|
return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())
|
|
}
|
|
|
|
switch {
|
|
case fd.IsList():
|
|
kind := fd.Kind()
|
|
if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
|
|
return d.syntaxError(tok.Pos(), "missing field separator :")
|
|
}
|
|
|
|
list := m.Mutable(fd).List()
|
|
if err := d.unmarshalList(fd, list); err != nil {
|
|
return err
|
|
}
|
|
|
|
case fd.IsMap():
|
|
mmap := m.Mutable(fd).Map()
|
|
if err := d.unmarshalMap(fd, mmap); err != nil {
|
|
return err
|
|
}
|
|
|
|
default:
|
|
kind := fd.Kind()
|
|
if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
|
|
return d.syntaxError(tok.Pos(), "missing field separator :")
|
|
}
|
|
|
|
// If field is a oneof, check if it has already been set.
|
|
if od := fd.ContainingOneof(); od != nil {
|
|
idx := uint64(od.Index())
|
|
if seenOneofs.Has(idx) {
|
|
return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())
|
|
}
|
|
seenOneofs.Set(idx)
|
|
}
|
|
|
|
num := uint64(fd.Number())
|
|
if seenNums.Has(num) {
|
|
return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())
|
|
}
|
|
|
|
if err := d.unmarshalSingular(fd, m); err != nil {
|
|
return err
|
|
}
|
|
seenNums.Set(num)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// findExtension returns protoreflect.ExtensionType from the Resolver if found.
|
|
func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
|
|
xt, err := d.opts.Resolver.FindExtensionByName(xtName)
|
|
if err == nil {
|
|
return xt, nil
|
|
}
|
|
return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
|
|
}
|
|
|
|
// unmarshalSingular unmarshals a non-repeated field value specified by the
|
|
// given FieldDescriptor.
|
|
func (d decoder) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) error {
|
|
var val pref.Value
|
|
var err error
|
|
switch fd.Kind() {
|
|
case pref.MessageKind, pref.GroupKind:
|
|
val = m.NewField(fd)
|
|
err = d.unmarshalMessage(val.Message(), true)
|
|
default:
|
|
val, err = d.unmarshalScalar(fd)
|
|
}
|
|
if err == nil {
|
|
m.Set(fd, val)
|
|
}
|
|
return err
|
|
}
|
|
|
|
// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
|
|
// given FieldDescriptor.
|
|
func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return pref.Value{}, err
|
|
}
|
|
|
|
if tok.Kind() != text.Scalar {
|
|
return pref.Value{}, d.unexpectedTokenError(tok)
|
|
}
|
|
|
|
kind := fd.Kind()
|
|
switch kind {
|
|
case pref.BoolKind:
|
|
if b, ok := tok.Bool(); ok {
|
|
return pref.ValueOfBool(b), nil
|
|
}
|
|
|
|
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
|
|
if n, ok := tok.Int32(); ok {
|
|
return pref.ValueOfInt32(n), nil
|
|
}
|
|
|
|
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
|
|
if n, ok := tok.Int64(); ok {
|
|
return pref.ValueOfInt64(n), nil
|
|
}
|
|
|
|
case pref.Uint32Kind, pref.Fixed32Kind:
|
|
if n, ok := tok.Uint32(); ok {
|
|
return pref.ValueOfUint32(n), nil
|
|
}
|
|
|
|
case pref.Uint64Kind, pref.Fixed64Kind:
|
|
if n, ok := tok.Uint64(); ok {
|
|
return pref.ValueOfUint64(n), nil
|
|
}
|
|
|
|
case pref.FloatKind:
|
|
if n, ok := tok.Float32(); ok {
|
|
return pref.ValueOfFloat32(n), nil
|
|
}
|
|
|
|
case pref.DoubleKind:
|
|
if n, ok := tok.Float64(); ok {
|
|
return pref.ValueOfFloat64(n), nil
|
|
}
|
|
|
|
case pref.StringKind:
|
|
if s, ok := tok.String(); ok {
|
|
if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
|
|
return pref.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
|
|
}
|
|
return pref.ValueOfString(s), nil
|
|
}
|
|
|
|
case pref.BytesKind:
|
|
if b, ok := tok.String(); ok {
|
|
return pref.ValueOfBytes([]byte(b)), nil
|
|
}
|
|
|
|
case pref.EnumKind:
|
|
if lit, ok := tok.Enum(); ok {
|
|
// Lookup EnumNumber based on name.
|
|
if enumVal := fd.Enum().Values().ByName(pref.Name(lit)); enumVal != nil {
|
|
return pref.ValueOfEnum(enumVal.Number()), nil
|
|
}
|
|
}
|
|
if num, ok := tok.Int32(); ok {
|
|
return pref.ValueOfEnum(pref.EnumNumber(num)), nil
|
|
}
|
|
|
|
default:
|
|
panic(fmt.Sprintf("invalid scalar kind %v", kind))
|
|
}
|
|
|
|
return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
|
|
}
|
|
|
|
// unmarshalList unmarshals into given protoreflect.List. A list value can
|
|
// either be in [] syntax or simply just a single scalar/message value.
|
|
func (d decoder) unmarshalList(fd pref.FieldDescriptor, list pref.List) error {
|
|
tok, err := d.Peek()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
switch fd.Kind() {
|
|
case pref.MessageKind, pref.GroupKind:
|
|
switch tok.Kind() {
|
|
case text.ListOpen:
|
|
d.Read()
|
|
for {
|
|
tok, err := d.Peek()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
switch tok.Kind() {
|
|
case text.ListClose:
|
|
d.Read()
|
|
return nil
|
|
case text.MessageOpen:
|
|
pval := list.NewElement()
|
|
if err := d.unmarshalMessage(pval.Message(), true); err != nil {
|
|
return err
|
|
}
|
|
list.Append(pval)
|
|
default:
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
}
|
|
|
|
case text.MessageOpen:
|
|
pval := list.NewElement()
|
|
if err := d.unmarshalMessage(pval.Message(), true); err != nil {
|
|
return err
|
|
}
|
|
list.Append(pval)
|
|
return nil
|
|
}
|
|
|
|
default:
|
|
switch tok.Kind() {
|
|
case text.ListOpen:
|
|
d.Read()
|
|
for {
|
|
tok, err := d.Peek()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
switch tok.Kind() {
|
|
case text.ListClose:
|
|
d.Read()
|
|
return nil
|
|
case text.Scalar:
|
|
pval, err := d.unmarshalScalar(fd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
list.Append(pval)
|
|
default:
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
}
|
|
|
|
case text.Scalar:
|
|
pval, err := d.unmarshalScalar(fd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
list.Append(pval)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
|
|
// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
|
|
// textproto message containing {key: <kvalue>, value: <mvalue>}.
|
|
func (d decoder) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error {
|
|
// Determine ahead whether map entry is a scalar type or a message type in
|
|
// order to call the appropriate unmarshalMapValue func inside
|
|
// unmarshalMapEntry.
|
|
var unmarshalMapValue func() (pref.Value, error)
|
|
switch fd.MapValue().Kind() {
|
|
case pref.MessageKind, pref.GroupKind:
|
|
unmarshalMapValue = func() (pref.Value, error) {
|
|
pval := mmap.NewValue()
|
|
if err := d.unmarshalMessage(pval.Message(), true); err != nil {
|
|
return pref.Value{}, err
|
|
}
|
|
return pval, nil
|
|
}
|
|
default:
|
|
unmarshalMapValue = func() (pref.Value, error) {
|
|
return d.unmarshalScalar(fd.MapValue())
|
|
}
|
|
}
|
|
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch tok.Kind() {
|
|
case text.MessageOpen:
|
|
return d.unmarshalMapEntry(fd, mmap, unmarshalMapValue)
|
|
|
|
case text.ListOpen:
|
|
for {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch tok.Kind() {
|
|
case text.ListClose:
|
|
return nil
|
|
case text.MessageOpen:
|
|
if err := d.unmarshalMapEntry(fd, mmap, unmarshalMapValue); err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
}
|
|
|
|
default:
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
}
|
|
|
|
// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
|
|
// textproto message containing {key: <kvalue>, value: <mvalue>}.
|
|
func (d decoder) unmarshalMapEntry(fd pref.FieldDescriptor, mmap pref.Map, unmarshalMapValue func() (pref.Value, error)) error {
|
|
var key pref.MapKey
|
|
var pval pref.Value
|
|
Loop:
|
|
for {
|
|
// Read field name.
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch tok.Kind() {
|
|
case text.Name:
|
|
if tok.NameKind() != text.IdentName {
|
|
if !d.opts.DiscardUnknown {
|
|
return d.newError(tok.Pos(), "unknown map entry field %q", tok.RawString())
|
|
}
|
|
d.skipValue()
|
|
continue Loop
|
|
}
|
|
// Continue below.
|
|
case text.MessageClose:
|
|
break Loop
|
|
default:
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
|
|
switch name := pref.Name(tok.IdentName()); name {
|
|
case genid.MapEntry_Key_field_name:
|
|
if !tok.HasSeparator() {
|
|
return d.syntaxError(tok.Pos(), "missing field separator :")
|
|
}
|
|
if key.IsValid() {
|
|
return d.newError(tok.Pos(), "map entry %q cannot be repeated", name)
|
|
}
|
|
val, err := d.unmarshalScalar(fd.MapKey())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
key = val.MapKey()
|
|
|
|
case genid.MapEntry_Value_field_name:
|
|
if kind := fd.MapValue().Kind(); (kind != pref.MessageKind) && (kind != pref.GroupKind) {
|
|
if !tok.HasSeparator() {
|
|
return d.syntaxError(tok.Pos(), "missing field separator :")
|
|
}
|
|
}
|
|
if pval.IsValid() {
|
|
return d.newError(tok.Pos(), "map entry %q cannot be repeated", name)
|
|
}
|
|
pval, err = unmarshalMapValue()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
default:
|
|
if !d.opts.DiscardUnknown {
|
|
return d.newError(tok.Pos(), "unknown map entry field %q", name)
|
|
}
|
|
d.skipValue()
|
|
}
|
|
}
|
|
|
|
if !key.IsValid() {
|
|
key = fd.MapKey().Default().MapKey()
|
|
}
|
|
if !pval.IsValid() {
|
|
switch fd.MapValue().Kind() {
|
|
case pref.MessageKind, pref.GroupKind:
|
|
// If value field is not set for message/group types, construct an
|
|
// empty one as default.
|
|
pval = mmap.NewValue()
|
|
default:
|
|
pval = fd.MapValue().Default()
|
|
}
|
|
}
|
|
mmap.Set(key, pval)
|
|
return nil
|
|
}
|
|
|
|
// unmarshalAny unmarshals an Any textproto. It can either be in expanded form
|
|
// or non-expanded form.
|
|
func (d decoder) unmarshalAny(m pref.Message, checkDelims bool) error {
|
|
var typeURL string
|
|
var bValue []byte
|
|
var seenTypeUrl bool
|
|
var seenValue bool
|
|
var isExpanded bool
|
|
|
|
if checkDelims {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if tok.Kind() != text.MessageOpen {
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
}
|
|
|
|
Loop:
|
|
for {
|
|
// Read field name. Can only have 3 possible field names, i.e. type_url,
|
|
// value and type URL name inside [].
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if typ := tok.Kind(); typ != text.Name {
|
|
if checkDelims {
|
|
if typ == text.MessageClose {
|
|
break Loop
|
|
}
|
|
} else if typ == text.EOF {
|
|
break Loop
|
|
}
|
|
return d.unexpectedTokenError(tok)
|
|
}
|
|
|
|
switch tok.NameKind() {
|
|
case text.IdentName:
|
|
// Both type_url and value fields require field separator :.
|
|
if !tok.HasSeparator() {
|
|
return d.syntaxError(tok.Pos(), "missing field separator :")
|
|
}
|
|
|
|
switch name := pref.Name(tok.IdentName()); name {
|
|
case genid.Any_TypeUrl_field_name:
|
|
if seenTypeUrl {
|
|
return d.newError(tok.Pos(), "duplicate %v field", genid.Any_TypeUrl_field_fullname)
|
|
}
|
|
if isExpanded {
|
|
return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
|
|
}
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var ok bool
|
|
typeURL, ok = tok.String()
|
|
if !ok {
|
|
return d.newError(tok.Pos(), "invalid %v field value: %v", genid.Any_TypeUrl_field_fullname, tok.RawString())
|
|
}
|
|
seenTypeUrl = true
|
|
|
|
case genid.Any_Value_field_name:
|
|
if seenValue {
|
|
return d.newError(tok.Pos(), "duplicate %v field", genid.Any_Value_field_fullname)
|
|
}
|
|
if isExpanded {
|
|
return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
|
|
}
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s, ok := tok.String()
|
|
if !ok {
|
|
return d.newError(tok.Pos(), "invalid %v field value: %v", genid.Any_Value_field_fullname, tok.RawString())
|
|
}
|
|
bValue = []byte(s)
|
|
seenValue = true
|
|
|
|
default:
|
|
if !d.opts.DiscardUnknown {
|
|
return d.newError(tok.Pos(), "invalid field name %q in %v message", tok.RawString(), genid.Any_message_fullname)
|
|
}
|
|
}
|
|
|
|
case text.TypeName:
|
|
if isExpanded {
|
|
return d.newError(tok.Pos(), "cannot have more than one type")
|
|
}
|
|
if seenTypeUrl {
|
|
return d.newError(tok.Pos(), "conflict with type_url field")
|
|
}
|
|
typeURL = tok.TypeName()
|
|
var err error
|
|
bValue, err = d.unmarshalExpandedAny(typeURL, tok.Pos())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
isExpanded = true
|
|
|
|
default:
|
|
if !d.opts.DiscardUnknown {
|
|
return d.newError(tok.Pos(), "invalid field name %q in %v message", tok.RawString(), genid.Any_message_fullname)
|
|
}
|
|
}
|
|
}
|
|
|
|
fds := m.Descriptor().Fields()
|
|
if len(typeURL) > 0 {
|
|
m.Set(fds.ByNumber(genid.Any_TypeUrl_field_number), pref.ValueOfString(typeURL))
|
|
}
|
|
if len(bValue) > 0 {
|
|
m.Set(fds.ByNumber(genid.Any_Value_field_number), pref.ValueOfBytes(bValue))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d decoder) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error) {
|
|
mt, err := d.opts.Resolver.FindMessageByURL(typeURL)
|
|
if err != nil {
|
|
return nil, d.newError(pos, "unable to resolve message [%v]: %v", typeURL, err)
|
|
}
|
|
// Create new message for the embedded message type and unmarshal the value
|
|
// field into it.
|
|
m := mt.New()
|
|
if err := d.unmarshalMessage(m, true); err != nil {
|
|
return nil, err
|
|
}
|
|
// Serialize the embedded message and return the resulting bytes.
|
|
b, err := proto.MarshalOptions{
|
|
AllowPartial: true, // Never check required fields inside an Any.
|
|
Deterministic: true,
|
|
}.Marshal(m.Interface())
|
|
if err != nil {
|
|
return nil, d.newError(pos, "error in marshaling message into Any.value: %v", err)
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
// skipValue makes the decoder parse a field value in order to advance the read
|
|
// to the next field. It relies on Read returning an error if the types are not
|
|
// in valid sequence.
|
|
func (d decoder) skipValue() error {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Only need to continue reading for messages and lists.
|
|
switch tok.Kind() {
|
|
case text.MessageOpen:
|
|
return d.skipMessageValue()
|
|
|
|
case text.ListOpen:
|
|
for {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch tok.Kind() {
|
|
case text.ListClose:
|
|
return nil
|
|
case text.MessageOpen:
|
|
return d.skipMessageValue()
|
|
default:
|
|
// Skip items. This will not validate whether skipped values are
|
|
// of the same type or not, same behavior as C++
|
|
// TextFormat::Parser::AllowUnknownField(true) version 3.8.0.
|
|
if err := d.skipValue(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// skipMessageValue makes the decoder parse and skip over all fields in a
|
|
// message. It assumes that the previous read type is MessageOpen.
|
|
func (d decoder) skipMessageValue() error {
|
|
for {
|
|
tok, err := d.Read()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch tok.Kind() {
|
|
case text.MessageClose:
|
|
return nil
|
|
case text.Name:
|
|
if err := d.skipValue(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|