// This sets the value in a struct of an indeterminate type to the
// matching value from the request (via Form middleware) in the
// same type, so that not all deserialized values have to be strings.
// Supported types are string, int, float, and bool.
func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value, nameInTag string, errors Errors) {
if scan, ok := structField.Addr().Interface().(sql.Scanner); ok {
scan.Scan(val)
return
}
switch valueKind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if val == "" {
val = "0"
}
intVal, err := strconv.ParseInt(val, 10, 64)
if err != nil {
errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as integer")
} else {
structField.SetInt(intVal)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if val == "" {
val = "0"
}
uintVal, err := strconv.ParseUint(val, 10, 64)
if err != nil {
errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as unsigned integer")
} else {
structField.SetUint(uintVal)
}
case reflect.Bool:
if val == "" {
val = "false"
}
boolVal, err := strconv.ParseBool(val)
if err != nil {
errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as boolean")
} else {
structField.SetBool(boolVal)
}
case reflect.Float32:
if val == "" {
val = "0.0"
}
floatVal, err := strconv.ParseFloat(val, 32)
if err != nil {
errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as 32-bit float")
} else {
structField.SetFloat(floatVal)
}
case reflect.Float64:
if val == "" {
val = "0.0"
}
floatVal, err := strconv.ParseFloat(val, 64)
if err != nil {
errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as 64-bit float")
} else {
structField.SetFloat(floatVal)
}
case reflect.String:
structField.SetString(val)
}
}
func parseAndSet(target reflect.Value, val string) error {
if !target.CanSet() {
return fmt.Errorf("Cannot set %v to %v", target, val)
}
switch kind := target.Type().Kind(); kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
intVal, err := strconv.ParseInt(val, 10, 64)
if err == nil {
target.SetInt(intVal)
}
return err
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
intVal, err := strconv.ParseUint(val, 10, 64)
if err == nil {
target.SetUint(intVal)
}
return err
case reflect.Float32, reflect.Float64:
floatVal, err := strconv.ParseFloat(val, 64)
if err == nil {
target.SetFloat(floatVal)
}
return err
case reflect.String:
target.SetString(val)
return nil
}
return fmt.Errorf("Field %v has type %v, cannot set to %v", target, target.Type(), val)
}
func setValue(elmv *reflect.Value, f Field) {
switch f.Kind {
case "int", "int64", "long":
itemValue, innerr := strconv.ParseInt(f.Value, 10, 64)
if innerr != nil {
itemValue = 0
}
elmv.SetInt(itemValue)
case "float", "float64", "double":
itemValue, innerr := strconv.ParseFloat(f.Value, 64)
if innerr != nil {
itemValue = 0
}
elmv.SetFloat(itemValue)
case "bool":
itemValue, innerr := strconv.ParseBool(f.Value)
if innerr != nil {
itemValue = false
}
elmv.SetBool(itemValue)
default:
itemValue := f.Value
elmv.SetString(itemValue)
}
}
// Fill a single reflected field if it has the conf tag.
//
func (c *Config) getField(elem reflect.Value, group, key string) {
var e error
switch elem.Interface().(type) {
case bool:
var val bool
val, e = c.Bool(group, key)
elem.SetBool(val)
case int:
var val int
val, e = c.Int(group, key)
elem.SetInt(int64(val))
case string:
var val string
val, e = c.String(group, key)
elem.SetString(val)
case float64:
var val float64
val, e = c.Float(group, key)
elem.SetFloat(val)
default:
c.logError(errors.New("Parse conf: wrong type: " + elem.Kind().String()))
}
if e != nil {
c.logError(errors.New("Parse conf: " + e.Error()))
}
}
func (d *Decoder) decodeString(s *string, v reflect.Value, fieldTag tag) error {
if fieldTag.AsString {
return d.decodeNumber(s, v)
}
// To maintain backwards compatibility with ConvertFrom family of methods which
// converted strings to time.Time structs
if _, ok := v.Interface().(time.Time); ok {
t, err := time.Parse(time.RFC3339, *s)
if err != nil {
return err
}
v.Set(reflect.ValueOf(t))
return nil
}
switch v.Kind() {
case reflect.String:
v.SetString(*s)
case reflect.Interface:
// Ensure type aliasing is handled properly
v.Set(reflect.ValueOf(*s).Convert(v.Type()))
default:
return &UnmarshalTypeError{Value: "string", Type: v.Type()}
}
return nil
}
func (f *Field) Unpack(buf []byte, val reflect.Value, length int, options *Options) error {
typ := f.Type.Resolve(options)
if typ == Pad || f.kind == reflect.String {
if typ == Pad {
return nil
} else {
val.SetString(string(buf))
return nil
}
} else if f.Slice {
if val.Cap() < length {
val.Set(reflect.MakeSlice(val.Type(), length, length))
} else if val.Len() < length {
val.Set(val.Slice(0, length))
}
// special case byte slices for performance
if !f.Array && typ == Uint8 && f.defType == Uint8 {
copy(val.Bytes(), buf[:length])
return nil
}
pos := 0
size := typ.Size()
for i := 0; i < length; i++ {
if err := f.unpackVal(buf[pos:pos+size], val.Index(i), 1, options); err != nil {
return err
}
pos += size
}
return nil
} else {
return f.unpackVal(buf, val, length, options)
}
}
func (defaultMarshaler) Marshal(v reflect.Value, s string) error {
if v.Kind() == reflect.Slice {
n := reflect.New(v.Type().Elem())
m := valueMarshaler(n.Elem())
err := m.Marshal(n.Elem(), s)
if err != nil {
return err
}
v.Set(reflect.Append(v, n.Elem()))
return nil
}
switch v.Kind() {
case reflect.Int:
x, err := strconv.ParseInt(s, 0, 0)
v.SetInt(x)
return err
case reflect.Uint:
x, err := strconv.ParseUint(s, 0, 0)
v.SetUint(x)
return err
case reflect.Int64:
x, err := strconv.ParseInt(s, 0, 64)
v.SetInt(x)
return err
case reflect.String:
v.SetString(s)
return nil
default:
return fmt.Errorf("unhandled builtin type: %s", v.Type().String())
}
}
func setFieldDefaults(v reflect.Value, sf reflect.StructField, s reflect.Value) {
if v.CanInterface() && reflect.DeepEqual(
v.Interface(), reflect.Zero(v.Type()).Interface()) {
tag := sf.Tag.Get("ebmldef")
if tag != "" {
switch v.Kind() {
case reflect.Int, reflect.Int64:
u, _ := strconv.ParseInt(tag, 10, 0)
v.SetInt(int64(u))
case reflect.Uint, reflect.Uint64:
u, _ := strconv.ParseUint(tag, 10, 0)
v.SetUint(u)
case reflect.Float32, reflect.Float64:
f, _ := strconv.ParseFloat(tag, 64)
v.SetFloat(f)
case reflect.String:
v.SetString(tag)
default:
log.Panic("Unsupported default value")
}
}
ltag := sf.Tag.Get("ebmldeflink")
if ltag != "" {
v.Set(s.FieldByName(ltag))
}
}
}
func (e *Element) readField(v reflect.Value) (err error) {
switch v.Kind() {
case reflect.Struct:
err = e.readStruct(v)
case reflect.Slice:
err = e.readSlice(v)
case reflect.Array:
for i, l := 0, v.Len(); i < l && err == nil; i++ {
err = e.readStruct(v.Index(i))
}
case reflect.String:
var s string
s, err = e.readString()
v.SetString(s)
case reflect.Int, reflect.Int64:
var u uint64
u, err = e.readUint64()
v.SetInt(int64(u))
case reflect.Uint, reflect.Uint64:
var u uint64
u, err = e.readUint64()
v.SetUint(u)
case reflect.Float32, reflect.Float64:
var f float64
f, err = e.readFloat()
v.SetFloat(f)
default:
err = errors.New("Unknown type: " + v.String())
}
return
}
// setValue updates the field value in fv to the data extracted from config
// with key.
func setValue(fv *reflect.Value, c *Config, key string) error {
// Update the value with the correct type
switch fv.Kind() {
case reflect.Int:
val, err := c.GetInt(key)
if err != nil {
return err
}
fv.SetInt(int64(val))
case reflect.Float64:
val, err := c.GetFloat(key)
if err != nil {
return err
}
fv.SetFloat(val)
case reflect.Bool:
val, err := c.GetBool(key)
if err != nil {
return err
}
fv.SetBool(val)
case reflect.String:
val, err := c.GetString(key)
if err != nil {
return err
}
fv.SetString(val)
}
return nil
}
// setWithProperType sets proper value to field based on its type,
// but it does not return error for failing parsing,
// because we want to use default value that is already assigned to strcut.
func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error {
switch t.Kind() {
case reflect.String:
if len(key.String()) == 0 {
return nil
}
field.SetString(key.String())
case reflect.Bool:
boolVal, err := key.Bool()
if err != nil {
return nil
}
field.SetBool(boolVal)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
durationVal, err := key.Duration()
// Skip zero value
if err == nil && int(durationVal) > 0 {
field.Set(reflect.ValueOf(durationVal))
return nil
}
intVal, err := key.Int64()
if err != nil || intVal == 0 {
return nil
}
field.SetInt(intVal)
// byte is an alias for uint8, so supporting uint8 breaks support for byte
case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
durationVal, err := key.Duration()
// Skip zero value
if err == nil && int(durationVal) > 0 {
field.Set(reflect.ValueOf(durationVal))
return nil
}
uintVal, err := key.Uint64()
if err != nil {
return nil
}
field.SetUint(uintVal)
case reflect.Float64:
floatVal, err := key.Float64()
if err != nil {
return nil
}
field.SetFloat(floatVal)
case reflectTime:
timeVal, err := key.Time()
if err != nil {
return nil
}
field.Set(reflect.ValueOf(timeVal))
case reflect.Slice:
return setSliceWithProperType(key, field, delim)
default:
return fmt.Errorf("unsupported type '%s'", t)
}
return nil
}
// type(1) | name length(1) | content length(1) | raw name bytes |
// 0x00 | content bytes | 0x00
func (d *decodeState) shortString(v reflect.Value) {
d.off += 1 // type
klen := int(Int8(d.data[d.off:]))
d.off += 1 // name length
vlen := int(Int8(d.data[d.off:]))
d.off += 1 // content length
if klen > 0 {
key := d.data[d.off : d.off+klen-1]
d.off += klen // name and 0x00
v = fieldByTag(v, key)
u, pv := d.indirect(v, false)
if u != nil {
d.off -= 1 + 1 + 1 + klen
if err := u.UnmarshalMCPACK(d.next()); err != nil {
d.error(err)
}
return
}
v = pv
}
val := string(d.data[d.off : d.off+vlen-1])
d.off += vlen // value and 0x00
if !v.IsValid() {
return
}
v.SetString(val)
}
func setConfigVal(str string, field reflect.Value) error {
t := field.Kind()
switch {
case t == reflect.String:
field.SetString(str)
case t >= reflect.Int && t <= reflect.Int64:
if x, err := strconv.ParseInt(str, 10, 64); err != nil {
return err
} else {
field.SetInt(x)
}
case t >= reflect.Uint && t <= reflect.Uint64:
if x, err := strconv.ParseUint(str, 10, 64); err != nil {
return err
} else {
field.SetUint(x)
}
case t >= reflect.Float32 && t <= reflect.Float64:
if x, err := strconv.ParseFloat(str, 64); err != nil {
return err
} else {
field.SetFloat(x)
}
case t == reflect.Bool:
if x, err := strconv.ParseBool(str); err != nil {
return err
} else {
field.SetBool(x)
}
default:
return nil
}
return nil
}
// decodeString decodes a string of size s into a v.
// If s is zero, the size of a string is read from a stream.
// The return value n indicates the number of bytes decoded.
func (d *Decoder) decodeString(s int, v reflect.Value) (n int, err error) {
// Read the size if it is a zero
if s == 0 {
s, err = d.readSize()
if err != nil {
return 0, err
}
// We have successfully read one byte of size already
n++
if s == 0 {
return n, nil
}
}
// Decode data of size s
data := make([]byte, s)
if err := binary.Read(d.r, d.bo, data); err != nil {
return n, err
}
n += s
// Trim null bytes
data = bytes.TrimRight(data, "\x00")
// Set the string
v.SetString(string(data))
return n, nil
}
func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value) error {
switch valueKind {
case reflect.Int:
return setIntField(val, 0, structField)
case reflect.Int8:
return setIntField(val, 8, structField)
case reflect.Int16:
return setIntField(val, 16, structField)
case reflect.Int32:
return setIntField(val, 32, structField)
case reflect.Int64:
return setIntField(val, 64, structField)
case reflect.Uint:
return setUintField(val, 0, structField)
case reflect.Uint8:
return setUintField(val, 8, structField)
case reflect.Uint16:
return setUintField(val, 16, structField)
case reflect.Uint32:
return setUintField(val, 32, structField)
case reflect.Uint64:
return setUintField(val, 64, structField)
case reflect.Bool:
return setBoolField(val, structField)
case reflect.Float32:
return setFloatField(val, 32, structField)
case reflect.Float64:
return setFloatField(val, 64, structField)
case reflect.String:
structField.SetString(val)
default:
return errors.New("Unknown type")
}
return nil
}
func (t *Transport) decodeArrayish(r reader, val reflect.Value) error {
usize, err := binary.ReadUvarint(r)
if err != nil {
return err
}
size := int(usize)
// Special cases: []byte, string
isByteArr := val.Kind() == reflect.Array && val.Type().Elem().Kind() == reflect.Uint8
isString := val.Kind() == reflect.String
if isByteArr || isString {
raw := make([]byte, size)
if _, err := io.ReadFull(r, raw); err != nil {
return err
}
switch {
case isString:
val.SetString(string(raw))
case isByteArr:
val.SetBytes(raw)
}
return nil
}
slice := reflect.MakeSlice(val.Type(), size, size)
for i := 0; i < size; i++ {
if err := t.decodeValue(r, slice.Index(i)); err != nil {
return err
}
}
val.Set(slice)
return nil
}
func (d *MySQL) ValueToField(value reflect.Value, field reflect.Value) error {
switch field.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
field.SetInt(value.Elem().Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
// reading uint from int value causes panic
switch value.Elem().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
field.SetUint(uint64(value.Elem().Int()))
default:
field.SetUint(value.Elem().Uint())
}
case reflect.Float32, reflect.Float64:
field.SetFloat(value.Elem().Float())
case reflect.String:
if !value.Elem().IsValid() {
field.SetString("")
return nil
}
field.SetString(string(value.Elem().Bytes()))
case reflect.Slice:
if reflect.TypeOf(value.Interface()).Elem().Kind() == reflect.Uint8 {
field.SetBytes(value.Elem().Bytes())
}
case reflect.Struct:
if field.Type() == reflect.TypeOf(time.Time{}) {
field.Set(value.Elem())
}
}
return nil
}
func (tbl *Table) setVal(field *reflect.Value, val interface{}) {
str, ok := val.(string)
log.Println("trying to set")
if ok {
log.Println("setting string")
field.SetString(str)
return
}
i, ok := val.(int64)
if ok {
field.SetInt(i)
return
}
ui, ok := val.(uint64)
if ok {
field.SetUint(ui)
return
}
b, ok := val.(bool)
if ok {
field.SetBool(b)
return
}
f, ok := val.(float64)
if ok {
field.SetFloat(f)
return
}
t, ok := val.(time.Time)
if ok {
field.Set(reflect.ValueOf(t))
return
}
}
func setValueFromBytes(t []uint8, to reflect.Value) {
switch to.Interface().(type) {
case bool:
n, _ := strconv.ParseInt(string(t), 10, 32)
convertAndSet(bool(n == 1), to)
case int, int8, int16, int32, int64:
n, _ := strconv.ParseInt(string(t), 10, 64)
convertAndSet(n, to)
case uint, uint8, uint16, uint32, uint64:
n, _ := strconv.ParseUint(string(t), 10, 64)
convertAndSet(n, to)
case float32:
n, _ := strconv.ParseFloat(string(t), 32)
convertAndSet(n, to)
case float64:
n, _ := strconv.ParseFloat(string(t), 64)
convertAndSet(n, to)
case string:
to.SetString(string(t))
case map[string]interface{}:
to.Set(reflect.ValueOf(parseHstoreColumn(string(t))))
default:
convertAndSet(t, to)
}
}
func luaU_FetchString(l Lua_State, v *reflect.Value) (ok bool) {
if ok = Lua_isstring(l, -1); ok {
v.SetString(Lua_tostring(l, -1))
}
Lua_pop(l, 1)
return
}
func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
if s, ok := data.(string); ok {
rv.SetString(s)
return nil
}
return badtype("string", data)
}
func (d *Decoder) decodeField(v reflect.Value, val string) error {
switch v.Type() {
case reflect.TypeOf(time.Duration(0)):
a, err := time.ParseDuration(val)
if err != nil {
return err
}
v.SetInt(int64(a))
default:
switch v.Kind() {
case reflect.String:
v.SetString(val)
case reflect.Int, reflect.Int32, reflect.Int64:
v.Type()
nv, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return err
}
v.SetInt(nv)
case reflect.Bool:
b, err := strconv.ParseBool(val)
if err != nil {
return err
}
v.SetBool(b)
case reflect.Float32, reflect.Float64:
f, err := strconv.ParseFloat(val, 64)
if err != nil {
return err
}
v.SetFloat(f)
}
}
return nil
}
func read(lex *lexer, v reflect.Value) {
switch lex.token {
case scanner.Ident:
// The only valid identifiers are
// "nil" and struct field names.
if lex.text() == "nil" {
v.Set(reflect.Zero(v.Type()))
lex.next()
return
}
case scanner.String:
s, _ := strconv.Unquote(lex.text()) // NOTE: ignoring errors
v.SetString(s)
lex.next()
return
case scanner.Int:
i, _ := strconv.Atoi(lex.text()) // NOTE: ignoring errors
v.SetInt(int64(i))
lex.next()
return
case '(':
lex.next()
readList(lex, v)
lex.next() // consume ')'
return
}
panic(fmt.Sprintf("unexpected token %q", lex.text()))
}
func boolAsStringDecoder(dv, sv reflect.Value) {
if sv.Bool() {
dv.SetString("1")
} else {
dv.SetString("0")
}
}
func (d *base) SetModelValue(driverValue, fieldValue reflect.Value) error {
// ignore zero types
if !driverValue.Elem().IsValid() {
return nil
}
switch fieldValue.Type().Kind() {
case reflect.Bool:
fieldValue.SetBool(d.Dialect.ParseBool(driverValue.Elem()))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fieldValue.SetInt(driverValue.Elem().Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
// reading uint from int value causes panic
switch driverValue.Elem().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fieldValue.SetUint(uint64(driverValue.Elem().Int()))
default:
fieldValue.SetUint(driverValue.Elem().Uint())
}
case reflect.Float32, reflect.Float64:
fieldValue.SetFloat(driverValue.Elem().Float())
case reflect.String:
fieldValue.SetString(string(driverValue.Elem().Bytes()))
case reflect.Slice:
if reflect.TypeOf(driverValue.Interface()).Elem().Kind() == reflect.Uint8 {
fieldValue.SetBytes(driverValue.Elem().Bytes())
}
case reflect.Struct:
if _, ok := fieldValue.Interface().(time.Time); ok {
fieldValue.Set(driverValue.Elem())
}
}
return nil
}
func (me Record) GetValue(key string, value reflect.Value) (err error) {
/*stringer, ok := value.Interface().(fmt.Stringer)
if ok {
me.Gut(key, stringer.String())
return
}*/
monolog.Debug("GetValue: %s %v", key, value)
switch value.Kind() {
case reflect.Int, reflect.Int32, reflect.Int64:
value.SetInt(int64(me.GetIntDefault(key, 0)))
case reflect.Uint, reflect.Uint32, reflect.Uint64:
value.SetUint(uint64(me.GetIntDefault(key, 0)))
case reflect.Float32, reflect.Float64:
f, err := me.GetFloat(key)
if err != nil {
return err
}
value.SetFloat(f)
case reflect.String:
s, ok := me.MayGet(key)
if !ok {
return fmt.Errorf("Could not get string for key %s", key)
}
value.SetString(s)
case reflect.Struct:
me.GetStruct(key+".", value.Addr().Interface())
default:
monolog.Warning("Don't know what to do with %v", value)
}
return nil
}
func (d base) setModelValue(driverValue, fieldValue reflect.Value) error {
switch fieldValue.Type().Kind() {
case reflect.Bool:
fieldValue.SetBool(d.dialect.parseBool(driverValue.Elem()))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fieldValue.SetInt(driverValue.Elem().Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
// reading uint from int value causes panic
switch driverValue.Elem().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fieldValue.SetUint(uint64(driverValue.Elem().Int()))
default:
fieldValue.SetUint(driverValue.Elem().Uint())
}
case reflect.Float32, reflect.Float64:
fieldValue.SetFloat(driverValue.Elem().Float())
case reflect.String:
fieldValue.SetString(string(driverValue.Elem().Bytes()))
case reflect.Slice:
if reflect.TypeOf(driverValue.Interface()).Elem().Kind() == reflect.Uint8 {
fieldValue.SetBytes(driverValue.Elem().Bytes())
}
case reflect.Struct:
switch fieldValue.Interface().(type) {
case time.Time:
fieldValue.Set(driverValue.Elem())
default:
if scanner, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
return scanner.Scan(driverValue.Interface())
}
}
}
return nil
}
// inflate the results of a match into a string
func inflateScalar(dest reflect.Value, match *match, captureIndex int) error {
if captureIndex == -1 {
// This means the field generated a regex but we did not want the results
return nil
}
region := match.captures[captureIndex]
if !region.wasMatched() {
// This means the region was optional and was not matched
return nil
}
buf := match.input[region.begin:region.end]
dest = ensureAlloc(dest)
switch dest.Type() {
case stringType:
dest.SetString(string(buf))
return nil
case byteArrayType:
dest.SetBytes(buf)
return nil
case emptyType:
// ignore the value
return nil
}
return fmt.Errorf("unable to capture into %s", dest.Type().String())
}
func convertAssignBulkString(d reflect.Value, s []byte) (err error) {
switch d.Type().Kind() {
case reflect.Float32, reflect.Float64:
var x float64
x, err = strconv.ParseFloat(string(s), d.Type().Bits())
d.SetFloat(x)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
var x int64
x, err = strconv.ParseInt(string(s), 10, d.Type().Bits())
d.SetInt(x)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
var x uint64
x, err = strconv.ParseUint(string(s), 10, d.Type().Bits())
d.SetUint(x)
case reflect.Bool:
var x bool
x, err = strconv.ParseBool(string(s))
d.SetBool(x)
case reflect.String:
d.SetString(string(s))
case reflect.Slice:
if d.Type().Elem().Kind() != reflect.Uint8 {
err = cannotConvert(d, s)
} else {
d.SetBytes(s)
}
default:
err = cannotConvert(d, s)
}
return
}
func read(lex *lexer, v reflect.Value) {
switch lex.token {
case scanner.Ident:
if lex.text() == "nil" {
v.Set(reflect.Zero(v.Type()))
lex.next()
return
}
case scanner.String:
s, _ := strconv.Unquote(lex.text())
v.SetString(s)
lex.next()
return
case scanner.Int:
i, _ := strconv.Atoi(lex.text())
v.SetInt(int64(i))
lex.next()
return
case '(':
lex.next()
readList(lex, v)
lex.next()
return
}
panic(fmt.Sprintf("unexpected token %q", lex.text()))
}
