本站源代码
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

735 lines
20KB

  1. // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
  2. // Copyright 2016 The Go Authors. All rights reserved.
  3. // Use of this source code is governed by a BSD-style
  4. // license that can be found in the LICENSE file.
  5. // +build go1.10
  6. // Package idna implements IDNA2008 using the compatibility processing
  7. // defined by UTS (Unicode Technical Standard) #46, which defines a standard to
  8. // deal with the transition from IDNA2003.
  9. //
  10. // IDNA2008 (Internationalized Domain Names for Applications), is defined in RFC
  11. // 5890, RFC 5891, RFC 5892, RFC 5893 and RFC 5894.
  12. // UTS #46 is defined in https://www.unicode.org/reports/tr46.
  13. // See https://unicode.org/cldr/utility/idna.jsp for a visualization of the
  14. // differences between these two standards.
  15. package idna // import "golang.org/x/net/idna"
  16. import (
  17. "fmt"
  18. "strings"
  19. "unicode/utf8"
  20. "golang.org/x/text/secure/bidirule"
  21. "golang.org/x/text/unicode/bidi"
  22. "golang.org/x/text/unicode/norm"
  23. )
  24. // NOTE: Unlike common practice in Go APIs, the functions will return a
  25. // sanitized domain name in case of errors. Browsers sometimes use a partially
  26. // evaluated string as lookup.
  27. // TODO: the current error handling is, in my opinion, the least opinionated.
  28. // Other strategies are also viable, though:
  29. // Option 1) Return an empty string in case of error, but allow the user to
  30. // specify explicitly which errors to ignore.
  31. // Option 2) Return the partially evaluated string if it is itself a valid
  32. // string, otherwise return the empty string in case of error.
  33. // Option 3) Option 1 and 2.
  34. // Option 4) Always return an empty string for now and implement Option 1 as
  35. // needed, and document that the return string may not be empty in case of
  36. // error in the future.
  37. // I think Option 1 is best, but it is quite opinionated.
  38. // ToASCII is a wrapper for Punycode.ToASCII.
  39. func ToASCII(s string) (string, error) {
  40. return Punycode.process(s, true)
  41. }
  42. // ToUnicode is a wrapper for Punycode.ToUnicode.
  43. func ToUnicode(s string) (string, error) {
  44. return Punycode.process(s, false)
  45. }
  46. // An Option configures a Profile at creation time.
  47. type Option func(*options)
  48. // Transitional sets a Profile to use the Transitional mapping as defined in UTS
  49. // #46. This will cause, for example, "ß" to be mapped to "ss". Using the
  50. // transitional mapping provides a compromise between IDNA2003 and IDNA2008
  51. // compatibility. It is used by most browsers when resolving domain names. This
  52. // option is only meaningful if combined with MapForLookup.
  53. func Transitional(transitional bool) Option {
  54. return func(o *options) { o.transitional = true }
  55. }
  56. // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
  57. // are longer than allowed by the RFC.
  58. func VerifyDNSLength(verify bool) Option {
  59. return func(o *options) { o.verifyDNSLength = verify }
  60. }
  61. // RemoveLeadingDots removes leading label separators. Leading runes that map to
  62. // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.
  63. //
  64. // This is the behavior suggested by the UTS #46 and is adopted by some
  65. // browsers.
  66. func RemoveLeadingDots(remove bool) Option {
  67. return func(o *options) { o.removeLeadingDots = remove }
  68. }
  69. // ValidateLabels sets whether to check the mandatory label validation criteria
  70. // as defined in Section 5.4 of RFC 5891. This includes testing for correct use
  71. // of hyphens ('-'), normalization, validity of runes, and the context rules.
  72. func ValidateLabels(enable bool) Option {
  73. return func(o *options) {
  74. // Don't override existing mappings, but set one that at least checks
  75. // normalization if it is not set.
  76. if o.mapping == nil && enable {
  77. o.mapping = normalize
  78. }
  79. o.trie = trie
  80. o.validateLabels = enable
  81. o.fromPuny = validateFromPunycode
  82. }
  83. }
  84. // StrictDomainName limits the set of permissible ASCII characters to those
  85. // allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the
  86. // hyphen). This is set by default for MapForLookup and ValidateForRegistration.
  87. //
  88. // This option is useful, for instance, for browsers that allow characters
  89. // outside this range, for example a '_' (U+005F LOW LINE). See
  90. // http://www.rfc-editor.org/std/std3.txt for more details This option
  91. // corresponds to the UseSTD3ASCIIRules option in UTS #46.
  92. func StrictDomainName(use bool) Option {
  93. return func(o *options) {
  94. o.trie = trie
  95. o.useSTD3Rules = use
  96. o.fromPuny = validateFromPunycode
  97. }
  98. }
  99. // NOTE: the following options pull in tables. The tables should not be linked
  100. // in as long as the options are not used.
  101. // BidiRule enables the Bidi rule as defined in RFC 5893. Any application
  102. // that relies on proper validation of labels should include this rule.
  103. func BidiRule() Option {
  104. return func(o *options) { o.bidirule = bidirule.ValidString }
  105. }
  106. // ValidateForRegistration sets validation options to verify that a given IDN is
  107. // properly formatted for registration as defined by Section 4 of RFC 5891.
  108. func ValidateForRegistration() Option {
  109. return func(o *options) {
  110. o.mapping = validateRegistration
  111. StrictDomainName(true)(o)
  112. ValidateLabels(true)(o)
  113. VerifyDNSLength(true)(o)
  114. BidiRule()(o)
  115. }
  116. }
  117. // MapForLookup sets validation and mapping options such that a given IDN is
  118. // transformed for domain name lookup according to the requirements set out in
  119. // Section 5 of RFC 5891. The mappings follow the recommendations of RFC 5894,
  120. // RFC 5895 and UTS 46. It does not add the Bidi Rule. Use the BidiRule option
  121. // to add this check.
  122. //
  123. // The mappings include normalization and mapping case, width and other
  124. // compatibility mappings.
  125. func MapForLookup() Option {
  126. return func(o *options) {
  127. o.mapping = validateAndMap
  128. StrictDomainName(true)(o)
  129. ValidateLabels(true)(o)
  130. }
  131. }
  132. type options struct {
  133. transitional bool
  134. useSTD3Rules bool
  135. validateLabels bool
  136. verifyDNSLength bool
  137. removeLeadingDots bool
  138. trie *idnaTrie
  139. // fromPuny calls validation rules when converting A-labels to U-labels.
  140. fromPuny func(p *Profile, s string) error
  141. // mapping implements a validation and mapping step as defined in RFC 5895
  142. // or UTS 46, tailored to, for example, domain registration or lookup.
  143. mapping func(p *Profile, s string) (mapped string, isBidi bool, err error)
  144. // bidirule, if specified, checks whether s conforms to the Bidi Rule
  145. // defined in RFC 5893.
  146. bidirule func(s string) bool
  147. }
  148. // A Profile defines the configuration of an IDNA mapper.
  149. type Profile struct {
  150. options
  151. }
  152. func apply(o *options, opts []Option) {
  153. for _, f := range opts {
  154. f(o)
  155. }
  156. }
  157. // New creates a new Profile.
  158. //
  159. // With no options, the returned Profile is the most permissive and equals the
  160. // Punycode Profile. Options can be passed to further restrict the Profile. The
  161. // MapForLookup and ValidateForRegistration options set a collection of options,
  162. // for lookup and registration purposes respectively, which can be tailored by
  163. // adding more fine-grained options, where later options override earlier
  164. // options.
  165. func New(o ...Option) *Profile {
  166. p := &Profile{}
  167. apply(&p.options, o)
  168. return p
  169. }
  170. // ToASCII converts a domain or domain label to its ASCII form. For example,
  171. // ToASCII("bücher.example.com") is "xn--bcher-kva.example.com", and
  172. // ToASCII("golang") is "golang". If an error is encountered it will return
  173. // an error and a (partially) processed result.
  174. func (p *Profile) ToASCII(s string) (string, error) {
  175. return p.process(s, true)
  176. }
  177. // ToUnicode converts a domain or domain label to its Unicode form. For example,
  178. // ToUnicode("xn--bcher-kva.example.com") is "bücher.example.com", and
  179. // ToUnicode("golang") is "golang". If an error is encountered it will return
  180. // an error and a (partially) processed result.
  181. func (p *Profile) ToUnicode(s string) (string, error) {
  182. pp := *p
  183. pp.transitional = false
  184. return pp.process(s, false)
  185. }
  186. // String reports a string with a description of the profile for debugging
  187. // purposes. The string format may change with different versions.
  188. func (p *Profile) String() string {
  189. s := ""
  190. if p.transitional {
  191. s = "Transitional"
  192. } else {
  193. s = "NonTransitional"
  194. }
  195. if p.useSTD3Rules {
  196. s += ":UseSTD3Rules"
  197. }
  198. if p.validateLabels {
  199. s += ":ValidateLabels"
  200. }
  201. if p.verifyDNSLength {
  202. s += ":VerifyDNSLength"
  203. }
  204. return s
  205. }
  206. var (
  207. // Punycode is a Profile that does raw punycode processing with a minimum
  208. // of validation.
  209. Punycode *Profile = punycode
  210. // Lookup is the recommended profile for looking up domain names, according
  211. // to Section 5 of RFC 5891. The exact configuration of this profile may
  212. // change over time.
  213. Lookup *Profile = lookup
  214. // Display is the recommended profile for displaying domain names.
  215. // The configuration of this profile may change over time.
  216. Display *Profile = display
  217. // Registration is the recommended profile for checking whether a given
  218. // IDN is valid for registration, according to Section 4 of RFC 5891.
  219. Registration *Profile = registration
  220. punycode = &Profile{}
  221. lookup = &Profile{options{
  222. transitional: true,
  223. useSTD3Rules: true,
  224. validateLabels: true,
  225. trie: trie,
  226. fromPuny: validateFromPunycode,
  227. mapping: validateAndMap,
  228. bidirule: bidirule.ValidString,
  229. }}
  230. display = &Profile{options{
  231. useSTD3Rules: true,
  232. validateLabels: true,
  233. trie: trie,
  234. fromPuny: validateFromPunycode,
  235. mapping: validateAndMap,
  236. bidirule: bidirule.ValidString,
  237. }}
  238. registration = &Profile{options{
  239. useSTD3Rules: true,
  240. validateLabels: true,
  241. verifyDNSLength: true,
  242. trie: trie,
  243. fromPuny: validateFromPunycode,
  244. mapping: validateRegistration,
  245. bidirule: bidirule.ValidString,
  246. }}
  247. // TODO: profiles
  248. // Register: recommended for approving domain names: don't do any mappings
  249. // but rather reject on invalid input. Bundle or block deviation characters.
  250. )
  251. type labelError struct{ label, code_ string }
  252. func (e labelError) code() string { return e.code_ }
  253. func (e labelError) Error() string {
  254. return fmt.Sprintf("idna: invalid label %q", e.label)
  255. }
  256. type runeError rune
  257. func (e runeError) code() string { return "P1" }
  258. func (e runeError) Error() string {
  259. return fmt.Sprintf("idna: disallowed rune %U", e)
  260. }
  261. // process implements the algorithm described in section 4 of UTS #46,
  262. // see https://www.unicode.org/reports/tr46.
  263. func (p *Profile) process(s string, toASCII bool) (string, error) {
  264. var err error
  265. var isBidi bool
  266. if p.mapping != nil {
  267. s, isBidi, err = p.mapping(p, s)
  268. }
  269. // Remove leading empty labels.
  270. if p.removeLeadingDots {
  271. for ; len(s) > 0 && s[0] == '.'; s = s[1:] {
  272. }
  273. }
  274. // TODO: allow for a quick check of the tables data.
  275. // It seems like we should only create this error on ToASCII, but the
  276. // UTS 46 conformance tests suggests we should always check this.
  277. if err == nil && p.verifyDNSLength && s == "" {
  278. err = &labelError{s, "A4"}
  279. }
  280. labels := labelIter{orig: s}
  281. for ; !labels.done(); labels.next() {
  282. label := labels.label()
  283. if label == "" {
  284. // Empty labels are not okay. The label iterator skips the last
  285. // label if it is empty.
  286. if err == nil && p.verifyDNSLength {
  287. err = &labelError{s, "A4"}
  288. }
  289. continue
  290. }
  291. if strings.HasPrefix(label, acePrefix) {
  292. u, err2 := decode(label[len(acePrefix):])
  293. if err2 != nil {
  294. if err == nil {
  295. err = err2
  296. }
  297. // Spec says keep the old label.
  298. continue
  299. }
  300. isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight
  301. labels.set(u)
  302. if err == nil && p.validateLabels {
  303. err = p.fromPuny(p, u)
  304. }
  305. if err == nil {
  306. // This should be called on NonTransitional, according to the
  307. // spec, but that currently does not have any effect. Use the
  308. // original profile to preserve options.
  309. err = p.validateLabel(u)
  310. }
  311. } else if err == nil {
  312. err = p.validateLabel(label)
  313. }
  314. }
  315. if isBidi && p.bidirule != nil && err == nil {
  316. for labels.reset(); !labels.done(); labels.next() {
  317. if !p.bidirule(labels.label()) {
  318. err = &labelError{s, "B"}
  319. break
  320. }
  321. }
  322. }
  323. if toASCII {
  324. for labels.reset(); !labels.done(); labels.next() {
  325. label := labels.label()
  326. if !ascii(label) {
  327. a, err2 := encode(acePrefix, label)
  328. if err == nil {
  329. err = err2
  330. }
  331. label = a
  332. labels.set(a)
  333. }
  334. n := len(label)
  335. if p.verifyDNSLength && err == nil && (n == 0 || n > 63) {
  336. err = &labelError{label, "A4"}
  337. }
  338. }
  339. }
  340. s = labels.result()
  341. if toASCII && p.verifyDNSLength && err == nil {
  342. // Compute the length of the domain name minus the root label and its dot.
  343. n := len(s)
  344. if n > 0 && s[n-1] == '.' {
  345. n--
  346. }
  347. if len(s) < 1 || n > 253 {
  348. err = &labelError{s, "A4"}
  349. }
  350. }
  351. return s, err
  352. }
  353. func normalize(p *Profile, s string) (mapped string, isBidi bool, err error) {
  354. // TODO: consider first doing a quick check to see if any of these checks
  355. // need to be done. This will make it slower in the general case, but
  356. // faster in the common case.
  357. mapped = norm.NFC.String(s)
  358. isBidi = bidirule.DirectionString(mapped) == bidi.RightToLeft
  359. return mapped, isBidi, nil
  360. }
  361. func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error) {
  362. // TODO: filter need for normalization in loop below.
  363. if !norm.NFC.IsNormalString(s) {
  364. return s, false, &labelError{s, "V1"}
  365. }
  366. for i := 0; i < len(s); {
  367. v, sz := trie.lookupString(s[i:])
  368. if sz == 0 {
  369. return s, bidi, runeError(utf8.RuneError)
  370. }
  371. bidi = bidi || info(v).isBidi(s[i:])
  372. // Copy bytes not copied so far.
  373. switch p.simplify(info(v).category()) {
  374. // TODO: handle the NV8 defined in the Unicode idna data set to allow
  375. // for strict conformance to IDNA2008.
  376. case valid, deviation:
  377. case disallowed, mapped, unknown, ignored:
  378. r, _ := utf8.DecodeRuneInString(s[i:])
  379. return s, bidi, runeError(r)
  380. }
  381. i += sz
  382. }
  383. return s, bidi, nil
  384. }
  385. func (c info) isBidi(s string) bool {
  386. if !c.isMapped() {
  387. return c&attributesMask == rtl
  388. }
  389. // TODO: also store bidi info for mapped data. This is possible, but a bit
  390. // cumbersome and not for the common case.
  391. p, _ := bidi.LookupString(s)
  392. switch p.Class() {
  393. case bidi.R, bidi.AL, bidi.AN:
  394. return true
  395. }
  396. return false
  397. }
  398. func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error) {
  399. var (
  400. b []byte
  401. k int
  402. )
  403. // combinedInfoBits contains the or-ed bits of all runes. We use this
  404. // to derive the mayNeedNorm bit later. This may trigger normalization
  405. // overeagerly, but it will not do so in the common case. The end result
  406. // is another 10% saving on BenchmarkProfile for the common case.
  407. var combinedInfoBits info
  408. for i := 0; i < len(s); {
  409. v, sz := trie.lookupString(s[i:])
  410. if sz == 0 {
  411. b = append(b, s[k:i]...)
  412. b = append(b, "\ufffd"...)
  413. k = len(s)
  414. if err == nil {
  415. err = runeError(utf8.RuneError)
  416. }
  417. break
  418. }
  419. combinedInfoBits |= info(v)
  420. bidi = bidi || info(v).isBidi(s[i:])
  421. start := i
  422. i += sz
  423. // Copy bytes not copied so far.
  424. switch p.simplify(info(v).category()) {
  425. case valid:
  426. continue
  427. case disallowed:
  428. if err == nil {
  429. r, _ := utf8.DecodeRuneInString(s[start:])
  430. err = runeError(r)
  431. }
  432. continue
  433. case mapped, deviation:
  434. b = append(b, s[k:start]...)
  435. b = info(v).appendMapping(b, s[start:i])
  436. case ignored:
  437. b = append(b, s[k:start]...)
  438. // drop the rune
  439. case unknown:
  440. b = append(b, s[k:start]...)
  441. b = append(b, "\ufffd"...)
  442. }
  443. k = i
  444. }
  445. if k == 0 {
  446. // No changes so far.
  447. if combinedInfoBits&mayNeedNorm != 0 {
  448. s = norm.NFC.String(s)
  449. }
  450. } else {
  451. b = append(b, s[k:]...)
  452. if norm.NFC.QuickSpan(b) != len(b) {
  453. b = norm.NFC.Bytes(b)
  454. }
  455. // TODO: the punycode converters require strings as input.
  456. s = string(b)
  457. }
  458. return s, bidi, err
  459. }
  460. // A labelIter allows iterating over domain name labels.
  461. type labelIter struct {
  462. orig string
  463. slice []string
  464. curStart int
  465. curEnd int
  466. i int
  467. }
  468. func (l *labelIter) reset() {
  469. l.curStart = 0
  470. l.curEnd = 0
  471. l.i = 0
  472. }
  473. func (l *labelIter) done() bool {
  474. return l.curStart >= len(l.orig)
  475. }
  476. func (l *labelIter) result() string {
  477. if l.slice != nil {
  478. return strings.Join(l.slice, ".")
  479. }
  480. return l.orig
  481. }
  482. func (l *labelIter) label() string {
  483. if l.slice != nil {
  484. return l.slice[l.i]
  485. }
  486. p := strings.IndexByte(l.orig[l.curStart:], '.')
  487. l.curEnd = l.curStart + p
  488. if p == -1 {
  489. l.curEnd = len(l.orig)
  490. }
  491. return l.orig[l.curStart:l.curEnd]
  492. }
  493. // next sets the value to the next label. It skips the last label if it is empty.
  494. func (l *labelIter) next() {
  495. l.i++
  496. if l.slice != nil {
  497. if l.i >= len(l.slice) || l.i == len(l.slice)-1 && l.slice[l.i] == "" {
  498. l.curStart = len(l.orig)
  499. }
  500. } else {
  501. l.curStart = l.curEnd + 1
  502. if l.curStart == len(l.orig)-1 && l.orig[l.curStart] == '.' {
  503. l.curStart = len(l.orig)
  504. }
  505. }
  506. }
  507. func (l *labelIter) set(s string) {
  508. if l.slice == nil {
  509. l.slice = strings.Split(l.orig, ".")
  510. }
  511. l.slice[l.i] = s
  512. }
  513. // acePrefix is the ASCII Compatible Encoding prefix.
  514. const acePrefix = "xn--"
  515. func (p *Profile) simplify(cat category) category {
  516. switch cat {
  517. case disallowedSTD3Mapped:
  518. if p.useSTD3Rules {
  519. cat = disallowed
  520. } else {
  521. cat = mapped
  522. }
  523. case disallowedSTD3Valid:
  524. if p.useSTD3Rules {
  525. cat = disallowed
  526. } else {
  527. cat = valid
  528. }
  529. case deviation:
  530. if !p.transitional {
  531. cat = valid
  532. }
  533. case validNV8, validXV8:
  534. // TODO: handle V2008
  535. cat = valid
  536. }
  537. return cat
  538. }
  539. func validateFromPunycode(p *Profile, s string) error {
  540. if !norm.NFC.IsNormalString(s) {
  541. return &labelError{s, "V1"}
  542. }
  543. // TODO: detect whether string may have to be normalized in the following
  544. // loop.
  545. for i := 0; i < len(s); {
  546. v, sz := trie.lookupString(s[i:])
  547. if sz == 0 {
  548. return runeError(utf8.RuneError)
  549. }
  550. if c := p.simplify(info(v).category()); c != valid && c != deviation {
  551. return &labelError{s, "V6"}
  552. }
  553. i += sz
  554. }
  555. return nil
  556. }
  557. const (
  558. zwnj = "\u200c"
  559. zwj = "\u200d"
  560. )
  561. type joinState int8
  562. const (
  563. stateStart joinState = iota
  564. stateVirama
  565. stateBefore
  566. stateBeforeVirama
  567. stateAfter
  568. stateFAIL
  569. )
  570. var joinStates = [][numJoinTypes]joinState{
  571. stateStart: {
  572. joiningL: stateBefore,
  573. joiningD: stateBefore,
  574. joinZWNJ: stateFAIL,
  575. joinZWJ: stateFAIL,
  576. joinVirama: stateVirama,
  577. },
  578. stateVirama: {
  579. joiningL: stateBefore,
  580. joiningD: stateBefore,
  581. },
  582. stateBefore: {
  583. joiningL: stateBefore,
  584. joiningD: stateBefore,
  585. joiningT: stateBefore,
  586. joinZWNJ: stateAfter,
  587. joinZWJ: stateFAIL,
  588. joinVirama: stateBeforeVirama,
  589. },
  590. stateBeforeVirama: {
  591. joiningL: stateBefore,
  592. joiningD: stateBefore,
  593. joiningT: stateBefore,
  594. },
  595. stateAfter: {
  596. joiningL: stateFAIL,
  597. joiningD: stateBefore,
  598. joiningT: stateAfter,
  599. joiningR: stateStart,
  600. joinZWNJ: stateFAIL,
  601. joinZWJ: stateFAIL,
  602. joinVirama: stateAfter, // no-op as we can't accept joiners here
  603. },
  604. stateFAIL: {
  605. 0: stateFAIL,
  606. joiningL: stateFAIL,
  607. joiningD: stateFAIL,
  608. joiningT: stateFAIL,
  609. joiningR: stateFAIL,
  610. joinZWNJ: stateFAIL,
  611. joinZWJ: stateFAIL,
  612. joinVirama: stateFAIL,
  613. },
  614. }
  615. // validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are
  616. // already implicitly satisfied by the overall implementation.
  617. func (p *Profile) validateLabel(s string) (err error) {
  618. if s == "" {
  619. if p.verifyDNSLength {
  620. return &labelError{s, "A4"}
  621. }
  622. return nil
  623. }
  624. if !p.validateLabels {
  625. return nil
  626. }
  627. trie := p.trie // p.validateLabels is only set if trie is set.
  628. if len(s) > 4 && s[2] == '-' && s[3] == '-' {
  629. return &labelError{s, "V2"}
  630. }
  631. if s[0] == '-' || s[len(s)-1] == '-' {
  632. return &labelError{s, "V3"}
  633. }
  634. // TODO: merge the use of this in the trie.
  635. v, sz := trie.lookupString(s)
  636. x := info(v)
  637. if x.isModifier() {
  638. return &labelError{s, "V5"}
  639. }
  640. // Quickly return in the absence of zero-width (non) joiners.
  641. if strings.Index(s, zwj) == -1 && strings.Index(s, zwnj) == -1 {
  642. return nil
  643. }
  644. st := stateStart
  645. for i := 0; ; {
  646. jt := x.joinType()
  647. if s[i:i+sz] == zwj {
  648. jt = joinZWJ
  649. } else if s[i:i+sz] == zwnj {
  650. jt = joinZWNJ
  651. }
  652. st = joinStates[st][jt]
  653. if x.isViramaModifier() {
  654. st = joinStates[st][joinVirama]
  655. }
  656. if i += sz; i == len(s) {
  657. break
  658. }
  659. v, sz = trie.lookupString(s[i:])
  660. x = info(v)
  661. }
  662. if st == stateFAIL || st == stateAfter {
  663. return &labelError{s, "C"}
  664. }
  665. return nil
  666. }
  667. func ascii(s string) bool {
  668. for i := 0; i < len(s); i++ {
  669. if s[i] >= utf8.RuneSelf {
  670. return false
  671. }
  672. }
  673. return true
  674. }
上海开阖软件有限公司 沪ICP备12045867号-1