return 0, false
}
-// ARM64RegisterExtension parses an ARM64 register with extension or arrangment.
+// ARM64RegisterExtension parses an ARM64 register with extension or arrangement.
func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error {
rm := uint32(reg)
if isAmount {
return nil
}
-// ARM64RegisterArrangement parses an ARM64 vector register arrangment.
+// ARM64RegisterArrangement parses an ARM64 vector register arrangement.
func ARM64RegisterArrangement(reg int16, name, arng string) (int64, error) {
var curQ, curSize uint16
if name[0] != 'V' {
}
}
-// registerExtension parses a register with extension or arrangment.
+// registerExtension parses a register with extension or arrangement.
// There is known to be a register (current token) and an extension operator (peeked token).
func (p *Parser) registerExtension(a *obj.Addr, name string, prefix rune) {
if prefix != 0 {
// of the 2-to-the-(J-1) serial numbers.
// For each generated function a compact summary is also
-// created so that the generated funtion can be simulated
+// created so that the generated function can be simulated
// with a simple interpreter to sanity check the behavior of
// the compiled code.
panic("couldn't find first two args of commutative op " + s[0])
}
if cnt[s[idx0]] == 1 && cnt[s[idx1]] == 1 || s[idx0] == s[idx1] && cnt[s[idx0]] == 2 {
- // When we have (Add x y) with no ther uses of x and y in the matching rule,
+ // When we have (Add x y) with no other uses of x and y in the matching rule,
// then we can skip the commutative match (Add y x).
commutative = false
}
// are present in the graph, initially with trivial inputs.
// 4. Record all to-be-modified uses of mem;
// apply modifications (split into two steps to simplify and
- // avoided nagging order-dependences).
+ // avoided nagging order-dependencies).
// 5. Rewrite backedges to include reschedule check,
// and modify destination phi function appropriately with new
// definitions for mem.
VSUB: Sub (scalar)
VSUB <Vm>, <Vn>, <Vd>
- Subtract low 64-bit element in <Vm> from the correponding element in <Vn>,
+ Subtract low 64-bit element in <Vm> from the corresponding element in <Vn>,
place the result into low 64-bit element of <Vd>.
VUADDLV: Unsigned sum Long across Vector.
// On ARM systems, Load will attempt to determine what ELF header flags to
// emit by scanning the attributes in the ELF file being loaded. The
// parameter initEhdrFlags contains the current header flags for the output
-// object, and the returnd ehdrFlags contains what this Load function computes.
+// object, and the returned ehdrFlags contains what this Load function computes.
// TODO: find a better place for this logic.
func Load(arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, pkg string, length int64, pn string, initEhdrFlags uint32) (textp []*sym.Symbol, ehdrFlags uint32, err error) {
errorf := func(str string, args ...interface{}) ([]*sym.Symbol, uint32, error) {
// and for constructing the global offset table when internally linking a dynamic
// executable.
//
- // TOOD(mwhudson): perhaps a better name for this is AttrNonGoSymbol.
+ // TODO(mwhudson): perhaps a better name for this is AttrNonGoSymbol.
AttrSubSymbol
// AttrContainer is set on text symbols that are present as the .Outer for some
// other symbol.
copy(invalidX[33:], y.Bytes())
if X, Y := Unmarshal(curve, invalidX); X != nil || Y != nil {
- t.Errorf("Unmarshal accpets invalid X coordinate")
+ t.Errorf("Unmarshal accepts invalid X coordinate")
}
// This is a point on the curve with a small y value, small enough that we can add p and still be within 32 bytes.
copy(invalidY[33:], y.Bytes())
if X, Y := Unmarshal(curve, invalidY); X != nil || Y != nil {
- t.Errorf("Unmarshal accpets invalid Y coordinate")
+ t.Errorf("Unmarshal accepts invalid Y coordinate")
}
}
// name constraints, but leaf certificate contains a name of an
// unsupported or unconstrained type.
UnconstrainedName
- // TooManyConstraints results when the number of comparision operations
+ // TooManyConstraints results when the number of comparison operations
// needed to check a certificate exceeds the limit set by
// VerifyOptions.MaxConstraintComparisions. This limit exists to
// prevent pathological certificates can consuming excessive amounts of
KeyUsages []ExtKeyUsage
// MaxConstraintComparisions is the maximum number of comparisons to
// perform when checking a given certificate's name constraints. If
- // zero, a sensible default is used. This limit prevents pathalogical
+ // zero, a sensible default is used. This limit prevents pathological
// certificates from consuming excessive amounts of CPU time when
// validating.
MaxConstraintComparisions int
err = conn.QueryRowContext(ctx, "SELECT|people|bdate|age=?", 1).Scan(tt.input)
if err == nil {
- t.Fatal("expected error when querying nil column, but suceeded")
+ t.Fatal("expected error when querying nil column, but succeeded")
}
if err.Error() != tt.expectedError {
t.Fatalf("Expected error: %s\nReceived: %s", tt.expectedError, err.Error())
}{
F: false,
T: true,
- C: "<Cincinatti>",
+ C: "<Cincinnati>",
G: "<Goodbye>",
H: "<Hello>",
A: []string{"<a>", "<b>"},
{
"if",
"{{if .T}}Hello{{end}}, {{.C}}!",
- "Hello, <Cincinatti>!",
+ "Hello, <Cincinnati>!",
},
{
"else",
{
"overescaping1",
"Hello, {{.C | html}}!",
- "Hello, <Cincinatti>!",
+ "Hello, <Cincinnati>!",
},
{
"overescaping2",
"Hello, {{html .C}}!",
- "Hello, <Cincinatti>!",
+ "Hello, <Cincinnati>!",
},
{
"overescaping3",
"{{with .C}}{{$msg := .}}Hello, {{$msg}}!{{end}}",
- "Hello, <Cincinatti>!",
+ "Hello, <Cincinnati>!",
},
{
"assignment",
{
"urlBranchConflictMoot",
`<a href="{{if .T}}/foo?a={{else}}/bar#{{end}}{{.C}}">`,
- `<a href="/foo?a=%3cCincinatti%3e">`,
+ `<a href="/foo?a=%3cCincinnati%3e">`,
},
{
"jsStrValue",
"jsStrNotUnderEscaped",
"<button onclick='alert({{.C | urlquery}})'>",
// URL escaped, then quoted for JS.
- `<button onclick='alert("%3CCincinatti%3E")'>`,
+ `<button onclick='alert("%3CCincinnati%3E")'>`,
},
{
"jsRe",
{
"HTML comment",
"<b>Hello, <!-- name of world -->{{.C}}</b>",
- "<b>Hello, <Cincinatti></b>",
+ "<b>Hello, <Cincinnati></b>",
},
{
"HTML comment not first < in text node.",
{
"Split HTML comment",
"<b>Hello, <!-- name of {{if .T}}city -->{{.C}}{{else}}world -->{{.W}}{{end}}</b>",
- "<b>Hello, <Cincinatti></b>",
+ "<b>Hello, <Cincinnati></b>",
},
{
"JS line comment",
// following the end of LZW data, the very next sub-block must be the block
// terminator. If the very end of LZW data happened to fill one sub-block, at
// most one more sub-block of length 1 may exist before the block-terminator.
-// These accomodations allow us to support GIFs created by less strict encoders.
+// These accommodations allow us to support GIFs created by less strict encoders.
// See https://golang.org/issue/16146.
func (b *blockReader) close() error {
if b.err == io.EOF {
B.Add(r, w)
} else {
- // single-digit calculations failed to simluate any quotients
+ // single-digit calculations failed to simulate any quotients
// do a standard Euclidean step
t.Rem(A, B)
A, B, t = B, t, A