vendor/github.com/gogo/protobuf/proto/text_parser.go

   1 // Protocol Buffers for Go with Gadgets
   2 //
   3 // Copyright (c) 2013, The GoGo Authors. All rights reserved.
   4 // http://github.com/gogo/protobuf
   5 //
   6 // Go support for Protocol Buffers - Google's data interchange format
   7 //
   8 // Copyright 2010 The Go Authors.  All rights reserved.
   9 // https://github.com/golang/protobuf
  10 //
  11 // Redistribution and use in source and binary forms, with or without
  12 // modification, are permitted provided that the following conditions are
  13 // met:
  14 //
  15 //     * Redistributions of source code must retain the above copyright
  16 // notice, this list of conditions and the following disclaimer.
  17 //     * Redistributions in binary form must reproduce the above
  18 // copyright notice, this list of conditions and the following disclaimer
  19 // in the documentation and/or other materials provided with the
  20 // distribution.
  21 //     * Neither the name of Google Inc. nor the names of its
  22 // contributors may be used to endorse or promote products derived from
  23 // this software without specific prior written permission.
  24 //
  25 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36
  37 package proto
  38
  39 // Functions for parsing the Text protocol buffer format.
  40 // TODO: message sets.
  41
  42 import (
  43         "encoding"
  44         "errors"
  45         "fmt"
  46         "reflect"
  47         "strconv"
  48         "strings"
  49         "time"
  50         "unicode/utf8"
  51 )
  52
  53 // Error string emitted when deserializing Any and fields are already set
  54 const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
  55
  56 type ParseError struct {
  57         Message string
  58         Line    int // 1-based line number
  59         Offset  int // 0-based byte offset from start of input
  60 }
  61
  62 func (p *ParseError) Error() string {
  63         if p.Line == 1 {
  64                 // show offset only for first line
  65                 return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
  66         }
  67         return fmt.Sprintf("line %d: %v", p.Line, p.Message)
  68 }
  69
  70 type token struct {
  71         value    string
  72         err      *ParseError
  73         line     int    // line number
  74         offset   int    // byte number from start of input, not start of line
  75         unquoted string // the unquoted version of value, if it was a quoted string
  76 }
  77
  78 func (t *token) String() string {
  79         if t.err == nil {
  80                 return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
  81         }
  82         return fmt.Sprintf("parse error: %v", t.err)
  83 }
  84
  85 type textParser struct {
  86         s            string // remaining input
  87         done         bool   // whether the parsing is finished (success or error)
  88         backed       bool   // whether back() was called
  89         offset, line int
  90         cur          token
  91 }
  92
  93 func newTextParser(s string) *textParser {
  94         p := new(textParser)
  95         p.s = s
  96         p.line = 1
  97         p.cur.line = 1
  98         return p
  99 }
 100
 101 func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
 102         pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
 103         p.cur.err = pe
 104         p.done = true
 105         return pe
 106 }
 107
 108 // Numbers and identifiers are matched by [-+._A-Za-z0-9]
 109 func isIdentOrNumberChar(c byte) bool {
 110         switch {
 111         case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
 112                 return true
 113         case '0' <= c && c <= '9':
 114                 return true
 115         }
 116         switch c {
 117         case '-', '+', '.', '_':
 118                 return true
 119         }
 120         return false
 121 }
 122
 123 func isWhitespace(c byte) bool {
 124         switch c {
 125         case ' ', '\t', '\n', '\r':
 126                 return true
 127         }
 128         return false
 129 }
 130
 131 func isQuote(c byte) bool {
 132         switch c {
 133         case '"', '\'':
 134                 return true
 135         }
 136         return false
 137 }
 138
 139 func (p *textParser) skipWhitespace() {
 140         i := 0
 141         for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
 142                 if p.s[i] == '#' {
 143                         // comment; skip to end of line or input
 144                         for i < len(p.s) && p.s[i] != '\n' {
 145                                 i++
 146                         }
 147                         if i == len(p.s) {
 148                                 break
 149                         }
 150                 }
 151                 if p.s[i] == '\n' {
 152                         p.line++
 153                 }
 154                 i++
 155         }
 156         p.offset += i
 157         p.s = p.s[i:len(p.s)]
 158         if len(p.s) == 0 {
 159                 p.done = true
 160         }
 161 }
 162
 163 func (p *textParser) advance() {
 164         // Skip whitespace
 165         p.skipWhitespace()
 166         if p.done {
 167                 return
 168         }
 169
 170         // Start of non-whitespace
 171         p.cur.err = nil
 172         p.cur.offset, p.cur.line = p.offset, p.line
 173         p.cur.unquoted = ""
 174         switch p.s[0] {
 175         case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
 176                 // Single symbol
 177                 p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
 178         case '"', '\'':
 179                 // Quoted string
 180                 i := 1
 181                 for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
 182                         if p.s[i] == '\\' && i+1 < len(p.s) {
 183                                 // skip escaped char
 184                                 i++
 185                         }
 186                         i++
 187                 }
 188                 if i >= len(p.s) || p.s[i] != p.s[0] {
 189                         p.errorf("unmatched quote")
 190                         return
 191                 }
 192                 unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
 193                 if err != nil {
 194                         p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
 195                         return
 196                 }
 197                 p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
 198                 p.cur.unquoted = unq
 199         default:
 200                 i := 0
 201                 for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
 202                         i++
 203                 }
 204                 if i == 0 {
 205                         p.errorf("unexpected byte %#x", p.s[0])
 206                         return
 207                 }
 208                 p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
 209         }
 210         p.offset += len(p.cur.value)
 211 }
 212
 213 var (
 214         errBadUTF8 = errors.New("proto: bad UTF-8")
 215 )
 216
 217 func unquoteC(s string, quote rune) (string, error) {
 218         // This is based on C++'s tokenizer.cc.
 219         // Despite its name, this is *not* parsing C syntax.
 220         // For instance, "\0" is an invalid quoted string.
 221
 222         // Avoid allocation in trivial cases.
 223         simple := true
 224         for _, r := range s {
 225                 if r == '\\' || r == quote {
 226                         simple = false
 227                         break
 228                 }
 229         }
 230         if simple {
 231                 return s, nil
 232         }
 233
 234         buf := make([]byte, 0, 3*len(s)/2)
 235         for len(s) > 0 {
 236                 r, n := utf8.DecodeRuneInString(s)
 237                 if r == utf8.RuneError && n == 1 {
 238                         return "", errBadUTF8
 239                 }
 240                 s = s[n:]
 241                 if r != '\\' {
 242                         if r < utf8.RuneSelf {
 243                                 buf = append(buf, byte(r))
 244                         } else {
 245                                 buf = append(buf, string(r)...)
 246                         }
 247                         continue
 248                 }
 249
 250                 ch, tail, err := unescape(s)
 251                 if err != nil {
 252                         return "", err
 253                 }
 254                 buf = append(buf, ch...)
 255                 s = tail
 256         }
 257         return string(buf), nil
 258 }
 259
 260 func unescape(s string) (ch string, tail string, err error) {
 261         r, n := utf8.DecodeRuneInString(s)
 262         if r == utf8.RuneError && n == 1 {
 263                 return "", "", errBadUTF8
 264         }
 265         s = s[n:]
 266         switch r {
 267         case 'a':
 268                 return "\a", s, nil
 269         case 'b':
 270                 return "\b", s, nil
 271         case 'f':
 272                 return "\f", s, nil
 273         case 'n':
 274                 return "\n", s, nil
 275         case 'r':
 276                 return "\r", s, nil
 277         case 't':
 278                 return "\t", s, nil
 279         case 'v':
 280                 return "\v", s, nil
 281         case '?':
 282                 return "?", s, nil // trigraph workaround
 283         case '\'', '"', '\\':
 284                 return string(r), s, nil
 285         case '0', '1', '2', '3', '4', '5', '6', '7':
 286                 if len(s) < 2 {
 287                         return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
 288                 }
 289                 ss := string(r) + s[:2]
 290                 s = s[2:]
 291                 i, err := strconv.ParseUint(ss, 8, 8)
 292                 if err != nil {
 293                         return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
 294                 }
 295                 return string([]byte{byte(i)}), s, nil
 296         case 'x', 'X', 'u', 'U':
 297                 var n int
 298                 switch r {
 299                 case 'x', 'X':
 300                         n = 2
 301                 case 'u':
 302                         n = 4
 303                 case 'U':
 304                         n = 8
 305                 }
 306                 if len(s) < n {
 307                         return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
 308                 }
 309                 ss := s[:n]
 310                 s = s[n:]
 311                 i, err := strconv.ParseUint(ss, 16, 64)
 312                 if err != nil {
 313                         return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
 314                 }
 315                 if r == 'x' || r == 'X' {
 316                         return string([]byte{byte(i)}), s, nil
 317                 }
 318                 if i > utf8.MaxRune {
 319                         return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
 320                 }
 321                 return string(i), s, nil
 322         }
 323         return "", "", fmt.Errorf(`unknown escape \%c`, r)
 324 }
 325
 326 // Back off the parser by one token. Can only be done between calls to next().
 327 // It makes the next advance() a no-op.
 328 func (p *textParser) back() { p.backed = true }
 329
 330 // Advances the parser and returns the new current token.
 331 func (p *textParser) next() *token {
 332         if p.backed || p.done {
 333                 p.backed = false
 334                 return &p.cur
 335         }
 336         p.advance()
 337         if p.done {
 338                 p.cur.value = ""
 339         } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
 340                 // Look for multiple quoted strings separated by whitespace,
 341                 // and concatenate them.
 342                 cat := p.cur
 343                 for {
 344                         p.skipWhitespace()
 345                         if p.done || !isQuote(p.s[0]) {
 346                                 break
 347                         }
 348                         p.advance()
 349                         if p.cur.err != nil {
 350                                 return &p.cur
 351                         }
 352                         cat.value += " " + p.cur.value
 353                         cat.unquoted += p.cur.unquoted
 354                 }
 355                 p.done = false // parser may have seen EOF, but we want to return cat
 356                 p.cur = cat
 357         }
 358         return &p.cur
 359 }
 360
 361 func (p *textParser) consumeToken(s string) error {
 362         tok := p.next()
 363         if tok.err != nil {
 364                 return tok.err
 365         }
 366         if tok.value != s {
 367                 p.back()
 368                 return p.errorf("expected %q, found %q", s, tok.value)
 369         }
 370         return nil
 371 }
 372
 373 // Return a RequiredNotSetError indicating which required field was not set.
 374 func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
 375         st := sv.Type()
 376         sprops := GetProperties(st)
 377         for i := 0; i < st.NumField(); i++ {
 378                 if !isNil(sv.Field(i)) {
 379                         continue
 380                 }
 381
 382                 props := sprops.Prop[i]
 383                 if props.Required {
 384                         return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
 385                 }
 386         }
 387         return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
 388 }
 389
 390 // Returns the index in the struct for the named field, as well as the parsed tag properties.
 391 func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
 392         i, ok := sprops.decoderOrigNames[name]
 393         if ok {
 394                 return i, sprops.Prop[i], true
 395         }
 396         return -1, nil, false
 397 }
 398
 399 // Consume a ':' from the input stream (if the next token is a colon),
 400 // returning an error if a colon is needed but not present.
 401 func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
 402         tok := p.next()
 403         if tok.err != nil {
 404                 return tok.err
 405         }
 406         if tok.value != ":" {
 407                 // Colon is optional when the field is a group or message.
 408                 needColon := true
 409                 switch props.Wire {
 410                 case "group":
 411                         needColon = false
 412                 case "bytes":
 413                         // A "bytes" field is either a message, a string, or a repeated field;
 414                         // those three become *T, *string and []T respectively, so we can check for
 415                         // this field being a pointer to a non-string.
 416                         if typ.Kind() == reflect.Ptr {
 417                                 // *T or *string
 418                                 if typ.Elem().Kind() == reflect.String {
 419                                         break
 420                                 }
 421                         } else if typ.Kind() == reflect.Slice {
 422                                 // []T or []*T
 423                                 if typ.Elem().Kind() != reflect.Ptr {
 424                                         break
 425                                 }
 426                         } else if typ.Kind() == reflect.String {
 427                                 // The proto3 exception is for a string field,
 428                                 // which requires a colon.
 429                                 break
 430                         }
 431                         needColon = false
 432                 }
 433                 if needColon {
 434                         return p.errorf("expected ':', found %q", tok.value)
 435                 }
 436                 p.back()
 437         }
 438         return nil
 439 }
 440
 441 func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
 442         st := sv.Type()
 443         sprops := GetProperties(st)
 444         reqCount := sprops.reqCount
 445         var reqFieldErr error
 446         fieldSet := make(map[string]bool)
 447         // A struct is a sequence of "name: value", terminated by one of
 448         // '>' or '}', or the end of the input.  A name may also be
 449         // "[extension]" or "[type/url]".
 450         //
 451         // The whole struct can also be an expanded Any message, like:
 452         // [type/url] < ... struct contents ... >
 453         for {
 454                 tok := p.next()
 455                 if tok.err != nil {
 456                         return tok.err
 457                 }
 458                 if tok.value == terminator {
 459                         break
 460                 }
 461                 if tok.value == "[" {
 462                         // Looks like an extension or an Any.
 463                         //
 464                         // TODO: Check whether we need to handle
 465                         // namespace rooted names (e.g. ".something.Foo").
 466                         extName, err := p.consumeExtName()
 467                         if err != nil {
 468                                 return err
 469                         }
 470
 471                         if s := strings.LastIndex(extName, "/"); s >= 0 {
 472                                 // If it contains a slash, it's an Any type URL.
 473                                 messageName := extName[s+1:]
 474                                 mt := MessageType(messageName)
 475                                 if mt == nil {
 476                                         return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
 477                                 }
 478                                 tok = p.next()
 479                                 if tok.err != nil {
 480                                         return tok.err
 481                                 }
 482                                 // consume an optional colon
 483                                 if tok.value == ":" {
 484                                         tok = p.next()
 485                                         if tok.err != nil {
 486                                                 return tok.err
 487                                         }
 488                                 }
 489                                 var terminator string
 490                                 switch tok.value {
 491                                 case "<":
 492                                         terminator = ">"
 493                                 case "{":
 494                                         terminator = "}"
 495                                 default:
 496                                         return p.errorf("expected '{' or '<', found %q", tok.value)
 497                                 }
 498                                 v := reflect.New(mt.Elem())
 499                                 if pe := p.readStruct(v.Elem(), terminator); pe != nil {
 500                                         return pe
 501                                 }
 502                                 b, err := Marshal(v.Interface().(Message))
 503                                 if err != nil {
 504                                         return p.errorf("failed to marshal message of type %q: %v", messageName, err)
 505                                 }
 506                                 if fieldSet["type_url"] {
 507                                         return p.errorf(anyRepeatedlyUnpacked, "type_url")
 508                                 }
 509                                 if fieldSet["value"] {
 510                                         return p.errorf(anyRepeatedlyUnpacked, "value")
 511                                 }
 512                                 sv.FieldByName("TypeUrl").SetString(extName)
 513                                 sv.FieldByName("Value").SetBytes(b)
 514                                 fieldSet["type_url"] = true
 515                                 fieldSet["value"] = true
 516                                 continue
 517                         }
 518
 519                         var desc *ExtensionDesc
 520                         // This could be faster, but it's functional.
 521                         // TODO: Do something smarter than a linear scan.
 522                         for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
 523                                 if d.Name == extName {
 524                                         desc = d
 525                                         break
 526                                 }
 527                         }
 528                         if desc == nil {
 529                                 return p.errorf("unrecognized extension %q", extName)
 530                         }
 531
 532                         props := &Properties{}
 533                         props.Parse(desc.Tag)
 534
 535                         typ := reflect.TypeOf(desc.ExtensionType)
 536                         if err := p.checkForColon(props, typ); err != nil {
 537                                 return err
 538                         }
 539
 540                         rep := desc.repeated()
 541
 542                         // Read the extension structure, and set it in
 543                         // the value we're constructing.
 544                         var ext reflect.Value
 545                         if !rep {
 546                                 ext = reflect.New(typ).Elem()
 547                         } else {
 548                                 ext = reflect.New(typ.Elem()).Elem()
 549                         }
 550                         if err := p.readAny(ext, props); err != nil {
 551                                 if _, ok := err.(*RequiredNotSetError); !ok {
 552                                         return err
 553                                 }
 554                                 reqFieldErr = err
 555                         }
 556                         ep := sv.Addr().Interface().(Message)
 557                         if !rep {
 558                                 SetExtension(ep, desc, ext.Interface())
 559                         } else {
 560                                 old, err := GetExtension(ep, desc)
 561                                 var sl reflect.Value
 562                                 if err == nil {
 563                                         sl = reflect.ValueOf(old) // existing slice
 564                                 } else {
 565                                         sl = reflect.MakeSlice(typ, 0, 1)
 566                                 }
 567                                 sl = reflect.Append(sl, ext)
 568                                 SetExtension(ep, desc, sl.Interface())
 569                         }
 570                         if err := p.consumeOptionalSeparator(); err != nil {
 571                                 return err
 572                         }
 573                         continue
 574                 }
 575
 576                 // This is a normal, non-extension field.
 577                 name := tok.value
 578                 var dst reflect.Value
 579                 fi, props, ok := structFieldByName(sprops, name)
 580                 if ok {
 581                         dst = sv.Field(fi)
 582                 } else if oop, ok := sprops.OneofTypes[name]; ok {
 583                         // It is a oneof.
 584                         props = oop.Prop
 585                         nv := reflect.New(oop.Type.Elem())
 586                         dst = nv.Elem().Field(0)
 587                         field := sv.Field(oop.Field)
 588                         if !field.IsNil() {
 589                                 return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
 590                         }
 591                         field.Set(nv)
 592                 }
 593                 if !dst.IsValid() {
 594                         return p.errorf("unknown field name %q in %v", name, st)
 595                 }
 596
 597                 if dst.Kind() == reflect.Map {
 598                         // Consume any colon.
 599                         if err := p.checkForColon(props, dst.Type()); err != nil {
 600                                 return err
 601                         }
 602
 603                         // Construct the map if it doesn't already exist.
 604                         if dst.IsNil() {
 605                                 dst.Set(reflect.MakeMap(dst.Type()))
 606                         }
 607                         key := reflect.New(dst.Type().Key()).Elem()
 608                         val := reflect.New(dst.Type().Elem()).Elem()
 609
 610                         // The map entry should be this sequence of tokens:
 611                         //      < key : KEY value : VALUE >
 612                         // However, implementations may omit key or value, and technically
 613                         // we should support them in any order.  See b/28924776 for a time
 614                         // this went wrong.
 615
 616                         tok := p.next()
 617                         var terminator string
 618                         switch tok.value {
 619                         case "<":
 620                                 terminator = ">"
 621                         case "{":
 622                                 terminator = "}"
 623                         default:
 624                                 return p.errorf("expected '{' or '<', found %q", tok.value)
 625                         }
 626                         for {
 627                                 tok := p.next()
 628                                 if tok.err != nil {
 629                                         return tok.err
 630                                 }
 631                                 if tok.value == terminator {
 632                                         break
 633                                 }
 634                                 switch tok.value {
 635                                 case "key":
 636                                         if err := p.consumeToken(":"); err != nil {
 637                                                 return err
 638                                         }
 639                                         if err := p.readAny(key, props.MapKeyProp); err != nil {
 640                                                 return err
 641                                         }
 642                                         if err := p.consumeOptionalSeparator(); err != nil {
 643                                                 return err
 644                                         }
 645                                 case "value":
 646                                         if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
 647                                                 return err
 648                                         }
 649                                         if err := p.readAny(val, props.MapValProp); err != nil {
 650                                                 return err
 651                                         }
 652                                         if err := p.consumeOptionalSeparator(); err != nil {
 653                                                 return err
 654                                         }
 655                                 default:
 656                                         p.back()
 657                                         return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
 658                                 }
 659                         }
 660
 661                         dst.SetMapIndex(key, val)
 662                         continue
 663                 }
 664
 665                 // Check that it's not already set if it's not a repeated field.
 666                 if !props.Repeated && fieldSet[name] {
 667                         return p.errorf("non-repeated field %q was repeated", name)
 668                 }
 669
 670                 if err := p.checkForColon(props, dst.Type()); err != nil {
 671                         return err
 672                 }
 673
 674                 // Parse into the field.
 675                 fieldSet[name] = true
 676                 if err := p.readAny(dst, props); err != nil {
 677                         if _, ok := err.(*RequiredNotSetError); !ok {
 678                                 return err
 679                         }
 680                         reqFieldErr = err
 681                 }
 682                 if props.Required {
 683                         reqCount--
 684                 }
 685
 686                 if err := p.consumeOptionalSeparator(); err != nil {
 687                         return err
 688                 }
 689
 690         }
 691
 692         if reqCount > 0 {
 693                 return p.missingRequiredFieldError(sv)
 694         }
 695         return reqFieldErr
 696 }
 697
 698 // consumeExtName consumes extension name or expanded Any type URL and the
 699 // following ']'. It returns the name or URL consumed.
 700 func (p *textParser) consumeExtName() (string, error) {
 701         tok := p.next()
 702         if tok.err != nil {
 703                 return "", tok.err
 704         }
 705
 706         // If extension name or type url is quoted, it's a single token.
 707         if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
 708                 name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
 709                 if err != nil {
 710                         return "", err
 711                 }
 712                 return name, p.consumeToken("]")
 713         }
 714
 715         // Consume everything up to "]"
 716         var parts []string
 717         for tok.value != "]" {
 718                 parts = append(parts, tok.value)
 719                 tok = p.next()
 720                 if tok.err != nil {
 721                         return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
 722                 }
 723                 if p.done && tok.value != "]" {
 724                         return "", p.errorf("unclosed type_url or extension name")
 725                 }
 726         }
 727         return strings.Join(parts, ""), nil
 728 }
 729
 730 // consumeOptionalSeparator consumes an optional semicolon or comma.
 731 // It is used in readStruct to provide backward compatibility.
 732 func (p *textParser) consumeOptionalSeparator() error {
 733         tok := p.next()
 734         if tok.err != nil {
 735                 return tok.err
 736         }
 737         if tok.value != ";" && tok.value != "," {
 738                 p.back()
 739         }
 740         return nil
 741 }
 742
 743 func (p *textParser) readAny(v reflect.Value, props *Properties) error {
 744         tok := p.next()
 745         if tok.err != nil {
 746                 return tok.err
 747         }
 748         if tok.value == "" {
 749                 return p.errorf("unexpected EOF")
 750         }
 751         if len(props.CustomType) > 0 {
 752                 if props.Repeated {
 753                         t := reflect.TypeOf(v.Interface())
 754                         if t.Kind() == reflect.Slice {
 755                                 tc := reflect.TypeOf(new(Marshaler))
 756                                 ok := t.Elem().Implements(tc.Elem())
 757                                 if ok {
 758                                         fv := v
 759                                         flen := fv.Len()
 760                                         if flen == fv.Cap() {
 761                                                 nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1)
 762                                                 reflect.Copy(nav, fv)
 763                                                 fv.Set(nav)
 764                                         }
 765                                         fv.SetLen(flen + 1)
 766
 767                                         // Read one.
 768                                         p.back()
 769                                         return p.readAny(fv.Index(flen), props)
 770                                 }
 771                         }
 772                 }
 773                 if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
 774                         custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler)
 775                         err := custom.Unmarshal([]byte(tok.unquoted))
 776                         if err != nil {
 777                                 return p.errorf("%v %v: %v", err, v.Type(), tok.value)
 778                         }
 779                         v.Set(reflect.ValueOf(custom))
 780                 } else {
 781                         custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler)
 782                         err := custom.Unmarshal([]byte(tok.unquoted))
 783                         if err != nil {
 784                                 return p.errorf("%v %v: %v", err, v.Type(), tok.value)
 785                         }
 786                         v.Set(reflect.Indirect(reflect.ValueOf(custom)))
 787                 }
 788                 return nil
 789         }
 790         if props.StdTime {
 791                 fv := v
 792                 p.back()
 793                 props.StdTime = false
 794                 tproto := &timestamp{}
 795                 err := p.readAny(reflect.ValueOf(tproto).Elem(), props)
 796                 props.StdTime = true
 797                 if err != nil {
 798                         return err
 799                 }
 800                 tim, err := timestampFromProto(tproto)
 801                 if err != nil {
 802                         return err
 803                 }
 804                 if props.Repeated {
 805                         t := reflect.TypeOf(v.Interface())
 806                         if t.Kind() == reflect.Slice {
 807                                 if t.Elem().Kind() == reflect.Ptr {
 808                                         ts := fv.Interface().([]*time.Time)
 809                                         ts = append(ts, &tim)
 810                                         fv.Set(reflect.ValueOf(ts))
 811                                         return nil
 812                                 } else {
 813                                         ts := fv.Interface().([]time.Time)
 814                                         ts = append(ts, tim)
 815                                         fv.Set(reflect.ValueOf(ts))
 816                                         return nil
 817                                 }
 818                         }
 819                 }
 820                 if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
 821                         v.Set(reflect.ValueOf(&tim))
 822                 } else {
 823                         v.Set(reflect.Indirect(reflect.ValueOf(&tim)))
 824                 }
 825                 return nil
 826         }
 827         if props.StdDuration {
 828                 fv := v
 829                 p.back()
 830                 props.StdDuration = false
 831                 dproto := &duration{}
 832                 err := p.readAny(reflect.ValueOf(dproto).Elem(), props)
 833                 props.StdDuration = true
 834                 if err != nil {
 835                         return err
 836                 }
 837                 dur, err := durationFromProto(dproto)
 838                 if err != nil {
 839                         return err
 840                 }
 841                 if props.Repeated {
 842                         t := reflect.TypeOf(v.Interface())
 843                         if t.Kind() == reflect.Slice {
 844                                 if t.Elem().Kind() == reflect.Ptr {
 845                                         ds := fv.Interface().([]*time.Duration)
 846                                         ds = append(ds, &dur)
 847                                         fv.Set(reflect.ValueOf(ds))
 848                                         return nil
 849                                 } else {
 850                                         ds := fv.Interface().([]time.Duration)
 851                                         ds = append(ds, dur)
 852                                         fv.Set(reflect.ValueOf(ds))
 853                                         return nil
 854                                 }
 855                         }
 856                 }
 857                 if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
 858                         v.Set(reflect.ValueOf(&dur))
 859                 } else {
 860                         v.Set(reflect.Indirect(reflect.ValueOf(&dur)))
 861                 }
 862                 return nil
 863         }
 864         switch fv := v; fv.Kind() {
 865         case reflect.Slice:
 866                 at := v.Type()
 867                 if at.Elem().Kind() == reflect.Uint8 {
 868                         // Special case for []byte
 869                         if tok.value[0] != '"' && tok.value[0] != '\'' {
 870                                 // Deliberately written out here, as the error after
 871                                 // this switch statement would write "invalid []byte: ...",
 872                                 // which is not as user-friendly.
 873                                 return p.errorf("invalid string: %v", tok.value)
 874                         }
 875                         bytes := []byte(tok.unquoted)
 876                         fv.Set(reflect.ValueOf(bytes))
 877                         return nil
 878                 }
 879                 // Repeated field.
 880                 if tok.value == "[" {
 881                         // Repeated field with list notation, like [1,2,3].
 882                         for {
 883                                 fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
 884                                 err := p.readAny(fv.Index(fv.Len()-1), props)
 885                                 if err != nil {
 886                                         return err
 887                                 }
 888                                 ntok := p.next()
 889                                 if ntok.err != nil {
 890                                         return ntok.err
 891                                 }
 892                                 if ntok.value == "]" {
 893                                         break
 894                                 }
 895                                 if ntok.value != "," {
 896                                         return p.errorf("Expected ']' or ',' found %q", ntok.value)
 897                                 }
 898                         }
 899                         return nil
 900                 }
 901                 // One value of the repeated field.
 902                 p.back()
 903                 fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
 904                 return p.readAny(fv.Index(fv.Len()-1), props)
 905         case reflect.Bool:
 906                 // true/1/t/True or false/f/0/False.
 907                 switch tok.value {
 908                 case "true", "1", "t", "True":
 909                         fv.SetBool(true)
 910                         return nil
 911                 case "false", "0", "f", "False":
 912                         fv.SetBool(false)
 913                         return nil
 914                 }
 915         case reflect.Float32, reflect.Float64:
 916                 v := tok.value
 917                 // Ignore 'f' for compatibility with output generated by C++, but don't
 918                 // remove 'f' when the value is "-inf" or "inf".
 919                 if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
 920                         v = v[:len(v)-1]
 921                 }
 922                 if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
 923                         fv.SetFloat(f)
 924                         return nil
 925                 }
 926         case reflect.Int8:
 927                 if x, err := strconv.ParseInt(tok.value, 0, 8); err == nil {
 928                         fv.SetInt(x)
 929                         return nil
 930                 }
 931         case reflect.Int16:
 932                 if x, err := strconv.ParseInt(tok.value, 0, 16); err == nil {
 933                         fv.SetInt(x)
 934                         return nil
 935                 }
 936         case reflect.Int32:
 937                 if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
 938                         fv.SetInt(x)
 939                         return nil
 940                 }
 941
 942                 if len(props.Enum) == 0 {
 943                         break
 944                 }
 945                 m, ok := enumValueMaps[props.Enum]
 946                 if !ok {
 947                         break
 948                 }
 949                 x, ok := m[tok.value]
 950                 if !ok {
 951                         break
 952                 }
 953                 fv.SetInt(int64(x))
 954                 return nil
 955         case reflect.Int64:
 956                 if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
 957                         fv.SetInt(x)
 958                         return nil
 959                 }
 960
 961         case reflect.Ptr:
 962                 // A basic field (indirected through pointer), or a repeated message/group
 963                 p.back()
 964                 fv.Set(reflect.New(fv.Type().Elem()))
 965                 return p.readAny(fv.Elem(), props)
 966         case reflect.String:
 967                 if tok.value[0] == '"' || tok.value[0] == '\'' {
 968                         fv.SetString(tok.unquoted)
 969                         return nil
 970                 }
 971         case reflect.Struct:
 972                 var terminator string
 973                 switch tok.value {
 974                 case "{":
 975                         terminator = "}"
 976                 case "<":
 977                         terminator = ">"
 978                 default:
 979                         return p.errorf("expected '{' or '<', found %q", tok.value)
 980                 }
 981                 // TODO: Handle nested messages which implement encoding.TextUnmarshaler.
 982                 return p.readStruct(fv, terminator)
 983         case reflect.Uint8:
 984                 if x, err := strconv.ParseUint(tok.value, 0, 8); err == nil {
 985                         fv.SetUint(x)
 986                         return nil
 987                 }
 988         case reflect.Uint16:
 989                 if x, err := strconv.ParseUint(tok.value, 0, 16); err == nil {
 990                         fv.SetUint(x)
 991                         return nil
 992                 }
 993         case reflect.Uint32:
 994                 if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
 995                         fv.SetUint(uint64(x))
 996                         return nil
 997                 }
 998         case reflect.Uint64:
 999                 if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
1000                         fv.SetUint(x)
1001                         return nil
1002                 }
1003         }
1004         return p.errorf("invalid %v: %v", v.Type(), tok.value)
1005 }
1006
1007 // UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
1008 // before starting to unmarshal, so any existing data in pb is always removed.
1009 // If a required field is not set and no other error occurs,
1010 // UnmarshalText returns *RequiredNotSetError.
1011 func UnmarshalText(s string, pb Message) error {
1012         if um, ok := pb.(encoding.TextUnmarshaler); ok {
1013                 return um.UnmarshalText([]byte(s))
1014         }
1015         pb.Reset()
1016         v := reflect.ValueOf(pb)
1017         return newTextParser(s).readStruct(v.Elem(), "")
1018 }