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 defval marshals and unmarshals textual forms of default values.
6 //
7 // This package handles both the form historically used in Go struct field tags
8 // and also the form used by google.protobuf.FieldDescriptorProto.default_value
9 // since they differ in superficial ways.
10 package defval
11 12 import (
13 "fmt"
14 "math"
15 "strconv"
16 17 ptext "google.golang.org/protobuf/internal/encoding/text"
18 "google.golang.org/protobuf/internal/errors"
19 "google.golang.org/protobuf/reflect/protoreflect"
20 )
21 22 // Format is the serialization format used to represent the default value.
23 type Format int
24 25 const (
26 _ Format = iota
27 28 // Descriptor uses the serialization format that protoc uses with the
29 // google.protobuf.FieldDescriptorProto.default_value field.
30 Descriptor
31 32 // GoTag uses the historical serialization format in Go struct field tags.
33 GoTag
34 )
35 36 // Unmarshal deserializes the default string s according to the given kind k.
37 // When k is an enum, a list of enum value descriptors must be provided.
38 func Unmarshal(s string, k protoreflect.Kind, evs protoreflect.EnumValueDescriptors, f Format) (protoreflect.Value, protoreflect.EnumValueDescriptor, error) {
39 switch k {
40 case protoreflect.BoolKind:
41 if f == GoTag {
42 switch s {
43 case "1":
44 return protoreflect.ValueOfBool(true), nil, nil
45 case "0":
46 return protoreflect.ValueOfBool(false), nil, nil
47 }
48 } else {
49 switch s {
50 case "true":
51 return protoreflect.ValueOfBool(true), nil, nil
52 case "false":
53 return protoreflect.ValueOfBool(false), nil, nil
54 }
55 }
56 case protoreflect.EnumKind:
57 if f == GoTag {
58 // Go tags use the numeric form of the enum value.
59 if n, err := strconv.ParseInt(s, 10, 32); err == nil {
60 if ev := evs.ByNumber(protoreflect.EnumNumber(n)); ev != nil {
61 return protoreflect.ValueOfEnum(ev.Number()), ev, nil
62 }
63 }
64 } else {
65 // Descriptor default_value use the enum identifier.
66 ev := evs.ByName(protoreflect.Name(s))
67 if ev != nil {
68 return protoreflect.ValueOfEnum(ev.Number()), ev, nil
69 }
70 }
71 case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
72 if v, err := strconv.ParseInt(s, 10, 32); err == nil {
73 return protoreflect.ValueOfInt32(int32(v)), nil, nil
74 }
75 case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
76 if v, err := strconv.ParseInt(s, 10, 64); err == nil {
77 return protoreflect.ValueOfInt64(int64(v)), nil, nil
78 }
79 case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
80 if v, err := strconv.ParseUint(s, 10, 32); err == nil {
81 return protoreflect.ValueOfUint32(uint32(v)), nil, nil
82 }
83 case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
84 if v, err := strconv.ParseUint(s, 10, 64); err == nil {
85 return protoreflect.ValueOfUint64(uint64(v)), nil, nil
86 }
87 case protoreflect.FloatKind, protoreflect.DoubleKind:
88 var v float64
89 var err error
90 switch s {
91 case "-inf":
92 v = math.Inf(-1)
93 case "inf":
94 v = math.Inf(+1)
95 case "nan":
96 v = math.NaN()
97 default:
98 v, err = strconv.ParseFloat(s, 64)
99 }
100 if err == nil {
101 if k == protoreflect.FloatKind {
102 return protoreflect.ValueOfFloat32(float32(v)), nil, nil
103 } else {
104 return protoreflect.ValueOfFloat64(float64(v)), nil, nil
105 }
106 }
107 case protoreflect.StringKind:
108 // String values are already unescaped and can be used as is.
109 return protoreflect.ValueOfString(s), nil, nil
110 case protoreflect.BytesKind:
111 if b, ok := unmarshalBytes(s); ok {
112 return protoreflect.ValueOfBytes(b), nil, nil
113 }
114 }
115 return protoreflect.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
116 }
117 118 // Marshal serializes v as the default string according to the given kind k.
119 // When specifying the Descriptor format for an enum kind, the associated
120 // enum value descriptor must be provided.
121 func Marshal(v protoreflect.Value, ev protoreflect.EnumValueDescriptor, k protoreflect.Kind, f Format) (string, error) {
122 switch k {
123 case protoreflect.BoolKind:
124 if f == GoTag {
125 if v.Bool() {
126 return "1", nil
127 } else {
128 return "0", nil
129 }
130 } else {
131 if v.Bool() {
132 return "true", nil
133 } else {
134 return "false", nil
135 }
136 }
137 case protoreflect.EnumKind:
138 if f == GoTag {
139 return strconv.FormatInt(int64(v.Enum()), 10), nil
140 } else {
141 return string(ev.Name()), nil
142 }
143 case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
144 return strconv.FormatInt(v.Int(), 10), nil
145 case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
146 return strconv.FormatUint(v.Uint(), 10), nil
147 case protoreflect.FloatKind, protoreflect.DoubleKind:
148 f := v.Float()
149 switch {
150 case math.IsInf(f, -1):
151 return "-inf", nil
152 case math.IsInf(f, +1):
153 return "inf", nil
154 case math.IsNaN(f):
155 return "nan", nil
156 default:
157 if k == protoreflect.FloatKind {
158 return strconv.FormatFloat(f, 'g', -1, 32), nil
159 } else {
160 return strconv.FormatFloat(f, 'g', -1, 64), nil
161 }
162 }
163 case protoreflect.StringKind:
164 // String values are serialized as is without any escaping.
165 return v.String(), nil
166 case protoreflect.BytesKind:
167 if s, ok := marshalBytes(v.Bytes()); ok {
168 return s, nil
169 }
170 }
171 return "", errors.New("could not format value for %v: %v", k, v)
172 }
173 174 // unmarshalBytes deserializes bytes by applying C unescaping.
175 func unmarshalBytes(s string) ([]byte, bool) {
176 // Bytes values use the same escaping as the text format,
177 // however they lack the surrounding double quotes.
178 v, err := ptext.UnmarshalString(`"` + s + `"`)
179 if err != nil {
180 return nil, false
181 }
182 return []byte(v), true
183 }
184 185 // marshalBytes serializes bytes by using C escaping.
186 // To match the exact output of protoc, this is identical to the
187 // CEscape function in strutil.cc of the protoc source code.
188 func marshalBytes(b []byte) (string, bool) {
189 var s []byte
190 for _, c := range b {
191 switch c {
192 case '\n':
193 s = append(s, `\n`...)
194 case '\r':
195 s = append(s, `\r`...)
196 case '\t':
197 s = append(s, `\t`...)
198 case '"':
199 s = append(s, `\"`...)
200 case '\'':
201 s = append(s, `\'`...)
202 case '\\':
203 s = append(s, `\\`...)
204 default:
205 if printableASCII := c >= 0x20 && c <= 0x7e; printableASCII {
206 s = append(s, c)
207 } else {
208 s = append(s, fmt.Sprintf(`\%03o`, c)...)
209 }
210 }
211 }
212 return string(s), true
213 }
214