Merge pull request #55 from cuonglm/cuonglm/do-not-use-reflect-SliceH…

…eader

Make "go test -gcflags=-d=checkptr" passes

decode.go

@@ -85,7 +85,7 @@ func (d *Decoder) decode(src []byte, header *interfaceHeader) error {
 	typeptr := uintptr(unsafe.Pointer(typ))
 
 	// noescape trick for header.typ ( reflect.*rtype )
-	copiedType := (*rtype)(unsafe.Pointer(typeptr))
+	copiedType := *(**rtype)(unsafe.Pointer(&typeptr))
 	ptr := uintptr(header.ptr)
 
 	if err := d.validateType(copiedType, ptr); err != nil {
@@ -150,7 +150,7 @@ func (d *Decoder) Decode(v interface{}) error {
 	ptr := uintptr(header.ptr)
 	typeptr := uintptr(unsafe.Pointer(typ))
 	// noescape trick for header.typ ( reflect.*rtype )
-	copiedType := (*rtype)(unsafe.Pointer(typeptr))
+	copiedType := *(**rtype)(unsafe.Pointer(&typeptr))
 
 	if err := d.validateType(copiedType, ptr); err != nil {
 		return err

decode_bool.go

@@ -66,13 +66,13 @@ func (d *boolDecoder) decodeStream(s *stream, p uintptr) error {
 			if err := trueBytes(s); err != nil {
 				return err
 			}
-			*(*bool)(unsafe.Pointer(p)) = true
+			**(**bool)(unsafe.Pointer(&p)) = true
 			return nil
 		case 'f':
 			if err := falseBytes(s); err != nil {
 				return err
 			}
-			*(*bool)(unsafe.Pointer(p)) = false
+			**(**bool)(unsafe.Pointer(&p)) = false
 			return nil
 		case nul:
 			if s.read() {
@@ -104,7 +104,7 @@ func (d *boolDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, error)
 			return 0, errInvalidCharacter(buf[cursor+3], "bool(true)", cursor)
 		}
 		cursor += 4
-		*(*bool)(unsafe.Pointer(p)) = true
+		**(**bool)(unsafe.Pointer(&p)) = true
 		return cursor, nil
 	case 'f':
 		if cursor+4 >= buflen {
@@ -123,7 +123,7 @@ func (d *boolDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, error)
 			return 0, errInvalidCharacter(buf[cursor+4], "bool(false)", cursor)
 		}
 		cursor += 5
-		*(*bool)(unsafe.Pointer(p)) = false
+		**(**bool)(unsafe.Pointer(&p)) = false
 		return cursor, nil
 	}
 	return 0, errUnexpectedEndOfJSON("bool", cursor)

decode_compile.go

@@ -89,73 +89,73 @@ func (d *Decoder) compilePtr(typ *rtype) (decoder, error) {
 
 func (d *Decoder) compileInt() (decoder, error) {
 	return newIntDecoder(func(p uintptr, v int64) {
-		*(*int)(unsafe.Pointer(p)) = int(v)
+		**(**int)(unsafe.Pointer(&p)) = int(v)
 	}), nil
 }
 
 func (d *Decoder) compileInt8() (decoder, error) {
 	return newIntDecoder(func(p uintptr, v int64) {
-		*(*int8)(unsafe.Pointer(p)) = int8(v)
+		**(**int8)(unsafe.Pointer(&p)) = int8(v)
 	}), nil
 }
 
 func (d *Decoder) compileInt16() (decoder, error) {
 	return newIntDecoder(func(p uintptr, v int64) {
-		*(*int16)(unsafe.Pointer(p)) = int16(v)
+		**(**int16)(unsafe.Pointer(&p)) = int16(v)
 	}), nil
 }
 
 func (d *Decoder) compileInt32() (decoder, error) {
 	return newIntDecoder(func(p uintptr, v int64) {
-		*(*int32)(unsafe.Pointer(p)) = int32(v)
+		**(**int32)(unsafe.Pointer(&p)) = int32(v)
 	}), nil
 }
 
 func (d *Decoder) compileInt64() (decoder, error) {
 	return newIntDecoder(func(p uintptr, v int64) {
-		*(*int64)(unsafe.Pointer(p)) = v
+		**(**int64)(unsafe.Pointer(&p)) = v
 	}), nil
 }
 
 func (d *Decoder) compileUint() (decoder, error) {
 	return newUintDecoder(func(p uintptr, v uint64) {
-		*(*uint)(unsafe.Pointer(p)) = uint(v)
+		**(**uint)(unsafe.Pointer(&p)) = uint(v)
 	}), nil
 }
 
 func (d *Decoder) compileUint8() (decoder, error) {
 	return newUintDecoder(func(p uintptr, v uint64) {
-		*(*uint8)(unsafe.Pointer(p)) = uint8(v)
+		**(**uint8)(unsafe.Pointer(&p)) = uint8(v)
 	}), nil
 }
 
 func (d *Decoder) compileUint16() (decoder, error) {
 	return newUintDecoder(func(p uintptr, v uint64) {
-		*(*uint16)(unsafe.Pointer(p)) = uint16(v)
+		**(**uint16)(unsafe.Pointer(&p)) = uint16(v)
 	}), nil
 }
 
 func (d *Decoder) compileUint32() (decoder, error) {
 	return newUintDecoder(func(p uintptr, v uint64) {
-		*(*uint32)(unsafe.Pointer(p)) = uint32(v)
+		**(**uint32)(unsafe.Pointer(&p)) = uint32(v)
 	}), nil
 }
 
 func (d *Decoder) compileUint64() (decoder, error) {
 	return newUintDecoder(func(p uintptr, v uint64) {
-		*(*uint64)(unsafe.Pointer(p)) = v
+		**(**uint64)(unsafe.Pointer(&p)) = v
 	}), nil
 }
 
 func (d *Decoder) compileFloat32() (decoder, error) {
 	return newFloatDecoder(func(p uintptr, v float64) {
-		*(*float32)(unsafe.Pointer(p)) = float32(v)
+		**(**float32)(unsafe.Pointer(&p)) = float32(v)
 	}), nil
 }
 
 func (d *Decoder) compileFloat64() (decoder, error) {
 	return newFloatDecoder(func(p uintptr, v float64) {
-		*(*float64)(unsafe.Pointer(p)) = v
+		**(**float64)(unsafe.Pointer(&p)) = v
 	}), nil
 }
 

decode_interface.go

@@ -19,11 +19,11 @@ func newInterfaceDecoder(typ *rtype) *interfaceDecoder {
 func (d *interfaceDecoder) numDecoder(s *stream) decoder {
 	if s.useNumber {
 		return newNumberDecoder(func(p uintptr, v Number) {
-			*(*interface{})(unsafe.Pointer(p)) = v
+			**(**interface{})(unsafe.Pointer(&p)) = v
 		})
 	}
 	return newFloatDecoder(func(p uintptr, v float64) {
-		*(*interface{})(unsafe.Pointer(p)) = v
+		**(**interface{})(unsafe.Pointer(&p)) = v
 	})
 }
 
@@ -48,7 +48,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p uintptr) error {
 			).decodeStream(s, uintptr(ptr)); err != nil {
 				return err
 			}
-			*(*interface{})(unsafe.Pointer(p)) = v
+			**(**interface{})(unsafe.Pointer(&p)) = v
 			return nil
 		case '[':
 			var v []interface{}
@@ -61,7 +61,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p uintptr) error {
 			).decodeStream(s, uintptr(ptr)); err != nil {
 				return err
 			}
-			*(*interface{})(unsafe.Pointer(p)) = v
+			**(**interface{})(unsafe.Pointer(&p)) = v
 			return nil
 		case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
 			return d.numDecoder(s).decodeStream(s, p)
@@ -77,7 +77,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p uintptr) error {
 				case '"':
 					literal := s.buf[start:s.cursor]
 					s.cursor++
-					*(*interface{})(unsafe.Pointer(p)) = *(*string)(unsafe.Pointer(&literal))
+					**(**interface{})(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&literal))
 					return nil
 				case nul:
 					if s.read() {
@@ -92,19 +92,19 @@ func (d *interfaceDecoder) decodeStream(s *stream, p uintptr) error {
 			if err := trueBytes(s); err != nil {
 				return err
 			}
-			*(*interface{})(unsafe.Pointer(p)) = true
+			**(**interface{})(unsafe.Pointer(&p)) = true
 			return nil
 		case 'f':
 			if err := falseBytes(s); err != nil {
 				return err
 			}
-			*(*interface{})(unsafe.Pointer(p)) = false
+			**(**interface{})(unsafe.Pointer(&p)) = false
 			return nil
 		case 'n':
 			if err := nullBytes(s); err != nil {
 				return err
 			}
-			*(*interface{})(unsafe.Pointer(p)) = nil
+			**(**interface{})(unsafe.Pointer(&p)) = nil
 			return nil
 		case nul:
 			if s.read() {
@@ -132,7 +132,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e
 		if err != nil {
 			return 0, err
 		}
-		*(*interface{})(unsafe.Pointer(p)) = v
+		**(**interface{})(unsafe.Pointer(&p)) = v
 		return cursor, nil
 	case '[':
 		var v []interface{}
@@ -147,11 +147,11 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e
 		if err != nil {
 			return 0, err
 		}
-		*(*interface{})(unsafe.Pointer(p)) = v
+		**(**interface{})(unsafe.Pointer(&p)) = v
 		return cursor, nil
 	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
 		return newFloatDecoder(func(p uintptr, v float64) {
-			*(*interface{})(unsafe.Pointer(p)) = v
+			**(**interface{})(unsafe.Pointer(&p)) = v
 		}).decode(buf, cursor, p)
 	case '"':
 		cursor++
@@ -163,7 +163,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e
 			case '"':
 				literal := buf[start:cursor]
 				cursor++
-				*(*interface{})(unsafe.Pointer(p)) = *(*string)(unsafe.Pointer(&literal))
+				**(**interface{})(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&literal))
 				return cursor, nil
 			case nul:
 				return 0, errUnexpectedEndOfJSON("string", cursor)
@@ -185,7 +185,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e
 			return 0, errInvalidCharacter(buf[cursor+3], "bool(true)", cursor)
 		}
 		cursor += 4
-		*(*interface{})(unsafe.Pointer(p)) = true
+		**(**interface{})(unsafe.Pointer(&p)) = true
 		return cursor, nil
 	case 'f':
 		if cursor+4 >= int64(len(buf)) {
@@ -204,7 +204,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e
 			return 0, errInvalidCharacter(buf[cursor+4], "bool(false)", cursor)
 		}
 		cursor += 5
-		*(*interface{})(unsafe.Pointer(p)) = false
+		**(**interface{})(unsafe.Pointer(&p)) = false
 		return cursor, nil
 	case 'n':
 		if cursor+3 >= int64(len(buf)) {
@@ -220,7 +220,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e
 			return 0, errInvalidCharacter(buf[cursor+3], "null", cursor)
 		}
 		cursor += 4
-		*(*interface{})(unsafe.Pointer(p)) = nil
+		**(**interface{})(unsafe.Pointer(&p)) = nil
 		return cursor, nil
 	}
 	return cursor, errNotAtBeginningOfValue(cursor)

decode_map.go

@@ -65,7 +65,7 @@ func (d *mapDecoder) decodeStream(s *stream, p uintptr) error {
 	s.skipWhiteSpace()
 	mapValue := makemap(d.mapType, 0)
 	if s.buf[s.cursor+1] == '}' {
-		*(*unsafe.Pointer)(unsafe.Pointer(p)) = mapValue
+		**(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
 		s.cursor++
 		return nil
 	}
@@ -96,7 +96,7 @@ func (d *mapDecoder) decodeStream(s *stream, p uintptr) error {
 			s.read()
 		}
 		if s.char() == '}' {
-			*(*unsafe.Pointer)(unsafe.Pointer(p)) = mapValue
+			**(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
 			s.cursor++
 			return nil
 		}
@@ -137,7 +137,7 @@ func (d *mapDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, error)
 	cursor = skipWhiteSpace(buf, cursor)
 	mapValue := makemap(d.mapType, 0)
 	if buf[cursor] == '}' {
-		*(*unsafe.Pointer)(unsafe.Pointer(p)) = mapValue
+		**(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
 		cursor++
 		return cursor, nil
 	}
@@ -165,7 +165,7 @@ func (d *mapDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, error)
 		mapassign(d.mapType, mapValue, unsafe.Pointer(&key), unsafe.Pointer(&value))
 		cursor = skipWhiteSpace(buf, valueCursor)
 		if buf[cursor] == '}' {
-			*(*unsafe.Pointer)(unsafe.Pointer(p)) = mapValue
+			**(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
 			cursor++
 			return cursor, nil
 		}

decode_ptr.go

@@ -21,7 +21,7 @@ func (d *ptrDecoder) decodeStream(s *stream, p uintptr) error {
 	if err := d.dec.decodeStream(s, newptr); err != nil {
 		return err
 	}
-	*(*uintptr)(unsafe.Pointer(p)) = newptr
+	**(**uintptr)(unsafe.Pointer(&p)) = newptr
 	return nil
 }
 
@@ -32,6 +32,6 @@ func (d *ptrDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, error)
 		return 0, err
 	}
 	cursor = c
-	*(*uintptr)(unsafe.Pointer(p)) = newptr
+	**(**uintptr)(unsafe.Pointer(&p)) = newptr
 	return cursor, nil
 }