decode_string.go

Documentation: google.golang.org/protobuf/internal/encoding/text

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package text
     6  
     7  import (
     8  	"bytes"
     9  	"strconv"
    10  	"strings"
    11  	"unicode"
    12  	"unicode/utf16"
    13  	"unicode/utf8"
    14  
    15  	"google.golang.org/protobuf/internal/strs"
    16  )
    17  
    18  // parseStringValue parses string field token.
    19  // This differs from parseString since the text format allows
    20  // multiple back-to-back string literals where they are semantically treated
    21  // as a single large string with all values concatenated.
    22  //
    23  // E.g., `"foo" "bar" "baz"` => "foobarbaz"
    24  func (d *Decoder) parseStringValue() (Token, error) {
    25  	// Note that the ending quote is sufficient to unambiguously mark the end
    26  	// of a string. Thus, the text grammar does not require intervening
    27  	// whitespace or control characters in-between strings.
    28  	// Thus, the following is valid:
    29  	//	`"foo"'bar'"baz"` => "foobarbaz"
    30  	in0 := d.in
    31  	var ss []string
    32  	for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
    33  		s, err := d.parseString()
    34  		if err != nil {
    35  			return Token{}, err
    36  		}
    37  		ss = append(ss, s)
    38  	}
    39  	// d.in already points to the end of the value at this point.
    40  	return Token{
    41  		kind:  Scalar,
    42  		attrs: stringValue,
    43  		pos:   len(d.orig) - len(in0),
    44  		raw:   in0[:len(in0)-len(d.in)],
    45  		str:   strings.Join(ss, ""),
    46  	}, nil
    47  }
    48  
    49  // parseString parses a string value enclosed in " or '.
    50  func (d *Decoder) parseString() (string, error) {
    51  	in := d.in
    52  	if len(in) == 0 {
    53  		return "", ErrUnexpectedEOF
    54  	}
    55  	quote := in[0]
    56  	in = in[1:]
    57  	i := indexNeedEscapeInBytes(in)
    58  	in, out := in[i:], in[:i:i] // set cap to prevent mutations
    59  	for len(in) > 0 {
    60  		switch r, n := utf8.DecodeRune(in); {
    61  		case r == utf8.RuneError && n == 1:
    62  			return "", d.newSyntaxError("invalid UTF-8 detected")
    63  		case r == 0 || r == '\n':
    64  			return "", d.newSyntaxError("invalid character %q in string", r)
    65  		case r == rune(quote):
    66  			in = in[1:]
    67  			d.consume(len(d.in) - len(in))
    68  			return string(out), nil
    69  		case r == '\\':
    70  			if len(in) < 2 {
    71  				return "", ErrUnexpectedEOF
    72  			}
    73  			switch r := in[1]; r {
    74  			case '"', '\'', '\\', '?':
    75  				in, out = in[2:], append(out, r)
    76  			case 'a':
    77  				in, out = in[2:], append(out, '\a')
    78  			case 'b':
    79  				in, out = in[2:], append(out, '\b')
    80  			case 'n':
    81  				in, out = in[2:], append(out, '\n')
    82  			case 'r':
    83  				in, out = in[2:], append(out, '\r')
    84  			case 't':
    85  				in, out = in[2:], append(out, '\t')
    86  			case 'v':
    87  				in, out = in[2:], append(out, '\v')
    88  			case 'f':
    89  				in, out = in[2:], append(out, '\f')
    90  			case '0', '1', '2', '3', '4', '5', '6', '7':
    91  				// One, two, or three octal characters.
    92  				n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
    93  				if n > 3 {
    94  					n = 3
    95  				}
    96  				v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
    97  				if err != nil {
    98  					return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
    99  				}
   100  				in, out = in[1+n:], append(out, byte(v))
   101  			case 'x':
   102  				// One or two hexadecimal characters.
   103  				n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
   104  				if n > 2 {
   105  					n = 2
   106  				}
   107  				v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
   108  				if err != nil {
   109  					return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
   110  				}
   111  				in, out = in[2+n:], append(out, byte(v))
   112  			case 'u', 'U':
   113  				// Four or eight hexadecimal characters
   114  				n := 6
   115  				if r == 'U' {
   116  					n = 10
   117  				}
   118  				if len(in) < n {
   119  					return "", ErrUnexpectedEOF
   120  				}
   121  				v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
   122  				if utf8.MaxRune < v || err != nil {
   123  					return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
   124  				}
   125  				in = in[n:]
   126  
   127  				r := rune(v)
   128  				if utf16.IsSurrogate(r) {
   129  					if len(in) < 6 {
   130  						return "", ErrUnexpectedEOF
   131  					}
   132  					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
   133  					r = utf16.DecodeRune(r, rune(v))
   134  					if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
   135  						return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
   136  					}
   137  					in = in[6:]
   138  				}
   139  				out = append(out, string(r)...)
   140  			default:
   141  				return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
   142  			}
   143  		default:
   144  			i := indexNeedEscapeInBytes(in[n:])
   145  			in, out = in[n+i:], append(out, in[:n+i]...)
   146  		}
   147  	}
   148  	return "", ErrUnexpectedEOF
   149  }
   150  
   151  // indexNeedEscapeInString returns the index of the character that needs
   152  // escaping. If no characters need escaping, this returns the input length.
   153  func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
   154  
   155  // UnmarshalString returns an unescaped string given a textproto string value.
   156  // String value needs to contain single or double quotes. This is only used by
   157  // internal/encoding/defval package for unmarshaling bytes.
   158  func UnmarshalString(s string) (string, error) {
   159  	d := NewDecoder([]byte(s))
   160  	return d.parseString()
   161  }
   162
View as plain text