From 671f807e2efe49d6b26d1d5dd617bf5402d6bfe4 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Thu, 2 Jul 2009 09:22:30 -0700
Subject: [PATCH] simplify decoders.  error checking is done higher up. if
 there is an error, we will write one more value into the struct but in return
 we do fewer tests in the decode.

R=rsc
DELTA=56  (0 added, 42 deleted, 14 changed)
OCL=31041
CL=31044
---
 src/pkg/gob/decode.go | 70 +++++++++----------------------------------
 1 file changed, 14 insertions(+), 56 deletions(-)

diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go
index aa9f518eb4..6133a96879 100644
--- a/src/pkg/gob/decode.go
+++ b/src/pkg/gob/decode.go
@@ -97,10 +97,7 @@ func decBool(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := int(DecodeInt(state));
-	if state.err == nil {
-		*(*bool)(p) = v != 0;
-	}
+	*(*bool)(p) = DecodeInt(state) != 0;
 }
 
 func decInt(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -110,10 +107,7 @@ func decInt(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := int(DecodeInt(state));
-	if state.err == nil {
-		*(*int)(p) = v;
-	}
+	*(*int)(p) = int(DecodeInt(state));
 }
 
 func decUint(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -123,10 +117,7 @@ func decUint(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := uint(DecodeUint(state));
-	if state.err == nil {
-		*(*uint)(p) = v;
-	}
+	*(*uint)(p) = uint(DecodeUint(state));
 }
 
 func decInt8(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -136,10 +127,7 @@ func decInt8(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := int8(DecodeInt(state));
-	if state.err == nil {
-		*(*int8)(p) = v;
-	}
+	*(*int8)(p) = int8(DecodeInt(state));
 }
 
 func decUint8(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -149,10 +137,7 @@ func decUint8(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := uint8(DecodeUint(state));
-	if state.err == nil {
-		*(*uint8)(p) = v;
-	}
+	*(*uint8)(p) = uint8(DecodeUint(state));
 }
 
 func decInt16(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -162,10 +147,7 @@ func decInt16(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := int16(DecodeInt(state));
-	if state.err == nil {
-		*(*int16)(p) = v;
-	}
+	*(*int16)(p) = int16(DecodeInt(state));
 }
 
 func decUint16(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -175,10 +157,7 @@ func decUint16(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := uint16(DecodeUint(state));
-	if state.err == nil {
-		*(*uint16)(p) = v;
-	}
+	*(*uint16)(p) = uint16(DecodeUint(state));
 }
 
 func decInt32(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -188,10 +167,7 @@ func decInt32(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := int32(DecodeInt(state));
-	if state.err == nil {
-		*(*int32)(p) = v;
-	}
+	*(*int32)(p) = int32(DecodeInt(state));
 }
 
 func decUint32(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -201,10 +177,7 @@ func decUint32(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := uint32(DecodeUint(state));
-	if state.err == nil {
-		*(*uint32)(p) = v;
-	}
+	*(*uint32)(p) = uint32(DecodeUint(state));
 }
 
 func decInt64(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -214,10 +187,7 @@ func decInt64(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := int64(DecodeInt(state));
-	if state.err == nil {
-		*(*int64)(p) = v;
-	}
+	*(*int64)(p) = int64(DecodeInt(state));
 }
 
 func decUint64(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -227,10 +197,7 @@ func decUint64(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := uint64(DecodeUint(state));
-	if state.err == nil {
-		*(*uint64)(p) = v;
-	}
+	*(*uint64)(p) = uint64(DecodeUint(state));
 }
 
 // Floating-point numbers are transmitted as uint64s holding the bits
@@ -255,10 +222,7 @@ func decFloat(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := float(floatFromBits(uint64(DecodeUint(state))));
-	if state.err == nil {
-		*(*float)(p) = v;
-	}
+	*(*float)(p) = float(floatFromBits(uint64(DecodeUint(state))));
 }
 
 func decFloat32(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -268,10 +232,7 @@ func decFloat32(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := float32(floatFromBits(uint64(DecodeUint(state))));
-	if state.err == nil {
-		*(*float32)(p) = v;
-	}
+	*(*float32)(p) = float32(floatFromBits(uint64(DecodeUint(state))));
 }
 
 func decFloat64(i *decInstr, state *DecState, p unsafe.Pointer) {
@@ -281,10 +242,7 @@ func decFloat64(i *decInstr, state *DecState, p unsafe.Pointer) {
 		}
 		p = *(*unsafe.Pointer)(p);
 	}
-	v := floatFromBits(uint64(DecodeUint(state)));
-	if state.err == nil {
-		*(*float64)(p) = v;
-	}
+	*(*float64)(p) = floatFromBits(uint64(DecodeUint(state)));
 }
 
 // Execution engine