all: gofmt
Gofmt to update doc comments to the new formatting.
For golang/go#51082.
Change-Id: I3e3c5666d5e901f2c5303911ddb548e3dd567fce
Reviewed-on: https://go-review.googlesource.com/c/text/+/399603
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Russ Cox <rsc@golang.org>
Reviewed-by: Ian Lance Taylor <iant@google.com>
diff --git a/cases/gen_trieval.go b/cases/gen_trieval.go
index 6c7222a..14dd33b 100644
--- a/cases/gen_trieval.go
+++ b/cases/gen_trieval.go
@@ -19,19 +19,19 @@
//
// The per-rune values have the following format:
//
-// if (exception) {
-// 15..4 unsigned exception index
-// } else {
-// 15..8 XOR pattern or index to XOR pattern for case mapping
-// Only 13..8 are used for XOR patterns.
-// 7 inverseFold (fold to upper, not to lower)
-// 6 index: interpret the XOR pattern as an index
-// or isMid if case mode is cIgnorableUncased.
-// 5..4 CCC: zero (normal or break), above or other
-// }
-// 3 exception: interpret this value as an exception index
-// (TODO: is this bit necessary? Probably implied from case mode.)
-// 2..0 case mode
+// if (exception) {
+// 15..4 unsigned exception index
+// } else {
+// 15..8 XOR pattern or index to XOR pattern for case mapping
+// Only 13..8 are used for XOR patterns.
+// 7 inverseFold (fold to upper, not to lower)
+// 6 index: interpret the XOR pattern as an index
+// or isMid if case mode is cIgnorableUncased.
+// 5..4 CCC: zero (normal or break), above or other
+// }
+// 3 exception: interpret this value as an exception index
+// (TODO: is this bit necessary? Probably implied from case mode.)
+// 2..0 case mode
//
// For the non-exceptional cases, a rune must be either uncased, lowercase or
// uppercase. If the rune is cased, the XOR pattern maps either a lowercase
@@ -133,37 +133,40 @@
// The entry is pointed to by the exception index in an entry. It has the
// following format:
//
-// Header
-// byte 0:
-// 7..6 unused
-// 5..4 CCC type (same bits as entry)
-// 3 unused
-// 2..0 length of fold
+// Header:
//
-// byte 1:
-// 7..6 unused
-// 5..3 length of 1st mapping of case type
-// 2..0 length of 2nd mapping of case type
+// byte 0:
+// 7..6 unused
+// 5..4 CCC type (same bits as entry)
+// 3 unused
+// 2..0 length of fold
//
-// case 1st 2nd
-// lower -> upper, title
-// upper -> lower, title
-// title -> lower, upper
+// byte 1:
+// 7..6 unused
+// 5..3 length of 1st mapping of case type
+// 2..0 length of 2nd mapping of case type
+//
+// case 1st 2nd
+// lower -> upper, title
+// upper -> lower, title
+// title -> lower, upper
//
// Lengths with the value 0x7 indicate no value and implies no change.
// A length of 0 indicates a mapping to zero-length string.
//
// Body bytes:
-// case folding bytes
-// lowercase mapping bytes
-// uppercase mapping bytes
-// titlecase mapping bytes
-// closure mapping bytes (for NFKC_Casefold). (TODO)
+//
+// case folding bytes
+// lowercase mapping bytes
+// uppercase mapping bytes
+// titlecase mapping bytes
+// closure mapping bytes (for NFKC_Casefold). (TODO)
//
// Fallbacks:
-// missing fold -> lower
-// missing title -> upper
-// all missing -> original rune
+//
+// missing fold -> lower
+// missing title -> upper
+// all missing -> original rune
//
// exceptions starts with a dummy byte to enforce that there is no zero index
// value.
diff --git a/cases/trieval.go b/cases/trieval.go
index 99e0396..4e4d13f 100644
--- a/cases/trieval.go
+++ b/cases/trieval.go
@@ -14,19 +14,19 @@
//
// The per-rune values have the following format:
//
-// if (exception) {
-// 15..4 unsigned exception index
-// } else {
-// 15..8 XOR pattern or index to XOR pattern for case mapping
-// Only 13..8 are used for XOR patterns.
-// 7 inverseFold (fold to upper, not to lower)
-// 6 index: interpret the XOR pattern as an index
-// or isMid if case mode is cIgnorableUncased.
-// 5..4 CCC: zero (normal or break), above or other
-// }
-// 3 exception: interpret this value as an exception index
-// (TODO: is this bit necessary? Probably implied from case mode.)
-// 2..0 case mode
+// if (exception) {
+// 15..4 unsigned exception index
+// } else {
+// 15..8 XOR pattern or index to XOR pattern for case mapping
+// Only 13..8 are used for XOR patterns.
+// 7 inverseFold (fold to upper, not to lower)
+// 6 index: interpret the XOR pattern as an index
+// or isMid if case mode is cIgnorableUncased.
+// 5..4 CCC: zero (normal or break), above or other
+// }
+// 3 exception: interpret this value as an exception index
+// (TODO: is this bit necessary? Probably implied from case mode.)
+// 2..0 case mode
//
// For the non-exceptional cases, a rune must be either uncased, lowercase or
// uppercase. If the rune is cased, the XOR pattern maps either a lowercase
@@ -128,37 +128,40 @@
// The entry is pointed to by the exception index in an entry. It has the
// following format:
//
-// Header
-// byte 0:
-// 7..6 unused
-// 5..4 CCC type (same bits as entry)
-// 3 unused
-// 2..0 length of fold
+// Header:
//
-// byte 1:
-// 7..6 unused
-// 5..3 length of 1st mapping of case type
-// 2..0 length of 2nd mapping of case type
+// byte 0:
+// 7..6 unused
+// 5..4 CCC type (same bits as entry)
+// 3 unused
+// 2..0 length of fold
//
-// case 1st 2nd
-// lower -> upper, title
-// upper -> lower, title
-// title -> lower, upper
+// byte 1:
+// 7..6 unused
+// 5..3 length of 1st mapping of case type
+// 2..0 length of 2nd mapping of case type
+//
+// case 1st 2nd
+// lower -> upper, title
+// upper -> lower, title
+// title -> lower, upper
//
// Lengths with the value 0x7 indicate no value and implies no change.
// A length of 0 indicates a mapping to zero-length string.
//
// Body bytes:
-// case folding bytes
-// lowercase mapping bytes
-// uppercase mapping bytes
-// titlecase mapping bytes
-// closure mapping bytes (for NFKC_Casefold). (TODO)
+//
+// case folding bytes
+// lowercase mapping bytes
+// uppercase mapping bytes
+// titlecase mapping bytes
+// closure mapping bytes (for NFKC_Casefold). (TODO)
//
// Fallbacks:
-// missing fold -> lower
-// missing title -> upper
-// all missing -> original rune
+//
+// missing fold -> lower
+// missing title -> upper
+// all missing -> original rune
//
// exceptions starts with a dummy byte to enforce that there is no zero index
// value.
diff --git a/cmd/gotext/doc.go b/cmd/gotext/doc.go
index fa247c6..d363ae2 100644
--- a/cmd/gotext/doc.go
+++ b/cmd/gotext/doc.go
@@ -4,60 +4,47 @@
//
// Usage:
//
-// gotext command [arguments]
+// gotext command [arguments]
//
// The commands are:
//
-// update merge translations and generate catalog
-// extract extracts strings to be translated from code
-// rewrite rewrites fmt functions to use a message Printer
-// generate generates code to insert translated messages
+// update merge translations and generate catalog
+// extract extracts strings to be translated from code
+// rewrite rewrites fmt functions to use a message Printer
+// generate generates code to insert translated messages
//
// Use "gotext help [command]" for more information about a command.
//
// Additional help topics:
//
-//
// Use "gotext help [topic]" for more information about that topic.
//
-//
-// Merge translations and generate catalog
+// # Merge translations and generate catalog
//
// Usage:
//
-// gotext update <package>* [-out <gofile>]
+// gotext update <package>* [-out <gofile>]
//
-//
-//
-//
-// Extracts strings to be translated from code
+// # Extracts strings to be translated from code
//
// Usage:
//
-// gotext extract <package>*
+// gotext extract <package>*
//
-//
-//
-//
-// Rewrites fmt functions to use a message Printer
+// # Rewrites fmt functions to use a message Printer
//
// Usage:
//
-// gotext rewrite <package>
+// gotext rewrite <package>
//
// rewrite is typically done once for a project. It rewrites all usages of
// fmt to use x/text's message package whenever a message.Printer is in scope.
// It rewrites Print and Println calls with constant strings to the equivalent
// using Printf to allow translators to reorder arguments.
//
-//
-// Generates code to insert translated messages
+// # Generates code to insert translated messages
//
// Usage:
//
-// gotext generate <package>
-//
-//
-//
-//
+// gotext generate <package>
package main
diff --git a/collate/build/builder.go b/collate/build/builder.go
index 092a4b5..3efb738 100644
--- a/collate/build/builder.go
+++ b/collate/build/builder.go
@@ -225,26 +225,37 @@
//
// Examples: create a tailoring for Swedish, where "ä" is ordered after "z"
// at the primary sorting level:
-// t := b.Tailoring("se")
-// t.SetAnchor("z")
-// t.Insert(colltab.Primary, "ä", "")
+//
+// t := b.Tailoring("se")
+// t.SetAnchor("z")
+// t.Insert(colltab.Primary, "ä", "")
+//
// Order "ü" after "ue" at the secondary sorting level:
-// t.SetAnchor("ue")
-// t.Insert(colltab.Secondary, "ü","")
+//
+// t.SetAnchor("ue")
+// t.Insert(colltab.Secondary, "ü","")
+//
// or
-// t.SetAnchor("u")
-// t.Insert(colltab.Secondary, "ü", "e")
+//
+// t.SetAnchor("u")
+// t.Insert(colltab.Secondary, "ü", "e")
+//
// Order "q" afer "ab" at the secondary level and "Q" after "q"
// at the tertiary level:
-// t.SetAnchor("ab")
-// t.Insert(colltab.Secondary, "q", "")
-// t.Insert(colltab.Tertiary, "Q", "")
+//
+// t.SetAnchor("ab")
+// t.Insert(colltab.Secondary, "q", "")
+// t.Insert(colltab.Tertiary, "Q", "")
+//
// Order "b" before "a":
-// t.SetAnchorBefore("a")
-// t.Insert(colltab.Primary, "b", "")
+//
+// t.SetAnchorBefore("a")
+// t.Insert(colltab.Primary, "b", "")
+//
// Order "0" after the last primary ignorable:
-// t.SetAnchor("<last_primary_ignorable/>")
-// t.Insert(colltab.Primary, "0", "")
+//
+// t.SetAnchor("<last_primary_ignorable/>")
+// t.Insert(colltab.Primary, "0", "")
func (t *Tailoring) Insert(level colltab.Level, str, extend string) error {
if t.anchor == nil {
return fmt.Errorf("%s:Insert: no anchor point set for tailoring of %s", t.id, str)
diff --git a/collate/build/colelem.go b/collate/build/colelem.go
index 04fc3bf..1aaa062 100644
--- a/collate/build/colelem.go
+++ b/collate/build/colelem.go
@@ -51,6 +51,7 @@
// - n* is the size of the first node in the contraction trie.
// - i* is the index of the first node in the contraction trie.
// - b* is the offset into the contraction collation element table.
+//
// See contract.go for details on the contraction trie.
const (
contractID = 0xC0000000
@@ -103,7 +104,8 @@
// The collation element, in this case, is of the form
// 11110000 00000000 wwwwwwww vvvvvvvv, where
// - v* is the replacement tertiary weight for the first rune,
-// - w* is the replacement tertiary weight for the second rune,
+// - w* is the replacement tertiary weight for the second rune.
+//
// Tertiary weights of subsequent runes should be replaced with maxTertiary.
// See https://www.unicode.org/reports/tr10/#Compatibility_Decompositions for more details.
const (
@@ -162,7 +164,9 @@
// primaries (either double primaries or for illegal runes)
// to our own representation.
// A CJK character C is represented in the DUCET as
-// [.FBxx.0020.0002.C][.BBBB.0000.0000.C]
+//
+// [.FBxx.0020.0002.C][.BBBB.0000.0000.C]
+//
// We will rewrite these characters to a single CE.
// We assume the CJK values start at 0x8000.
// See https://unicode.org/reports/tr10/#Implicit_Weights
diff --git a/collate/build/contract.go b/collate/build/contract.go
index e2df64f..5d79eb8 100644
--- a/collate/build/contract.go
+++ b/collate/build/contract.go
@@ -56,19 +56,22 @@
// entry might still resemble a completed suffix.
// Examples:
// The suffix strings "ab" and "ac" can be represented as:
-// []ctEntry{
-// {'a', 1, 1, noIndex}, // 'a' by itself does not match, so i is 0xFF.
-// {'b', 'c', 0, 1}, // "ab" -> 1, "ac" -> 2
-// }
+//
+// []ctEntry{
+// {'a', 1, 1, noIndex}, // 'a' by itself does not match, so i is 0xFF.
+// {'b', 'c', 0, 1}, // "ab" -> 1, "ac" -> 2
+// }
//
// The suffix strings "ab", "abc", "abd", and "abcd" can be represented as:
-// []ctEntry{
-// {'a', 1, 1, noIndex}, // 'a' must be followed by 'b'.
-// {'b', 1, 2, 1}, // "ab" -> 1, may be followed by 'c' or 'd'.
-// {'d', 'd', final, 3}, // "abd" -> 3
-// {'c', 4, 1, 2}, // "abc" -> 2, may be followed by 'd'.
-// {'d', 'd', final, 4}, // "abcd" -> 4
-// }
+//
+// []ctEntry{
+// {'a', 1, 1, noIndex}, // 'a' must be followed by 'b'.
+// {'b', 1, 2, 1}, // "ab" -> 1, may be followed by 'c' or 'd'.
+// {'d', 'd', final, 3}, // "abd" -> 3
+// {'c', 4, 1, 2}, // "abc" -> 2, may be followed by 'd'.
+// {'d', 'd', final, 4}, // "abcd" -> 4
+// }
+//
// See genStateTests in contract_test.go for more examples.
type ctEntry struct {
L uint8 // non-final: byte value to match; final: lowest match in range.
diff --git a/feature/plural/gen.go b/feature/plural/gen.go
index b9c5f24..5f8f375 100644
--- a/feature/plural/gen.go
+++ b/feature/plural/gen.go
@@ -359,15 +359,16 @@
// the resulting or conditions to conds.
//
// Example rules:
-// // Category "one" in English: only allow 1 with no visible fraction
-// i = 1 and v = 0 @integer 1
//
-// // Category "few" in Czech: all numbers with visible fractions
-// v != 0 @decimal ...
+// // Category "one" in English: only allow 1 with no visible fraction
+// i = 1 and v = 0 @integer 1
//
-// // Category "zero" in Latvian: all multiples of 10 or the numbers 11-19 or
-// // numbers with a fraction 11..19 and no trailing zeros.
-// n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer ...
+// // Category "few" in Czech: all numbers with visible fractions
+// v != 0 @decimal ...
+//
+// // Category "zero" in Latvian: all multiples of 10 or the numbers 11-19 or
+// // numbers with a fraction 11..19 and no trailing zeros.
+// n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer ...
//
// @integer and @decimal are followed by examples and are not relevant for the
// rule itself. The are used here to signal the termination of the rule.
diff --git a/feature/plural/message.go b/feature/plural/message.go
index f931f8a..6248d01 100644
--- a/feature/plural/message.go
+++ b/feature/plural/message.go
@@ -35,13 +35,13 @@
// The cases argument are pairs of selectors and messages. Selectors are of type
// string or Form. Messages are of type string or catalog.Message. A selector
// matches an argument if:
-// - it is "other" or Other
-// - it matches the plural form of the argument: "zero", "one", "two", "few",
-// or "many", or the equivalent Form
-// - it is of the form "=x" where x is an integer that matches the value of
-// the argument.
-// - it is of the form "<x" where x is an integer that is larger than the
-// argument.
+// - it is "other" or Other
+// - it matches the plural form of the argument: "zero", "one", "two", "few",
+// or "many", or the equivalent Form
+// - it is of the form "=x" where x is an integer that matches the value of
+// the argument.
+// - it is of the form "<x" where x is an integer that is larger than the
+// argument.
//
// The format argument determines the formatting parameters for which to
// determine the plural form. This is especially relevant for non-integer
diff --git a/feature/plural/plural.go b/feature/plural/plural.go
index 5b521b1..e9f2d42 100644
--- a/feature/plural/plural.go
+++ b/feature/plural/plural.go
@@ -20,7 +20,6 @@
// Rules defines the plural rules for all languages for a certain plural type.
//
-//
// This package is UNDER CONSTRUCTION and its API may change.
type Rules struct {
rules []pluralCheck
@@ -54,19 +53,19 @@
// getIntApprox converts the digits in slice digits[start:end] to an integer
// according to the following rules:
-// - Let i be asInt(digits[start:end]), where out-of-range digits are assumed
-// to be zero.
-// - Result n is big if i / 10^nMod > 1.
-// - Otherwise the result is i % 10^nMod.
+// - Let i be asInt(digits[start:end]), where out-of-range digits are assumed
+// to be zero.
+// - Result n is big if i / 10^nMod > 1.
+// - Otherwise the result is i % 10^nMod.
//
// For example, if digits is {1, 2, 3} and start:end is 0:5, then the result
// for various values of nMod is:
-// - when nMod == 2, n == big
-// - when nMod == 3, n == big
-// - when nMod == 4, n == big
-// - when nMod == 5, n == 12300
-// - when nMod == 6, n == 12300
-// - when nMod == 7, n == 12300
+// - when nMod == 2, n == big
+// - when nMod == 3, n == big
+// - when nMod == 4, n == big
+// - when nMod == 5, n == 12300
+// - when nMod == 6, n == 12300
+// - when nMod == 7, n == 12300
func getIntApprox(digits []byte, start, end, nMod, big int) (n int) {
// Leading 0 digits just result in 0.
p := start
@@ -107,12 +106,13 @@
//
// The following table contains examples of possible arguments to represent
// the given numbers.
-// decimal digits exp scale
-// 123 []byte{1, 2, 3} 3 0
-// 123.4 []byte{1, 2, 3, 4} 3 1
-// 123.40 []byte{1, 2, 3, 4} 3 2
-// 100000 []byte{1} 6 0
-// 100000.00 []byte{1} 6 3
+//
+// decimal digits exp scale
+// 123 []byte{1, 2, 3} 3 0
+// 123.4 []byte{1, 2, 3, 4} 3 1
+// 123.40 []byte{1, 2, 3, 4} 3 2
+// 100000 []byte{1} 6 0
+// 100000.00 []byte{1} 6 3
func (p *Rules) MatchDigits(t language.Tag, digits []byte, exp, scale int) Form {
index := tagToID(t)
@@ -152,14 +152,15 @@
// MatchPlural returns the plural form for the given language and plural
// operands (as defined in
// https://unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules):
-// where
-// n absolute value of the source number (integer and decimals)
-// input
-// i integer digits of n.
-// v number of visible fraction digits in n, with trailing zeros.
-// w number of visible fraction digits in n, without trailing zeros.
-// f visible fractional digits in n, with trailing zeros (f = t * 10^(v-w))
-// t visible fractional digits in n, without trailing zeros.
+//
+// where
+// n absolute value of the source number (integer and decimals)
+// input
+// i integer digits of n.
+// v number of visible fraction digits in n, with trailing zeros.
+// w number of visible fraction digits in n, without trailing zeros.
+// f visible fractional digits in n, with trailing zeros (f = t * 10^(v-w))
+// t visible fractional digits in n, without trailing zeros.
//
// If any of the operand values is too large to fit in an int, it is okay to
// pass the value modulo 10,000,000.
diff --git a/internal/catmsg/catmsg.go b/internal/catmsg/catmsg.go
index c0bf86f..1b257a7 100644
--- a/internal/catmsg/catmsg.go
+++ b/internal/catmsg/catmsg.go
@@ -9,8 +9,7 @@
// own. For instance, the plural package provides functionality for selecting
// translation strings based on the plural category of substitution arguments.
//
-//
-// Encoding and Decoding
+// # Encoding and Decoding
//
// Catalogs store Messages encoded as a single string. Compiling a message into
// a string both results in compacter representation and speeds up evaluation.
@@ -25,8 +24,7 @@
// the message. This decoder takes a Decoder argument which provides the
// counterparts for the decoding.
//
-//
-// Renderers
+// # Renderers
//
// A Decoder must be initialized with a Renderer implementation. These
// implementations must be provided by packages that use Catalogs, typically
@@ -38,22 +36,22 @@
// as sequence of substrings passed to the Renderer. The following snippet shows
// how to express the above example using the message package.
//
-// message.Set(language.English, "You are %d minute(s) late.",
-// catalog.Var("minutes", plural.Select(1, "one", "minute")),
-// catalog.String("You are %[1]d ${minutes} late."))
+// message.Set(language.English, "You are %d minute(s) late.",
+// catalog.Var("minutes", plural.Select(1, "one", "minute")),
+// catalog.String("You are %[1]d ${minutes} late."))
//
-// p := message.NewPrinter(language.English)
-// p.Printf("You are %d minute(s) late.", 5) // always 5 minutes late.
+// p := message.NewPrinter(language.English)
+// p.Printf("You are %d minute(s) late.", 5) // always 5 minutes late.
//
// To evaluate the Printf, package message wraps the arguments in a Renderer
// that is passed to the catalog for message decoding. The call sequence that
// results from evaluating the above message, assuming the person is rather
// tardy, is:
//
-// Render("You are %[1]d ")
-// Arg(1)
-// Render("minutes")
-// Render(" late.")
+// Render("You are %[1]d ")
+// Arg(1)
+// Render("minutes")
+// Render(" late.")
//
// The calls to Arg is caused by the plural.Select execution, which evaluates
// the argument to determine whether the singular or plural message form should
@@ -267,10 +265,12 @@
// Var defines a message that can be substituted for a placeholder of the same
// name. If an expression does not result in a string after evaluation, Name is
// used as the substitution. For example:
-// Var{
-// Name: "minutes",
-// Message: plural.Select(1, "one", "minute"),
-// }
+//
+// Var{
+// Name: "minutes",
+// Message: plural.Select(1, "one", "minute"),
+// }
+//
// will resolve to minute for singular and minutes for plural forms.
type Var struct {
Name string
@@ -318,13 +318,15 @@
// calls for each placeholder and interstitial string. For example, for the
// message: "%[1]v ${invites} %[2]v to ${their} party." The sequence of calls
// is:
-// d.Render("%[1]v ")
-// d.Arg(1)
-// d.Render(resultOfInvites)
-// d.Render(" %[2]v to ")
-// d.Arg(2)
-// d.Render(resultOfTheir)
-// d.Render(" party.")
+//
+// d.Render("%[1]v ")
+// d.Arg(1)
+// d.Render(resultOfInvites)
+// d.Render(" %[2]v to ")
+// d.Arg(2)
+// d.Render(resultOfTheir)
+// d.Render(" party.")
+//
// where the messages for "invites" and "their" both use a plural.Select
// referring to the first argument.
//
diff --git a/internal/cldrtree/cldrtree.go b/internal/cldrtree/cldrtree.go
index 7530831..cc2714e 100644
--- a/internal/cldrtree/cldrtree.go
+++ b/internal/cldrtree/cldrtree.go
@@ -4,7 +4,6 @@
// Package cldrtree builds and generates a CLDR index file, including all
// inheritance.
-//
package cldrtree
//go:generate go test -gen
diff --git a/internal/colltab/collelem.go b/internal/colltab/collelem.go
index 396cebd..0c23c8a 100644
--- a/internal/colltab/collelem.go
+++ b/internal/colltab/collelem.go
@@ -78,24 +78,27 @@
// For normal collation elements, we assume that a collation element either has
// a primary or non-default secondary value, not both.
// Collation elements with a primary value are of the form
-// 01pppppp pppppppp ppppppp0 ssssssss
-// - p* is primary collation value
-// - s* is the secondary collation value
-// 00pppppp pppppppp ppppppps sssttttt, where
-// - p* is primary collation value
-// - s* offset of secondary from default value.
-// - t* is the tertiary collation value
-// 100ttttt cccccccc pppppppp pppppppp
-// - t* is the tertiar collation value
-// - c* is the canonical combining class
-// - p* is the primary collation value
+//
+// 01pppppp pppppppp ppppppp0 ssssssss
+// - p* is primary collation value
+// - s* is the secondary collation value
+// 00pppppp pppppppp ppppppps sssttttt, where
+// - p* is primary collation value
+// - s* offset of secondary from default value.
+// - t* is the tertiary collation value
+// 100ttttt cccccccc pppppppp pppppppp
+// - t* is the tertiar collation value
+// - c* is the canonical combining class
+// - p* is the primary collation value
+//
// Collation elements with a secondary value are of the form
-// 1010cccc ccccssss ssssssss tttttttt, where
-// - c* is the canonical combining class
-// - s* is the secondary collation value
-// - t* is the tertiary collation value
-// 11qqqqqq qqqqqqqq qqqqqqq0 00000000
-// - q* quaternary value
+//
+// 1010cccc ccccssss ssssssss tttttttt, where
+// - c* is the canonical combining class
+// - s* is the secondary collation value
+// - t* is the tertiary collation value
+// 11qqqqqq qqqqqqqq qqqqqqq0 00000000
+// - q* quaternary value
const (
ceTypeMask = 0xC0000000
ceTypeMaskExt = 0xE0000000
@@ -296,6 +299,7 @@
// - n* is the size of the first node in the contraction trie.
// - i* is the index of the first node in the contraction trie.
// - b* is the offset into the contraction collation element table.
+//
// See contract.go for details on the contraction trie.
const (
maxNBits = 4
@@ -326,6 +330,7 @@
// The Elem, in this case, is of the form 11110000 00000000 wwwwwwww vvvvvvvv, where
// - v* is the replacement tertiary weight for the first rune,
// - w* is the replacement tertiary weight for the second rune,
+//
// Tertiary weights of subsequent runes should be replaced with maxTertiary.
// See https://www.unicode.org/reports/tr10/#Compatibility_Decompositions for more details.
func splitDecompose(ce Elem) (t1, t2 uint8) {
diff --git a/internal/export/idna/gen_trieval.go b/internal/export/idna/gen_trieval.go
index 9d92407..501bfab 100644
--- a/internal/export/idna/gen_trieval.go
+++ b/internal/export/idna/gen_trieval.go
@@ -22,23 +22,23 @@
//
// The per-rune values have the following format:
//
-// if mapped {
-// if inlinedXOR {
-// 15..13 inline XOR marker
-// 12..11 unused
-// 10..3 inline XOR mask
-// } else {
-// 15..3 index into xor or mapping table
-// }
-// } else {
-// 15..14 unused
-// 13 mayNeedNorm
-// 12..11 attributes
-// 10..8 joining type
-// 7..3 category type
-// }
-// 2 use xor pattern
-// 1..0 mapped category
+// if mapped {
+// if inlinedXOR {
+// 15..13 inline XOR marker
+// 12..11 unused
+// 10..3 inline XOR mask
+// } else {
+// 15..3 index into xor or mapping table
+// }
+// } else {
+// 15..14 unused
+// 13 mayNeedNorm
+// 12..11 attributes
+// 10..8 joining type
+// 7..3 category type
+// }
+// 2 use xor pattern
+// 1..0 mapped category
//
// See the definitions below for a more detailed description of the various
// bits.
diff --git a/internal/export/idna/trieval.go b/internal/export/idna/trieval.go
index 7a8cf88..9c070a4 100644
--- a/internal/export/idna/trieval.go
+++ b/internal/export/idna/trieval.go
@@ -17,23 +17,23 @@
//
// The per-rune values have the following format:
//
-// if mapped {
-// if inlinedXOR {
-// 15..13 inline XOR marker
-// 12..11 unused
-// 10..3 inline XOR mask
-// } else {
-// 15..3 index into xor or mapping table
-// }
-// } else {
-// 15..14 unused
-// 13 mayNeedNorm
-// 12..11 attributes
-// 10..8 joining type
-// 7..3 category type
-// }
-// 2 use xor pattern
-// 1..0 mapped category
+// if mapped {
+// if inlinedXOR {
+// 15..13 inline XOR marker
+// 12..11 unused
+// 10..3 inline XOR mask
+// } else {
+// 15..3 index into xor or mapping table
+// }
+// } else {
+// 15..14 unused
+// 13 mayNeedNorm
+// 12..11 attributes
+// 10..8 joining type
+// 7..3 category type
+// }
+// 2 use xor pattern
+// 1..0 mapped category
//
// See the definitions below for a more detailed description of the various
// bits.
diff --git a/internal/language/tables.go b/internal/language/tables.go
index a19480c..3552e1a 100644
--- a/internal/language/tables.go
+++ b/internal/language/tables.go
@@ -121,9 +121,10 @@
// lang holds an alphabetically sorted list of ISO-639 language identifiers.
// All entries are 4 bytes. The index of the identifier (divided by 4) is the language tag.
// For 2-byte language identifiers, the two successive bytes have the following meaning:
-// - if the first letter of the 2- and 3-letter ISO codes are the same:
-// the second and third letter of the 3-letter ISO code.
-// - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
+// - if the first letter of the 2- and 3-letter ISO codes are the same:
+// the second and third letter of the 3-letter ISO code.
+// - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
+//
// For 3-byte language identifiers the 4th byte is 0.
const lang tag.Index = "" + // Size: 5324 bytes
"---\x00aaaraai\x00aak\x00aau\x00abbkabi\x00abq\x00abr\x00abt\x00aby\x00a" +
@@ -1086,9 +1087,9 @@
// regionISO holds a list of alphabetically sorted 2-letter ISO region codes.
// Each 2-letter codes is followed by two bytes with the following meaning:
-// - [A-Z}{2}: the first letter of the 2-letter code plus these two
-// letters form the 3-letter ISO code.
-// - 0, n: index into altRegionISO3.
+// - [A-Z]{2}: the first letter of the 2-letter code plus these two
+// letters form the 3-letter ISO code.
+// - 0, n: index into altRegionISO3.
const regionISO tag.Index = "" + // Size: 1308 bytes
"AAAAACSCADNDAEREAFFGAGTGAIIAALLBAMRMANNTAOGOAQTAARRGASSMATUTAUUSAWBWAXLA" +
"AZZEBAIHBBRBBDGDBEELBFFABGGRBHHRBIDIBJENBLLMBMMUBNRNBOOLBQESBRRABSHSBTTN" +
@@ -1206,7 +1207,9 @@
// m49Index gives indexes into fromM49 based on the three most significant bits
// of a 10-bit UN.M49 code. To search an UN.M49 code in fromM49, search in
-// fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
+//
+// fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
+//
// for an entry where the first 7 bits match the 7 lsb of the UN.M49 code.
// The region code is stored in the 9 lsb of the indexed value.
// Size: 18 bytes, 9 elements
diff --git a/internal/number/decimal.go b/internal/number/decimal.go
index cb656db..37e0c4b 100644
--- a/internal/number/decimal.go
+++ b/internal/number/decimal.go
@@ -33,13 +33,14 @@
// may point outside a valid position in Digits.
//
// Examples:
-// Number Decimal
-// 12345 Digits: [1, 2, 3, 4, 5], Exp: 5
-// 12.345 Digits: [1, 2, 3, 4, 5], Exp: 2
-// 12000 Digits: [1, 2], Exp: 5
-// 12000.00 Digits: [1, 2], Exp: 5
-// 0.00123 Digits: [1, 2, 3], Exp: -2
-// 0 Digits: [], Exp: 0
+//
+// Number Decimal
+// 12345 Digits: [1, 2, 3, 4, 5], Exp: 5
+// 12.345 Digits: [1, 2, 3, 4, 5], Exp: 2
+// 12000 Digits: [1, 2], Exp: 5
+// 12000.00 Digits: [1, 2], Exp: 5
+// 0.00123 Digits: [1, 2, 3], Exp: -2
+// 0 Digits: [], Exp: 0
type Decimal struct {
digits
@@ -60,22 +61,23 @@
// engineering notation. Digits must have at least one digit.
//
// Examples:
-// Number Decimal
-// decimal
-// 12345 Digits: [1, 2, 3, 4, 5], Exp: 5 End: 5
-// 12.345 Digits: [1, 2, 3, 4, 5], Exp: 2 End: 5
-// 12000 Digits: [1, 2], Exp: 5 End: 5
-// 12000.00 Digits: [1, 2], Exp: 5 End: 7
-// 0.00123 Digits: [1, 2, 3], Exp: -2 End: 3
-// 0 Digits: [], Exp: 0 End: 1
-// scientific (actual exp is Exp - Comma)
-// 0e0 Digits: [0], Exp: 1, End: 1, Comma: 1
-// .0e0 Digits: [0], Exp: 0, End: 1, Comma: 0
-// 0.0e0 Digits: [0], Exp: 1, End: 2, Comma: 1
-// 1.23e4 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 1
-// .123e5 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 0
-// engineering
-// 12.3e3 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 2
+//
+// Number Decimal
+// decimal
+// 12345 Digits: [1, 2, 3, 4, 5], Exp: 5 End: 5
+// 12.345 Digits: [1, 2, 3, 4, 5], Exp: 2 End: 5
+// 12000 Digits: [1, 2], Exp: 5 End: 5
+// 12000.00 Digits: [1, 2], Exp: 5 End: 7
+// 0.00123 Digits: [1, 2, 3], Exp: -2 End: 3
+// 0 Digits: [], Exp: 0 End: 1
+// scientific (actual exp is Exp - Comma)
+// 0e0 Digits: [0], Exp: 1, End: 1, Comma: 1
+// .0e0 Digits: [0], Exp: 0, End: 1, Comma: 0
+// 0.0e0 Digits: [0], Exp: 1, End: 2, Comma: 1
+// 1.23e4 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 1
+// .123e5 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 0
+// engineering
+// 12.3e3 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 2
type Digits struct {
digits
// End indicates the end position of the number.
diff --git a/internal/testtext/codesize.go b/internal/testtext/codesize.go
index 5fc5eae..88df487 100644
--- a/internal/testtext/codesize.go
+++ b/internal/testtext/codesize.go
@@ -16,11 +16,13 @@
// CodeSize builds the given code sample and returns the binary size or en error
// if an error occurred. The code sample typically will look like this:
-// package main
-// import "golang.org/x/text/somepackage"
-// func main() {
-// somepackage.Func() // reference Func to cause it to be linked in.
-// }
+//
+// package main
+// import "golang.org/x/text/somepackage"
+// func main() {
+// somepackage.Func() // reference Func to cause it to be linked in.
+// }
+//
// See dict_test.go in the display package for an example.
func CodeSize(s string) (int, error) {
// Write the file.
diff --git a/internal/triegen/triegen.go b/internal/triegen/triegen.go
index 51d218a..de54a80 100644
--- a/internal/triegen/triegen.go
+++ b/internal/triegen/triegen.go
@@ -34,23 +34,24 @@
// triegen generates both tables and code. The code is optimized to use the
// automatically chosen data types. The following code is generated for a Trie
// or multiple Tries named "foo":
-// - type fooTrie
-// The trie type.
//
-// - func newFooTrie(x int) *fooTrie
-// Trie constructor, where x is the index of the trie passed to Gen.
+// - type fooTrie
+// The trie type.
//
-// - func (t *fooTrie) lookup(s []byte) (v uintX, sz int)
-// The lookup method, where uintX is automatically chosen.
+// - func newFooTrie(x int) *fooTrie
+// Trie constructor, where x is the index of the trie passed to Gen.
//
-// - func lookupString, lookupUnsafe and lookupStringUnsafe
-// Variants of the above.
+// - func (t *fooTrie) lookup(s []byte) (v uintX, sz int)
+// The lookup method, where uintX is automatically chosen.
//
-// - var fooValues and fooIndex and any tables generated by Compacters.
-// The core trie data.
+// - func lookupString, lookupUnsafe and lookupStringUnsafe
+// Variants of the above.
//
-// - var fooTrieHandles
-// Indexes of starter blocks in case of multiple trie roots.
+// - var fooValues and fooIndex and any tables generated by Compacters.
+// The core trie data.
+//
+// - var fooTrieHandles
+// Indexes of starter blocks in case of multiple trie roots.
//
// It is recommended that users test the generated trie by checking the returned
// value for every rune. Such exhaustive tests are possible as the number of
diff --git a/internal/utf8internal/utf8internal.go b/internal/utf8internal/utf8internal.go
index 575cea8..e5c53b1 100644
--- a/internal/utf8internal/utf8internal.go
+++ b/internal/utf8internal/utf8internal.go
@@ -74,7 +74,7 @@
// AcceptRanges is a slice of AcceptRange values. For a given byte sequence b
//
-// AcceptRanges[First[b[0]]>>AcceptShift]
+// AcceptRanges[First[b[0]]>>AcceptShift]
//
// will give the value of AcceptRange for the multi-byte UTF-8 sequence starting
// at b[0].
diff --git a/language/display/lookup.go b/language/display/lookup.go
index e6dc0e0..8830775 100644
--- a/language/display/lookup.go
+++ b/language/display/lookup.go
@@ -92,10 +92,10 @@
// offsets for a string in data. For example, consider a header that defines
// strings for the languages de, el, en, fi, and nl:
//
-// header{
-// data: "GermanGreekEnglishDutch",
-// index: []uint16{ 0, 6, 11, 18, 18, 23 },
-// }
+// header{
+// data: "GermanGreekEnglishDutch",
+// index: []uint16{0, 6, 11, 18, 18, 23},
+// }
//
// For a language with index i, the string is defined by
// data[index[i]:index[i+1]]. So the number of elements in index is always one
@@ -204,9 +204,11 @@
// for each length, which can be used in combination with binary search to get
// the index associated with a tag.
// For example, a tagIndex{
-// "arenesfrruzh", // 6 2-byte tags.
-// "barwae", // 2 3-byte tags.
-// "",
+//
+// "arenesfrruzh", // 6 2-byte tags.
+// "barwae", // 2 3-byte tags.
+// "",
+//
// }
// would mean that the 2-byte tag "fr" had an index of 3, and the 3-byte tag
// "wae" had an index of 7.
diff --git a/language/doc.go b/language/doc.go
index 8afecd5..212b77c 100644
--- a/language/doc.go
+++ b/language/doc.go
@@ -10,18 +10,17 @@
// and provides the user with the best experience
// (see https://blog.golang.org/matchlang).
//
-//
-// Matching preferred against supported languages
+// # Matching preferred against supported languages
//
// A Matcher for an application that supports English, Australian English,
// Danish, and standard Mandarin can be created as follows:
//
-// var matcher = language.NewMatcher([]language.Tag{
-// language.English, // The first language is used as fallback.
-// language.MustParse("en-AU"),
-// language.Danish,
-// language.Chinese,
-// })
+// var matcher = language.NewMatcher([]language.Tag{
+// language.English, // The first language is used as fallback.
+// language.MustParse("en-AU"),
+// language.Danish,
+// language.Chinese,
+// })
//
// This list of supported languages is typically implied by the languages for
// which there exists translations of the user interface.
@@ -30,14 +29,14 @@
// language tags.
// The MatchString finds best matches for such strings:
//
-// handler(w http.ResponseWriter, r *http.Request) {
-// lang, _ := r.Cookie("lang")
-// accept := r.Header.Get("Accept-Language")
-// tag, _ := language.MatchStrings(matcher, lang.String(), accept)
+// handler(w http.ResponseWriter, r *http.Request) {
+// lang, _ := r.Cookie("lang")
+// accept := r.Header.Get("Accept-Language")
+// tag, _ := language.MatchStrings(matcher, lang.String(), accept)
//
-// // tag should now be used for the initialization of any
-// // locale-specific service.
-// }
+// // tag should now be used for the initialization of any
+// // locale-specific service.
+// }
//
// The Matcher's Match method can be used to match Tags directly.
//
@@ -48,8 +47,7 @@
// For instance, it will know that a reader of Bokmål Danish can read Norwegian
// and will know that Cantonese ("yue") is a good match for "zh-HK".
//
-//
-// Using match results
+// # Using match results
//
// To guarantee a consistent user experience to the user it is important to
// use the same language tag for the selection of any locale-specific services.
@@ -58,9 +56,9 @@
// More subtly confusing is using the wrong sorting order or casing
// algorithm for a certain language.
//
-// All the packages in x/text that provide locale-specific services
-// (e.g. collate, cases) should be initialized with the tag that was
-// obtained at the start of an interaction with the user.
+// All the packages in x/text that provide locale-specific services
+// (e.g. collate, cases) should be initialized with the tag that was
+// obtained at the start of an interaction with the user.
//
// Note that Tag that is returned by Match and MatchString may differ from any
// of the supported languages, as it may contain carried over settings from
@@ -70,8 +68,7 @@
// Match and MatchString both return the index of the matched supported tag
// to simplify associating such data with the matched tag.
//
-//
-// Canonicalization
+// # Canonicalization
//
// If one uses the Matcher to compare languages one does not need to
// worry about canonicalization.
@@ -92,10 +89,9 @@
// equivalence relations. The CanonType type can be used to alter the
// canonicalization form.
//
-// References
+// # References
//
// BCP 47 - Tags for Identifying Languages http://tools.ietf.org/html/bcp47
-//
package language // import "golang.org/x/text/language"
// TODO: explanation on how to match languages for your own locale-specific
diff --git a/message/catalog/catalog.go b/message/catalog/catalog.go
index de595b5..96955d0 100644
--- a/message/catalog/catalog.go
+++ b/message/catalog/catalog.go
@@ -13,8 +13,7 @@
// language. The Loader interface defines a source of dictionaries. A
// translation of a format string is represented by a Message.
//
-//
-// Catalogs
+// # Catalogs
//
// A Catalog defines a programmatic interface for setting message translations.
// It maintains a set of per-language dictionaries with translations for a set
@@ -24,8 +23,7 @@
// the key. For example, a Dictionary for "en-GB" could leave out entries that
// are identical to those in a dictionary for "en".
//
-//
-// Messages
+// # Messages
//
// A Message is a format string which varies on the value of substitution
// variables. For instance, to indicate the number of results one could want "no
@@ -39,8 +37,7 @@
// to selected string. This separation of concerns allows Catalog to be used to
// store any kind of formatting strings.
//
-//
-// Selecting messages based on linguistic features of substitution arguments
+// # Selecting messages based on linguistic features of substitution arguments
//
// Messages may vary based on any linguistic features of the argument values.
// The most common one is plural form, but others exist.
@@ -48,10 +45,10 @@
// Selection messages are provided in packages that provide support for a
// specific linguistic feature. The following snippet uses plural.Selectf:
//
-// catalog.Set(language.English, "You are %d minute(s) late.",
-// plural.Selectf(1, "",
-// plural.One, "You are 1 minute late.",
-// plural.Other, "You are %d minutes late."))
+// catalog.Set(language.English, "You are %d minute(s) late.",
+// plural.Selectf(1, "",
+// plural.One, "You are 1 minute late.",
+// plural.Other, "You are %d minutes late."))
//
// In this example, a message is stored in the Catalog where one of two messages
// is selected based on the first argument, a number. The first message is
@@ -64,47 +61,46 @@
// Selects can be nested. This allows selecting sentences based on features of
// multiple arguments or multiple linguistic properties of a single argument.
//
-//
-// String interpolation
+// # String interpolation
//
// There is often a lot of commonality between the possible variants of a
// message. For instance, in the example above the word "minute" varies based on
// the plural catogory of the argument, but the rest of the sentence is
// identical. Using interpolation the above message can be rewritten as:
//
-// catalog.Set(language.English, "You are %d minute(s) late.",
-// catalog.Var("minutes",
-// plural.Selectf(1, "", plural.One, "minute", plural.Other, "minutes")),
-// catalog.String("You are %[1]d ${minutes} late."))
+// catalog.Set(language.English, "You are %d minute(s) late.",
+// catalog.Var("minutes",
+// plural.Selectf(1, "", plural.One, "minute", plural.Other, "minutes")),
+// catalog.String("You are %[1]d ${minutes} late."))
//
// Var is defined to return the variable name if the message does not yield a
// match. This allows us to further simplify this snippet to
//
-// catalog.Set(language.English, "You are %d minute(s) late.",
-// catalog.Var("minutes", plural.Selectf(1, "", plural.One, "minute")),
-// catalog.String("You are %d ${minutes} late."))
+// catalog.Set(language.English, "You are %d minute(s) late.",
+// catalog.Var("minutes", plural.Selectf(1, "", plural.One, "minute")),
+// catalog.String("You are %d ${minutes} late."))
//
// Overall this is still only a minor improvement, but things can get a lot more
// unwieldy if more than one linguistic feature is used to determine a message
// variant. Consider the following example:
//
-// // argument 1: list of hosts, argument 2: list of guests
-// catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
-// catalog.Var("their",
-// plural.Selectf(1, ""
-// plural.One, gender.Select(1, "female", "her", "other", "his"))),
-// catalog.Var("invites", plural.Selectf(1, "", plural.One, "invite"))
-// catalog.String("%[1]v ${invites} %[2]v to ${their} party.")),
+// // argument 1: list of hosts, argument 2: list of guests
+// catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
+// catalog.Var("their",
+// plural.Selectf(1, ""
+// plural.One, gender.Select(1, "female", "her", "other", "his"))),
+// catalog.Var("invites", plural.Selectf(1, "", plural.One, "invite"))
+// catalog.String("%[1]v ${invites} %[2]v to ${their} party.")),
//
// Without variable substitution, this would have to be written as
//
-// // argument 1: list of hosts, argument 2: list of guests
-// catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
-// plural.Selectf(1, "",
-// plural.One, gender.Select(1,
-// "female", "%[1]v invites %[2]v to her party."
-// "other", "%[1]v invites %[2]v to his party."),
-// plural.Other, "%[1]v invites %[2]v to their party.")
+// // argument 1: list of hosts, argument 2: list of guests
+// catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
+// plural.Selectf(1, "",
+// plural.One, gender.Select(1,
+// "female", "%[1]v invites %[2]v to her party."
+// "other", "%[1]v invites %[2]v to his party."),
+// plural.Other, "%[1]v invites %[2]v to their party."))
//
// Not necessarily shorter, but using variables there is less duplication and
// the messages are more maintenance friendly. Moreover, languages may have up
@@ -113,33 +109,32 @@
// Different messages using the same inflections can reuse variables by moving
// them to macros. Using macros we can rewrite the message as:
//
-// // argument 1: list of hosts, argument 2: list of guests
-// catalog.SetString(language.English, "%[1]v invite(s) %[2]v to their party.",
-// "%[1]v ${invites(1)} %[2]v to ${their(1)} party.")
+// // argument 1: list of hosts, argument 2: list of guests
+// catalog.SetString(language.English, "%[1]v invite(s) %[2]v to their party.",
+// "%[1]v ${invites(1)} %[2]v to ${their(1)} party.")
//
// Where the following macros were defined separately.
//
-// catalog.SetMacro(language.English, "invites", plural.Selectf(1, "",
-// plural.One, "invite"))
-// catalog.SetMacro(language.English, "their", plural.Selectf(1, "",
-// plural.One, gender.Select(1, "female", "her", "other", "his"))),
+// catalog.SetMacro(language.English, "invites", plural.Selectf(1, "",
+// plural.One, "invite"))
+// catalog.SetMacro(language.English, "their", plural.Selectf(1, "",
+// plural.One, gender.Select(1, "female", "her", "other", "his"))),
//
// Placeholders use parentheses and the arguments to invoke a macro.
//
-//
-// Looking up messages
+// # Looking up messages
//
// Message lookup using Catalogs is typically only done by specialized packages
// and is not something the user should be concerned with. For instance, to
// express the tardiness of a user using the related message we defined earlier,
// the user may use the package message like so:
//
-// p := message.NewPrinter(language.English)
-// p.Printf("You are %d minute(s) late.", 5)
+// p := message.NewPrinter(language.English)
+// p.Printf("You are %d minute(s) late.", 5)
//
// Which would print:
-// You are 5 minutes late.
//
+// You are 5 minutes late.
//
// This package is UNDER CONSTRUCTION and its API may change.
package catalog // import "golang.org/x/text/message/catalog"
diff --git a/message/doc.go b/message/doc.go
index 72e8fde..4bf7bdc 100644
--- a/message/doc.go
+++ b/message/doc.go
@@ -5,22 +5,21 @@
// Package message implements formatted I/O for localized strings with functions
// analogous to the fmt's print functions. It is a drop-in replacement for fmt.
//
-//
-// Localized Formatting
+// # Localized Formatting
//
// A format string can be localized by replacing any of the print functions of
// fmt with an equivalent call to a Printer.
//
-// p := message.NewPrinter(message.MatchLanguage("en"))
-// p.Println(123456.78) // Prints 123,456.78
+// p := message.NewPrinter(message.MatchLanguage("en"))
+// p.Println(123456.78) // Prints 123,456.78
//
-// p.Printf("%d ducks in a row", 4331) // Prints 4,331 ducks in a row
+// p.Printf("%d ducks in a row", 4331) // Prints 4,331 ducks in a row
//
-// p := message.NewPrinter(message.MatchLanguage("nl"))
-// p.Printf("Hoogte: %.1f meter", 1244.9) // Prints Hoogte: 1,244.9 meter
+// p := message.NewPrinter(message.MatchLanguage("nl"))
+// p.Printf("Hoogte: %.1f meter", 1244.9) // Prints Hoogte: 1,244.9 meter
//
-// p := message.NewPrinter(message.MatchLanguage("bn"))
-// p.Println(123456.78) // Prints ১,২৩,৪৫৬.৭৮
+// p := message.NewPrinter(message.MatchLanguage("bn"))
+// p.Println(123456.78) // Prints ১,২৩,৪৫৬.৭৮
//
// Printer currently supports numbers and specialized types for which packages
// exist in x/text. Other builtin types such as time.Time and slices are
@@ -35,8 +34,7 @@
//
// See package fmt for more options.
//
-//
-// Translation
+// # Translation
//
// The format strings that are passed to Printf, Sprintf, Fprintf, or Errorf
// are used as keys to look up translations for the specified languages.
@@ -44,34 +42,36 @@
//
// One can use arbitrary keys to distinguish between otherwise ambiguous
// strings:
-// p := message.NewPrinter(language.English)
-// p.Printf("archive(noun)") // Prints "archive"
-// p.Printf("archive(verb)") // Prints "archive"
//
-// p := message.NewPrinter(language.German)
-// p.Printf("archive(noun)") // Prints "Archiv"
-// p.Printf("archive(verb)") // Prints "archivieren"
+// p := message.NewPrinter(language.English)
+// p.Printf("archive(noun)") // Prints "archive"
+// p.Printf("archive(verb)") // Prints "archive"
+//
+// p := message.NewPrinter(language.German)
+// p.Printf("archive(noun)") // Prints "Archiv"
+// p.Printf("archive(verb)") // Prints "archivieren"
//
// To retain the fallback functionality, use Key:
-// p.Printf(message.Key("archive(noun)", "archive"))
-// p.Printf(message.Key("archive(verb)", "archive"))
//
+// p.Printf(message.Key("archive(noun)", "archive"))
+// p.Printf(message.Key("archive(verb)", "archive"))
//
-// Translation Pipeline
+// # Translation Pipeline
//
// Format strings that contain text need to be translated to support different
// locales. The first step is to extract strings that need to be translated.
//
// 1. Install gotext
-// go get -u golang.org/x/text/cmd/gotext
-// gotext -help
+//
+// go get -u golang.org/x/text/cmd/gotext
+// gotext -help
//
// 2. Mark strings in your source to be translated by using message.Printer,
// instead of the functions of the fmt package.
//
// 3. Extract the strings from your source
//
-// gotext extract
+// gotext extract
//
// The output will be written to the textdata directory.
//
@@ -89,13 +89,11 @@
// see also package golang.org/x/text/message/catalog can be used to implement
// either dynamic or static loading of messages.
//
-//
-// Plural and Gender Forms
+// # Plural and Gender Forms
//
// Translated messages can vary based on the plural and gender forms of
// substitution values. In general, it is up to the translators to provide
// alternative translations for such forms. See the packages in
// golang.org/x/text/feature and golang.org/x/text/message/catalog for more
// information.
-//
package message
diff --git a/number/doc.go b/number/doc.go
index 2ad8d43..8766230 100644
--- a/number/doc.go
+++ b/number/doc.go
@@ -9,19 +9,18 @@
// builtin Go types and anything that implements the Convert interface
// (currently internal).
//
-// p := message.NewPrinter(language.English)
+// p := message.NewPrinter(language.English)
//
-// p.Printf("%v bottles of beer on the wall.", number.Decimal(1234))
-// // Prints: 1,234 bottles of beer on the wall.
+// p.Printf("%v bottles of beer on the wall.", number.Decimal(1234))
+// // Prints: 1,234 bottles of beer on the wall.
//
-// p.Printf("%v of gophers lose too much fur", number.Percent(0.12))
-// // Prints: 12% of gophers lose too much fur.
+// p.Printf("%v of gophers lose too much fur", number.Percent(0.12))
+// // Prints: 12% of gophers lose too much fur.
//
-// p := message.NewPrinter(language.Dutch)
+// p := message.NewPrinter(language.Dutch)
//
-// p.Printf("There are %v bikes per household.", number.Decimal(1.2))
-// // Prints: Er zijn 1,2 fietsen per huishouden.
-//
+// p.Printf("There are %v bikes per household.", number.Decimal(1.2))
+// // Prints: Er zijn 1,2 fietsen per huishouden.
//
// The width and scale specified in the formatting directives override the
// configuration of the formatter.
diff --git a/unicode/bidi/core.go b/unicode/bidi/core.go
index fde188a..9d2ae54 100644
--- a/unicode/bidi/core.go
+++ b/unicode/bidi/core.go
@@ -193,14 +193,14 @@
//
// At the end of this function:
//
-// - The member variable matchingPDI is set to point to the index of the
-// matching PDI character for each isolate initiator character. If there is
-// no matching PDI, it is set to the length of the input text. For other
-// characters, it is set to -1.
-// - The member variable matchingIsolateInitiator is set to point to the
-// index of the matching isolate initiator character for each PDI character.
-// If there is no matching isolate initiator, or the character is not a PDI,
-// it is set to -1.
+// - The member variable matchingPDI is set to point to the index of the
+// matching PDI character for each isolate initiator character. If there is
+// no matching PDI, it is set to the length of the input text. For other
+// characters, it is set to -1.
+// - The member variable matchingIsolateInitiator is set to point to the
+// index of the matching isolate initiator character for each PDI character.
+// If there is no matching isolate initiator, or the character is not a PDI,
+// it is set to -1.
func (p *paragraph) determineMatchingIsolates() {
p.matchingPDI = make([]int, p.Len())
p.matchingIsolateInitiator = make([]int, p.Len())
@@ -435,7 +435,7 @@
}
// Rule X10, second bullet: Determine the start-of-sequence (sos) and end-of-sequence (eos) types,
-// either L or R, for each isolating run sequence.
+// either L or R, for each isolating run sequence.
func (p *paragraph) isolatingRunSequence(indexes []int) *isolatingRunSequence {
length := len(indexes)
types := make([]Class, length)
@@ -905,7 +905,7 @@
// Lines are concatenated from left to right. So for example, the fifth
// character from the left on the third line is
//
-// getReordering(linebreaks)[linebreaks[1] + 4]
+// getReordering(linebreaks)[linebreaks[1] + 4]
//
// (linebreaks[1] is the position after the last character of the second
// line, which is also the index of the first character on the third line,
diff --git a/unicode/cldr/collate.go b/unicode/cldr/collate.go
index 27c5bac..056fe7f 100644
--- a/unicode/cldr/collate.go
+++ b/unicode/cldr/collate.go
@@ -98,9 +98,13 @@
}
// parseSpecialAnchor parses the anchor syntax which is either of the form
-// ['before' <level>] <anchor>
+//
+// ['before' <level>] <anchor>
+//
// or
-// [<label>]
+//
+// [<label>]
+//
// The starting should already be consumed.
func parseSpecialAnchor(p RuleProcessor, s string) (tail string, err error) {
i := strings.IndexByte(s, ']')
diff --git a/unicode/norm/forminfo.go b/unicode/norm/forminfo.go
index 526c703..d69ccb4 100644
--- a/unicode/norm/forminfo.go
+++ b/unicode/norm/forminfo.go
@@ -110,10 +110,11 @@
}
// We pack quick check data in 4 bits:
-// 5: Combines forward (0 == false, 1 == true)
-// 4..3: NFC_QC Yes(00), No (10), or Maybe (11)
-// 2: NFD_QC Yes (0) or No (1). No also means there is a decomposition.
-// 1..0: Number of trailing non-starters.
+//
+// 5: Combines forward (0 == false, 1 == true)
+// 4..3: NFC_QC Yes(00), No (10), or Maybe (11)
+// 2: NFD_QC Yes (0) or No (1). No also means there is a decomposition.
+// 1..0: Number of trailing non-starters.
//
// When all 4 bits are zero, the character is inert, meaning it is never
// influenced by normalization.
diff --git a/unicode/norm/maketables.go b/unicode/norm/maketables.go
index 0d24d21..dd05b6f 100644
--- a/unicode/norm/maketables.go
+++ b/unicode/norm/maketables.go
@@ -132,8 +132,10 @@
}
// In UnicodeData.txt, some ranges are marked like this:
+//
// 3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
// 4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
+//
// parseCharacter keeps a state variable indicating the weirdness.
type State int
diff --git a/unicode/norm/normalize.go b/unicode/norm/normalize.go
index 95efcf2..4747ad0 100644
--- a/unicode/norm/normalize.go
+++ b/unicode/norm/normalize.go
@@ -18,16 +18,17 @@
// A Form denotes a canonical representation of Unicode code points.
// The Unicode-defined normalization and equivalence forms are:
//
-// NFC Unicode Normalization Form C
-// NFD Unicode Normalization Form D
-// NFKC Unicode Normalization Form KC
-// NFKD Unicode Normalization Form KD
+// NFC Unicode Normalization Form C
+// NFD Unicode Normalization Form D
+// NFKC Unicode Normalization Form KC
+// NFKD Unicode Normalization Form KD
//
// For a Form f, this documentation uses the notation f(x) to mean
// the bytes or string x converted to the given form.
// A position n in x is called a boundary if conversion to the form can
// proceed independently on both sides:
-// f(x) == append(f(x[0:n]), f(x[n:])...)
+//
+// f(x) == append(f(x[0:n]), f(x[n:])...)
//
// References: https://unicode.org/reports/tr15/ and
// https://unicode.org/notes/tn5/.
diff --git a/width/tables10.0.0.go b/width/tables10.0.0.go
index 186b1d4..cd9d91c 100644
--- a/width/tables10.0.0.go
+++ b/width/tables10.0.0.go
@@ -1146,21 +1146,31 @@
}
// inverseData contains 4-byte entries of the following format:
-// <length> <modified UTF-8-encoded rune> <0 padding>
+//
+// <length> <modified UTF-8-encoded rune> <0 padding>
+//
// The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
// UTF-8 encoding of the original rune. Mappings often have the following
// pattern:
-// Ａ -> A (U+FF21 -> U+0041)
-// Ｂ -> B (U+FF22 -> U+0042)
-// ...
+//
+// Ａ -> A (U+FF21 -> U+0041)
+// Ｂ -> B (U+FF22 -> U+0042)
+// ...
+//
// By xor-ing the last byte the same entry can be shared by many mappings. This
// reduces the total number of distinct entries by about two thirds.
// The resulting entry for the aforementioned mappings is
-// { 0x01, 0xE0, 0x00, 0x00 }
+//
+// { 0x01, 0xE0, 0x00, 0x00 }
+//
// Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-// E0 ^ A1 = 41.
+//
+// E0 ^ A1 = 41.
+//
// Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-// E0 ^ A2 = 42.
+//
+// E0 ^ A2 = 42.
+//
// Note that because of the xor-ing, the byte sequence stored in the entry is
// not valid UTF-8.
var inverseData = [150][4]byte{
diff --git a/width/tables11.0.0.go b/width/tables11.0.0.go
index 990f762..327eaef 100644
--- a/width/tables11.0.0.go
+++ b/width/tables11.0.0.go
@@ -1158,21 +1158,31 @@
}
// inverseData contains 4-byte entries of the following format:
-// <length> <modified UTF-8-encoded rune> <0 padding>
+//
+// <length> <modified UTF-8-encoded rune> <0 padding>
+//
// The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
// UTF-8 encoding of the original rune. Mappings often have the following
// pattern:
-// Ａ -> A (U+FF21 -> U+0041)
-// Ｂ -> B (U+FF22 -> U+0042)
-// ...
+//
+// Ａ -> A (U+FF21 -> U+0041)
+// Ｂ -> B (U+FF22 -> U+0042)
+// ...
+//
// By xor-ing the last byte the same entry can be shared by many mappings. This
// reduces the total number of distinct entries by about two thirds.
// The resulting entry for the aforementioned mappings is
-// { 0x01, 0xE0, 0x00, 0x00 }
+//
+// { 0x01, 0xE0, 0x00, 0x00 }
+//
// Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-// E0 ^ A1 = 41.
+//
+// E0 ^ A1 = 41.
+//
// Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-// E0 ^ A2 = 42.
+//
+// E0 ^ A2 = 42.
+//
// Note that because of the xor-ing, the byte sequence stored in the entry is
// not valid UTF-8.
var inverseData = [150][4]byte{
diff --git a/width/tables12.0.0.go b/width/tables12.0.0.go
index 8529629..5c14ade 100644
--- a/width/tables12.0.0.go
+++ b/width/tables12.0.0.go
@@ -1178,21 +1178,31 @@
}
// inverseData contains 4-byte entries of the following format:
-// <length> <modified UTF-8-encoded rune> <0 padding>
+//
+// <length> <modified UTF-8-encoded rune> <0 padding>
+//
// The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
// UTF-8 encoding of the original rune. Mappings often have the following
// pattern:
-// Ａ -> A (U+FF21 -> U+0041)
-// Ｂ -> B (U+FF22 -> U+0042)
-// ...
+//
+// Ａ -> A (U+FF21 -> U+0041)
+// Ｂ -> B (U+FF22 -> U+0042)
+// ...
+//
// By xor-ing the last byte the same entry can be shared by many mappings. This
// reduces the total number of distinct entries by about two thirds.
// The resulting entry for the aforementioned mappings is
-// { 0x01, 0xE0, 0x00, 0x00 }
+//
+// { 0x01, 0xE0, 0x00, 0x00 }
+//
// Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-// E0 ^ A1 = 41.
+//
+// E0 ^ A1 = 41.
+//
// Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-// E0 ^ A2 = 42.
+//
+// E0 ^ A2 = 42.
+//
// Note that because of the xor-ing, the byte sequence stored in the entry is
// not valid UTF-8.
var inverseData = [150][4]byte{
diff --git a/width/tables13.0.0.go b/width/tables13.0.0.go
index bac3f1a..ab258e3 100644
--- a/width/tables13.0.0.go
+++ b/width/tables13.0.0.go
@@ -1179,21 +1179,31 @@
}
// inverseData contains 4-byte entries of the following format:
-// <length> <modified UTF-8-encoded rune> <0 padding>
+//
+// <length> <modified UTF-8-encoded rune> <0 padding>
+//
// The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
// UTF-8 encoding of the original rune. Mappings often have the following
// pattern:
-// Ａ -> A (U+FF21 -> U+0041)
-// Ｂ -> B (U+FF22 -> U+0042)
-// ...
+//
+// Ａ -> A (U+FF21 -> U+0041)
+// Ｂ -> B (U+FF22 -> U+0042)
+// ...
+//
// By xor-ing the last byte the same entry can be shared by many mappings. This
// reduces the total number of distinct entries by about two thirds.
// The resulting entry for the aforementioned mappings is
-// { 0x01, 0xE0, 0x00, 0x00 }
+//
+// { 0x01, 0xE0, 0x00, 0x00 }
+//
// Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-// E0 ^ A1 = 41.
+//
+// E0 ^ A1 = 41.
+//
// Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-// E0 ^ A2 = 42.
+//
+// E0 ^ A2 = 42.
+//
// Note that because of the xor-ing, the byte sequence stored in the entry is
// not valid UTF-8.
var inverseData = [150][4]byte{
diff --git a/width/tables9.0.0.go b/width/tables9.0.0.go
index b3db84f..6781f3d 100644
--- a/width/tables9.0.0.go
+++ b/width/tables9.0.0.go
@@ -1114,21 +1114,31 @@
}
// inverseData contains 4-byte entries of the following format:
-// <length> <modified UTF-8-encoded rune> <0 padding>
+//
+// <length> <modified UTF-8-encoded rune> <0 padding>
+//
// The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
// UTF-8 encoding of the original rune. Mappings often have the following
// pattern:
-// Ａ -> A (U+FF21 -> U+0041)
-// Ｂ -> B (U+FF22 -> U+0042)
-// ...
+//
+// Ａ -> A (U+FF21 -> U+0041)
+// Ｂ -> B (U+FF22 -> U+0042)
+// ...
+//
// By xor-ing the last byte the same entry can be shared by many mappings. This
// reduces the total number of distinct entries by about two thirds.
// The resulting entry for the aforementioned mappings is
-// { 0x01, 0xE0, 0x00, 0x00 }
+//
+// { 0x01, 0xE0, 0x00, 0x00 }
+//
// Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-// E0 ^ A1 = 41.
+//
+// E0 ^ A1 = 41.
+//
// Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-// E0 ^ A2 = 42.
+//
+// E0 ^ A2 = 42.
+//
// Note that because of the xor-ing, the byte sequence stored in the entry is
// not valid UTF-8.
var inverseData = [150][4]byte{
