code review 4536063: pkg: spelling tweaks, A-H

src/pkg/asn1/marshal.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package asn1
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 333 matching lines @@
                         return out.WriteByte(0)
                 }
         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                 return marshalInt64(out, int64(v.Int()))
         case reflect.Struct:
                 t := v.Type()
 
                 startingField := 0
 
                 // If the first element of the structure is a non-empty
-                // RawContents, then we don't bother serialising the rest.
+                // RawContents, then we don't bother serializing the rest.
                 if t.NumField() > 0 && t.Field(0).Type == rawContentsType {
                         s := v.Field(0)
                         if s.Len() > 0 {
                                 bytes := make([]byte, s.Len())
                                 for i := 0; i < s.Len(); i++ {
                                         bytes[i] = uint8(s.Index(i).Uint())
                                 }
                                 /* The RawContents will contain the tag and
                                  * length fields but we'll also be writing
-                                 * those outselves, so we strip them out of
+                                 * those ourselves, so we strip them out of
                                  * bytes */
                                 _, err = out.Write(stripTagAndLength(bytes))
                                 return
                         } else {
                                 startingField = 1
                         }
                 }
 
                 for i := startingField; i < t.NumField(); i++ {
                         var pre *forkableWriter
@@ skipping 120 matching lines @@
         var out bytes.Buffer
         v := reflect.ValueOf(val)
         f := newForkableWriter()
         err := marshalField(f, v, fieldParameters{})
         if err != nil {
                 return nil, err
         }
         _, err = f.writeTo(&out)
         return out.Bytes(), nil
 }