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.

1670 lines
26 KiB

  1. package urn
  2. import (
  3. "fmt"
  4. )
  5. var (
  6. errPrefix = "expecting the prefix to be the \"urn\" string (whatever case) [col %d]"
  7. errIdentifier = "expecting the identifier to be string (1..31 alnum chars, also containing dashes but not at its start) [col %d]"
  8. errSpecificString = "expecting the specific string to be a string containing alnum, hex, or others ([()+,-.:=@;$_!*']) chars [col %d]"
  9. errNoUrnWithinID = "expecting the identifier to not contain the \"urn\" reserved string [col %d]"
  10. errHex = "expecting the specific string hex chars to be well-formed (%%alnum{2}) [col %d]"
  11. errParse = "parsing error [col %d]"
  12. )
  13. const start int = 1
  14. const first_final int = 44
  15. const en_fail int = 46
  16. const en_main int = 1
  17. // Machine is the interface representing the FSM
  18. type Machine interface {
  19. Error() error
  20. Parse(input []byte) (*URN, error)
  21. }
  22. type machine struct {
  23. data []byte
  24. cs int
  25. p, pe, eof, pb int
  26. err error
  27. tolower []int
  28. }
  29. // NewMachine creates a new FSM able to parse RFC 2141 strings.
  30. func NewMachine() Machine {
  31. m := &machine{}
  32. return m
  33. }
  34. // Err returns the error that occurred on the last call to Parse.
  35. //
  36. // If the result is nil, then the line was parsed successfully.
  37. func (m *machine) Error() error {
  38. return m.err
  39. }
  40. func (m *machine) text() []byte {
  41. return m.data[m.pb:m.p]
  42. }
  43. // Parse parses the input byte array as a RFC 2141 string.
  44. func (m *machine) Parse(input []byte) (*URN, error) {
  45. m.data = input
  46. m.p = 0
  47. m.pb = 0
  48. m.pe = len(input)
  49. m.eof = len(input)
  50. m.err = nil
  51. m.tolower = []int{}
  52. output := &URN{}
  53. {
  54. m.cs = start
  55. }
  56. {
  57. if (m.p) == (m.pe) {
  58. goto _test_eof
  59. }
  60. switch m.cs {
  61. case 1:
  62. goto st_case_1
  63. case 0:
  64. goto st_case_0
  65. case 2:
  66. goto st_case_2
  67. case 3:
  68. goto st_case_3
  69. case 4:
  70. goto st_case_4
  71. case 5:
  72. goto st_case_5
  73. case 6:
  74. goto st_case_6
  75. case 7:
  76. goto st_case_7
  77. case 8:
  78. goto st_case_8
  79. case 9:
  80. goto st_case_9
  81. case 10:
  82. goto st_case_10
  83. case 11:
  84. goto st_case_11
  85. case 12:
  86. goto st_case_12
  87. case 13:
  88. goto st_case_13
  89. case 14:
  90. goto st_case_14
  91. case 15:
  92. goto st_case_15
  93. case 16:
  94. goto st_case_16
  95. case 17:
  96. goto st_case_17
  97. case 18:
  98. goto st_case_18
  99. case 19:
  100. goto st_case_19
  101. case 20:
  102. goto st_case_20
  103. case 21:
  104. goto st_case_21
  105. case 22:
  106. goto st_case_22
  107. case 23:
  108. goto st_case_23
  109. case 24:
  110. goto st_case_24
  111. case 25:
  112. goto st_case_25
  113. case 26:
  114. goto st_case_26
  115. case 27:
  116. goto st_case_27
  117. case 28:
  118. goto st_case_28
  119. case 29:
  120. goto st_case_29
  121. case 30:
  122. goto st_case_30
  123. case 31:
  124. goto st_case_31
  125. case 32:
  126. goto st_case_32
  127. case 33:
  128. goto st_case_33
  129. case 34:
  130. goto st_case_34
  131. case 35:
  132. goto st_case_35
  133. case 36:
  134. goto st_case_36
  135. case 37:
  136. goto st_case_37
  137. case 38:
  138. goto st_case_38
  139. case 44:
  140. goto st_case_44
  141. case 39:
  142. goto st_case_39
  143. case 40:
  144. goto st_case_40
  145. case 45:
  146. goto st_case_45
  147. case 41:
  148. goto st_case_41
  149. case 42:
  150. goto st_case_42
  151. case 43:
  152. goto st_case_43
  153. case 46:
  154. goto st_case_46
  155. }
  156. goto st_out
  157. st_case_1:
  158. switch (m.data)[(m.p)] {
  159. case 85:
  160. goto tr1
  161. case 117:
  162. goto tr1
  163. }
  164. goto tr0
  165. tr0:
  166. m.err = fmt.Errorf(errParse, m.p)
  167. (m.p)--
  168. {
  169. goto st46
  170. }
  171. goto st0
  172. tr3:
  173. m.err = fmt.Errorf(errPrefix, m.p)
  174. (m.p)--
  175. {
  176. goto st46
  177. }
  178. m.err = fmt.Errorf(errParse, m.p)
  179. (m.p)--
  180. {
  181. goto st46
  182. }
  183. goto st0
  184. tr6:
  185. m.err = fmt.Errorf(errIdentifier, m.p)
  186. (m.p)--
  187. {
  188. goto st46
  189. }
  190. m.err = fmt.Errorf(errParse, m.p)
  191. (m.p)--
  192. {
  193. goto st46
  194. }
  195. goto st0
  196. tr41:
  197. m.err = fmt.Errorf(errSpecificString, m.p)
  198. (m.p)--
  199. {
  200. goto st46
  201. }
  202. m.err = fmt.Errorf(errParse, m.p)
  203. (m.p)--
  204. {
  205. goto st46
  206. }
  207. goto st0
  208. tr44:
  209. m.err = fmt.Errorf(errHex, m.p)
  210. (m.p)--
  211. {
  212. goto st46
  213. }
  214. m.err = fmt.Errorf(errSpecificString, m.p)
  215. (m.p)--
  216. {
  217. goto st46
  218. }
  219. m.err = fmt.Errorf(errParse, m.p)
  220. (m.p)--
  221. {
  222. goto st46
  223. }
  224. goto st0
  225. tr50:
  226. m.err = fmt.Errorf(errPrefix, m.p)
  227. (m.p)--
  228. {
  229. goto st46
  230. }
  231. m.err = fmt.Errorf(errIdentifier, m.p)
  232. (m.p)--
  233. {
  234. goto st46
  235. }
  236. m.err = fmt.Errorf(errParse, m.p)
  237. (m.p)--
  238. {
  239. goto st46
  240. }
  241. goto st0
  242. tr52:
  243. m.err = fmt.Errorf(errNoUrnWithinID, m.p)
  244. (m.p)--
  245. {
  246. goto st46
  247. }
  248. m.err = fmt.Errorf(errIdentifier, m.p)
  249. (m.p)--
  250. {
  251. goto st46
  252. }
  253. m.err = fmt.Errorf(errParse, m.p)
  254. (m.p)--
  255. {
  256. goto st46
  257. }
  258. goto st0
  259. st_case_0:
  260. st0:
  261. m.cs = 0
  262. goto _out
  263. tr1:
  264. m.pb = m.p
  265. goto st2
  266. st2:
  267. if (m.p)++; (m.p) == (m.pe) {
  268. goto _test_eof2
  269. }
  270. st_case_2:
  271. switch (m.data)[(m.p)] {
  272. case 82:
  273. goto st3
  274. case 114:
  275. goto st3
  276. }
  277. goto tr0
  278. st3:
  279. if (m.p)++; (m.p) == (m.pe) {
  280. goto _test_eof3
  281. }
  282. st_case_3:
  283. switch (m.data)[(m.p)] {
  284. case 78:
  285. goto st4
  286. case 110:
  287. goto st4
  288. }
  289. goto tr3
  290. st4:
  291. if (m.p)++; (m.p) == (m.pe) {
  292. goto _test_eof4
  293. }
  294. st_case_4:
  295. if (m.data)[(m.p)] == 58 {
  296. goto tr5
  297. }
  298. goto tr0
  299. tr5:
  300. output.prefix = string(m.text())
  301. goto st5
  302. st5:
  303. if (m.p)++; (m.p) == (m.pe) {
  304. goto _test_eof5
  305. }
  306. st_case_5:
  307. switch (m.data)[(m.p)] {
  308. case 85:
  309. goto tr8
  310. case 117:
  311. goto tr8
  312. }
  313. switch {
  314. case (m.data)[(m.p)] < 65:
  315. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  316. goto tr7
  317. }
  318. case (m.data)[(m.p)] > 90:
  319. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  320. goto tr7
  321. }
  322. default:
  323. goto tr7
  324. }
  325. goto tr6
  326. tr7:
  327. m.pb = m.p
  328. goto st6
  329. st6:
  330. if (m.p)++; (m.p) == (m.pe) {
  331. goto _test_eof6
  332. }
  333. st_case_6:
  334. switch (m.data)[(m.p)] {
  335. case 45:
  336. goto st7
  337. case 58:
  338. goto tr10
  339. }
  340. switch {
  341. case (m.data)[(m.p)] < 65:
  342. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  343. goto st7
  344. }
  345. case (m.data)[(m.p)] > 90:
  346. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  347. goto st7
  348. }
  349. default:
  350. goto st7
  351. }
  352. goto tr6
  353. st7:
  354. if (m.p)++; (m.p) == (m.pe) {
  355. goto _test_eof7
  356. }
  357. st_case_7:
  358. switch (m.data)[(m.p)] {
  359. case 45:
  360. goto st8
  361. case 58:
  362. goto tr10
  363. }
  364. switch {
  365. case (m.data)[(m.p)] < 65:
  366. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  367. goto st8
  368. }
  369. case (m.data)[(m.p)] > 90:
  370. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  371. goto st8
  372. }
  373. default:
  374. goto st8
  375. }
  376. goto tr6
  377. st8:
  378. if (m.p)++; (m.p) == (m.pe) {
  379. goto _test_eof8
  380. }
  381. st_case_8:
  382. switch (m.data)[(m.p)] {
  383. case 45:
  384. goto st9
  385. case 58:
  386. goto tr10
  387. }
  388. switch {
  389. case (m.data)[(m.p)] < 65:
  390. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  391. goto st9
  392. }
  393. case (m.data)[(m.p)] > 90:
  394. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  395. goto st9
  396. }
  397. default:
  398. goto st9
  399. }
  400. goto tr6
  401. st9:
  402. if (m.p)++; (m.p) == (m.pe) {
  403. goto _test_eof9
  404. }
  405. st_case_9:
  406. switch (m.data)[(m.p)] {
  407. case 45:
  408. goto st10
  409. case 58:
  410. goto tr10
  411. }
  412. switch {
  413. case (m.data)[(m.p)] < 65:
  414. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  415. goto st10
  416. }
  417. case (m.data)[(m.p)] > 90:
  418. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  419. goto st10
  420. }
  421. default:
  422. goto st10
  423. }
  424. goto tr6
  425. st10:
  426. if (m.p)++; (m.p) == (m.pe) {
  427. goto _test_eof10
  428. }
  429. st_case_10:
  430. switch (m.data)[(m.p)] {
  431. case 45:
  432. goto st11
  433. case 58:
  434. goto tr10
  435. }
  436. switch {
  437. case (m.data)[(m.p)] < 65:
  438. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  439. goto st11
  440. }
  441. case (m.data)[(m.p)] > 90:
  442. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  443. goto st11
  444. }
  445. default:
  446. goto st11
  447. }
  448. goto tr6
  449. st11:
  450. if (m.p)++; (m.p) == (m.pe) {
  451. goto _test_eof11
  452. }
  453. st_case_11:
  454. switch (m.data)[(m.p)] {
  455. case 45:
  456. goto st12
  457. case 58:
  458. goto tr10
  459. }
  460. switch {
  461. case (m.data)[(m.p)] < 65:
  462. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  463. goto st12
  464. }
  465. case (m.data)[(m.p)] > 90:
  466. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  467. goto st12
  468. }
  469. default:
  470. goto st12
  471. }
  472. goto tr6
  473. st12:
  474. if (m.p)++; (m.p) == (m.pe) {
  475. goto _test_eof12
  476. }
  477. st_case_12:
  478. switch (m.data)[(m.p)] {
  479. case 45:
  480. goto st13
  481. case 58:
  482. goto tr10
  483. }
  484. switch {
  485. case (m.data)[(m.p)] < 65:
  486. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  487. goto st13
  488. }
  489. case (m.data)[(m.p)] > 90:
  490. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  491. goto st13
  492. }
  493. default:
  494. goto st13
  495. }
  496. goto tr6
  497. st13:
  498. if (m.p)++; (m.p) == (m.pe) {
  499. goto _test_eof13
  500. }
  501. st_case_13:
  502. switch (m.data)[(m.p)] {
  503. case 45:
  504. goto st14
  505. case 58:
  506. goto tr10
  507. }
  508. switch {
  509. case (m.data)[(m.p)] < 65:
  510. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  511. goto st14
  512. }
  513. case (m.data)[(m.p)] > 90:
  514. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  515. goto st14
  516. }
  517. default:
  518. goto st14
  519. }
  520. goto tr6
  521. st14:
  522. if (m.p)++; (m.p) == (m.pe) {
  523. goto _test_eof14
  524. }
  525. st_case_14:
  526. switch (m.data)[(m.p)] {
  527. case 45:
  528. goto st15
  529. case 58:
  530. goto tr10
  531. }
  532. switch {
  533. case (m.data)[(m.p)] < 65:
  534. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  535. goto st15
  536. }
  537. case (m.data)[(m.p)] > 90:
  538. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  539. goto st15
  540. }
  541. default:
  542. goto st15
  543. }
  544. goto tr6
  545. st15:
  546. if (m.p)++; (m.p) == (m.pe) {
  547. goto _test_eof15
  548. }
  549. st_case_15:
  550. switch (m.data)[(m.p)] {
  551. case 45:
  552. goto st16
  553. case 58:
  554. goto tr10
  555. }
  556. switch {
  557. case (m.data)[(m.p)] < 65:
  558. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  559. goto st16
  560. }
  561. case (m.data)[(m.p)] > 90:
  562. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  563. goto st16
  564. }
  565. default:
  566. goto st16
  567. }
  568. goto tr6
  569. st16:
  570. if (m.p)++; (m.p) == (m.pe) {
  571. goto _test_eof16
  572. }
  573. st_case_16:
  574. switch (m.data)[(m.p)] {
  575. case 45:
  576. goto st17
  577. case 58:
  578. goto tr10
  579. }
  580. switch {
  581. case (m.data)[(m.p)] < 65:
  582. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  583. goto st17
  584. }
  585. case (m.data)[(m.p)] > 90:
  586. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  587. goto st17
  588. }
  589. default:
  590. goto st17
  591. }
  592. goto tr6
  593. st17:
  594. if (m.p)++; (m.p) == (m.pe) {
  595. goto _test_eof17
  596. }
  597. st_case_17:
  598. switch (m.data)[(m.p)] {
  599. case 45:
  600. goto st18
  601. case 58:
  602. goto tr10
  603. }
  604. switch {
  605. case (m.data)[(m.p)] < 65:
  606. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  607. goto st18
  608. }
  609. case (m.data)[(m.p)] > 90:
  610. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  611. goto st18
  612. }
  613. default:
  614. goto st18
  615. }
  616. goto tr6
  617. st18:
  618. if (m.p)++; (m.p) == (m.pe) {
  619. goto _test_eof18
  620. }
  621. st_case_18:
  622. switch (m.data)[(m.p)] {
  623. case 45:
  624. goto st19
  625. case 58:
  626. goto tr10
  627. }
  628. switch {
  629. case (m.data)[(m.p)] < 65:
  630. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  631. goto st19
  632. }
  633. case (m.data)[(m.p)] > 90:
  634. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  635. goto st19
  636. }
  637. default:
  638. goto st19
  639. }
  640. goto tr6
  641. st19:
  642. if (m.p)++; (m.p) == (m.pe) {
  643. goto _test_eof19
  644. }
  645. st_case_19:
  646. switch (m.data)[(m.p)] {
  647. case 45:
  648. goto st20
  649. case 58:
  650. goto tr10
  651. }
  652. switch {
  653. case (m.data)[(m.p)] < 65:
  654. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  655. goto st20
  656. }
  657. case (m.data)[(m.p)] > 90:
  658. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  659. goto st20
  660. }
  661. default:
  662. goto st20
  663. }
  664. goto tr6
  665. st20:
  666. if (m.p)++; (m.p) == (m.pe) {
  667. goto _test_eof20
  668. }
  669. st_case_20:
  670. switch (m.data)[(m.p)] {
  671. case 45:
  672. goto st21
  673. case 58:
  674. goto tr10
  675. }
  676. switch {
  677. case (m.data)[(m.p)] < 65:
  678. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  679. goto st21
  680. }
  681. case (m.data)[(m.p)] > 90:
  682. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  683. goto st21
  684. }
  685. default:
  686. goto st21
  687. }
  688. goto tr6
  689. st21:
  690. if (m.p)++; (m.p) == (m.pe) {
  691. goto _test_eof21
  692. }
  693. st_case_21:
  694. switch (m.data)[(m.p)] {
  695. case 45:
  696. goto st22
  697. case 58:
  698. goto tr10
  699. }
  700. switch {
  701. case (m.data)[(m.p)] < 65:
  702. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  703. goto st22
  704. }
  705. case (m.data)[(m.p)] > 90:
  706. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  707. goto st22
  708. }
  709. default:
  710. goto st22
  711. }
  712. goto tr6
  713. st22:
  714. if (m.p)++; (m.p) == (m.pe) {
  715. goto _test_eof22
  716. }
  717. st_case_22:
  718. switch (m.data)[(m.p)] {
  719. case 45:
  720. goto st23
  721. case 58:
  722. goto tr10
  723. }
  724. switch {
  725. case (m.data)[(m.p)] < 65:
  726. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  727. goto st23
  728. }
  729. case (m.data)[(m.p)] > 90:
  730. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  731. goto st23
  732. }
  733. default:
  734. goto st23
  735. }
  736. goto tr6
  737. st23:
  738. if (m.p)++; (m.p) == (m.pe) {
  739. goto _test_eof23
  740. }
  741. st_case_23:
  742. switch (m.data)[(m.p)] {
  743. case 45:
  744. goto st24
  745. case 58:
  746. goto tr10
  747. }
  748. switch {
  749. case (m.data)[(m.p)] < 65:
  750. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  751. goto st24
  752. }
  753. case (m.data)[(m.p)] > 90:
  754. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  755. goto st24
  756. }
  757. default:
  758. goto st24
  759. }
  760. goto tr6
  761. st24:
  762. if (m.p)++; (m.p) == (m.pe) {
  763. goto _test_eof24
  764. }
  765. st_case_24:
  766. switch (m.data)[(m.p)] {
  767. case 45:
  768. goto st25
  769. case 58:
  770. goto tr10
  771. }
  772. switch {
  773. case (m.data)[(m.p)] < 65:
  774. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  775. goto st25
  776. }
  777. case (m.data)[(m.p)] > 90:
  778. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  779. goto st25
  780. }
  781. default:
  782. goto st25
  783. }
  784. goto tr6
  785. st25:
  786. if (m.p)++; (m.p) == (m.pe) {
  787. goto _test_eof25
  788. }
  789. st_case_25:
  790. switch (m.data)[(m.p)] {
  791. case 45:
  792. goto st26
  793. case 58:
  794. goto tr10
  795. }
  796. switch {
  797. case (m.data)[(m.p)] < 65:
  798. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  799. goto st26
  800. }
  801. case (m.data)[(m.p)] > 90:
  802. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  803. goto st26
  804. }
  805. default:
  806. goto st26
  807. }
  808. goto tr6
  809. st26:
  810. if (m.p)++; (m.p) == (m.pe) {
  811. goto _test_eof26
  812. }
  813. st_case_26:
  814. switch (m.data)[(m.p)] {
  815. case 45:
  816. goto st27
  817. case 58:
  818. goto tr10
  819. }
  820. switch {
  821. case (m.data)[(m.p)] < 65:
  822. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  823. goto st27
  824. }
  825. case (m.data)[(m.p)] > 90:
  826. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  827. goto st27
  828. }
  829. default:
  830. goto st27
  831. }
  832. goto tr6
  833. st27:
  834. if (m.p)++; (m.p) == (m.pe) {
  835. goto _test_eof27
  836. }
  837. st_case_27:
  838. switch (m.data)[(m.p)] {
  839. case 45:
  840. goto st28
  841. case 58:
  842. goto tr10
  843. }
  844. switch {
  845. case (m.data)[(m.p)] < 65:
  846. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  847. goto st28
  848. }
  849. case (m.data)[(m.p)] > 90:
  850. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  851. goto st28
  852. }
  853. default:
  854. goto st28
  855. }
  856. goto tr6
  857. st28:
  858. if (m.p)++; (m.p) == (m.pe) {
  859. goto _test_eof28
  860. }
  861. st_case_28:
  862. switch (m.data)[(m.p)] {
  863. case 45:
  864. goto st29
  865. case 58:
  866. goto tr10
  867. }
  868. switch {
  869. case (m.data)[(m.p)] < 65:
  870. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  871. goto st29
  872. }
  873. case (m.data)[(m.p)] > 90:
  874. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  875. goto st29
  876. }
  877. default:
  878. goto st29
  879. }
  880. goto tr6
  881. st29:
  882. if (m.p)++; (m.p) == (m.pe) {
  883. goto _test_eof29
  884. }
  885. st_case_29:
  886. switch (m.data)[(m.p)] {
  887. case 45:
  888. goto st30
  889. case 58:
  890. goto tr10
  891. }
  892. switch {
  893. case (m.data)[(m.p)] < 65:
  894. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  895. goto st30
  896. }
  897. case (m.data)[(m.p)] > 90:
  898. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  899. goto st30
  900. }
  901. default:
  902. goto st30
  903. }
  904. goto tr6
  905. st30:
  906. if (m.p)++; (m.p) == (m.pe) {
  907. goto _test_eof30
  908. }
  909. st_case_30:
  910. switch (m.data)[(m.p)] {
  911. case 45:
  912. goto st31
  913. case 58:
  914. goto tr10
  915. }
  916. switch {
  917. case (m.data)[(m.p)] < 65:
  918. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  919. goto st31
  920. }
  921. case (m.data)[(m.p)] > 90:
  922. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  923. goto st31
  924. }
  925. default:
  926. goto st31
  927. }
  928. goto tr6
  929. st31:
  930. if (m.p)++; (m.p) == (m.pe) {
  931. goto _test_eof31
  932. }
  933. st_case_31:
  934. switch (m.data)[(m.p)] {
  935. case 45:
  936. goto st32
  937. case 58:
  938. goto tr10
  939. }
  940. switch {
  941. case (m.data)[(m.p)] < 65:
  942. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  943. goto st32
  944. }
  945. case (m.data)[(m.p)] > 90:
  946. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  947. goto st32
  948. }
  949. default:
  950. goto st32
  951. }
  952. goto tr6
  953. st32:
  954. if (m.p)++; (m.p) == (m.pe) {
  955. goto _test_eof32
  956. }
  957. st_case_32:
  958. switch (m.data)[(m.p)] {
  959. case 45:
  960. goto st33
  961. case 58:
  962. goto tr10
  963. }
  964. switch {
  965. case (m.data)[(m.p)] < 65:
  966. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  967. goto st33
  968. }
  969. case (m.data)[(m.p)] > 90:
  970. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  971. goto st33
  972. }
  973. default:
  974. goto st33
  975. }
  976. goto tr6
  977. st33:
  978. if (m.p)++; (m.p) == (m.pe) {
  979. goto _test_eof33
  980. }
  981. st_case_33:
  982. switch (m.data)[(m.p)] {
  983. case 45:
  984. goto st34
  985. case 58:
  986. goto tr10
  987. }
  988. switch {
  989. case (m.data)[(m.p)] < 65:
  990. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  991. goto st34
  992. }
  993. case (m.data)[(m.p)] > 90:
  994. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  995. goto st34
  996. }
  997. default:
  998. goto st34
  999. }
  1000. goto tr6
  1001. st34:
  1002. if (m.p)++; (m.p) == (m.pe) {
  1003. goto _test_eof34
  1004. }
  1005. st_case_34:
  1006. switch (m.data)[(m.p)] {
  1007. case 45:
  1008. goto st35
  1009. case 58:
  1010. goto tr10
  1011. }
  1012. switch {
  1013. case (m.data)[(m.p)] < 65:
  1014. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1015. goto st35
  1016. }
  1017. case (m.data)[(m.p)] > 90:
  1018. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1019. goto st35
  1020. }
  1021. default:
  1022. goto st35
  1023. }
  1024. goto tr6
  1025. st35:
  1026. if (m.p)++; (m.p) == (m.pe) {
  1027. goto _test_eof35
  1028. }
  1029. st_case_35:
  1030. switch (m.data)[(m.p)] {
  1031. case 45:
  1032. goto st36
  1033. case 58:
  1034. goto tr10
  1035. }
  1036. switch {
  1037. case (m.data)[(m.p)] < 65:
  1038. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1039. goto st36
  1040. }
  1041. case (m.data)[(m.p)] > 90:
  1042. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1043. goto st36
  1044. }
  1045. default:
  1046. goto st36
  1047. }
  1048. goto tr6
  1049. st36:
  1050. if (m.p)++; (m.p) == (m.pe) {
  1051. goto _test_eof36
  1052. }
  1053. st_case_36:
  1054. switch (m.data)[(m.p)] {
  1055. case 45:
  1056. goto st37
  1057. case 58:
  1058. goto tr10
  1059. }
  1060. switch {
  1061. case (m.data)[(m.p)] < 65:
  1062. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1063. goto st37
  1064. }
  1065. case (m.data)[(m.p)] > 90:
  1066. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1067. goto st37
  1068. }
  1069. default:
  1070. goto st37
  1071. }
  1072. goto tr6
  1073. st37:
  1074. if (m.p)++; (m.p) == (m.pe) {
  1075. goto _test_eof37
  1076. }
  1077. st_case_37:
  1078. if (m.data)[(m.p)] == 58 {
  1079. goto tr10
  1080. }
  1081. goto tr6
  1082. tr10:
  1083. output.ID = string(m.text())
  1084. goto st38
  1085. st38:
  1086. if (m.p)++; (m.p) == (m.pe) {
  1087. goto _test_eof38
  1088. }
  1089. st_case_38:
  1090. switch (m.data)[(m.p)] {
  1091. case 33:
  1092. goto tr42
  1093. case 36:
  1094. goto tr42
  1095. case 37:
  1096. goto tr43
  1097. case 61:
  1098. goto tr42
  1099. case 95:
  1100. goto tr42
  1101. }
  1102. switch {
  1103. case (m.data)[(m.p)] < 48:
  1104. if 39 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 46 {
  1105. goto tr42
  1106. }
  1107. case (m.data)[(m.p)] > 59:
  1108. switch {
  1109. case (m.data)[(m.p)] > 90:
  1110. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1111. goto tr42
  1112. }
  1113. case (m.data)[(m.p)] >= 64:
  1114. goto tr42
  1115. }
  1116. default:
  1117. goto tr42
  1118. }
  1119. goto tr41
  1120. tr42:
  1121. m.pb = m.p
  1122. goto st44
  1123. st44:
  1124. if (m.p)++; (m.p) == (m.pe) {
  1125. goto _test_eof44
  1126. }
  1127. st_case_44:
  1128. switch (m.data)[(m.p)] {
  1129. case 33:
  1130. goto st44
  1131. case 36:
  1132. goto st44
  1133. case 37:
  1134. goto st39
  1135. case 61:
  1136. goto st44
  1137. case 95:
  1138. goto st44
  1139. }
  1140. switch {
  1141. case (m.data)[(m.p)] < 48:
  1142. if 39 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 46 {
  1143. goto st44
  1144. }
  1145. case (m.data)[(m.p)] > 59:
  1146. switch {
  1147. case (m.data)[(m.p)] > 90:
  1148. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1149. goto st44
  1150. }
  1151. case (m.data)[(m.p)] >= 64:
  1152. goto st44
  1153. }
  1154. default:
  1155. goto st44
  1156. }
  1157. goto tr41
  1158. tr43:
  1159. m.pb = m.p
  1160. goto st39
  1161. st39:
  1162. if (m.p)++; (m.p) == (m.pe) {
  1163. goto _test_eof39
  1164. }
  1165. st_case_39:
  1166. switch {
  1167. case (m.data)[(m.p)] < 65:
  1168. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1169. goto st40
  1170. }
  1171. case (m.data)[(m.p)] > 90:
  1172. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1173. goto st40
  1174. }
  1175. default:
  1176. goto tr46
  1177. }
  1178. goto tr44
  1179. tr46:
  1180. m.tolower = append(m.tolower, m.p-m.pb)
  1181. goto st40
  1182. st40:
  1183. if (m.p)++; (m.p) == (m.pe) {
  1184. goto _test_eof40
  1185. }
  1186. st_case_40:
  1187. switch {
  1188. case (m.data)[(m.p)] < 65:
  1189. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1190. goto st45
  1191. }
  1192. case (m.data)[(m.p)] > 90:
  1193. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1194. goto st45
  1195. }
  1196. default:
  1197. goto tr48
  1198. }
  1199. goto tr44
  1200. tr48:
  1201. m.tolower = append(m.tolower, m.p-m.pb)
  1202. goto st45
  1203. st45:
  1204. if (m.p)++; (m.p) == (m.pe) {
  1205. goto _test_eof45
  1206. }
  1207. st_case_45:
  1208. switch (m.data)[(m.p)] {
  1209. case 33:
  1210. goto st44
  1211. case 36:
  1212. goto st44
  1213. case 37:
  1214. goto st39
  1215. case 61:
  1216. goto st44
  1217. case 95:
  1218. goto st44
  1219. }
  1220. switch {
  1221. case (m.data)[(m.p)] < 48:
  1222. if 39 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 46 {
  1223. goto st44
  1224. }
  1225. case (m.data)[(m.p)] > 59:
  1226. switch {
  1227. case (m.data)[(m.p)] > 90:
  1228. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1229. goto st44
  1230. }
  1231. case (m.data)[(m.p)] >= 64:
  1232. goto st44
  1233. }
  1234. default:
  1235. goto st44
  1236. }
  1237. goto tr44
  1238. tr8:
  1239. m.pb = m.p
  1240. goto st41
  1241. st41:
  1242. if (m.p)++; (m.p) == (m.pe) {
  1243. goto _test_eof41
  1244. }
  1245. st_case_41:
  1246. switch (m.data)[(m.p)] {
  1247. case 45:
  1248. goto st7
  1249. case 58:
  1250. goto tr10
  1251. case 82:
  1252. goto st42
  1253. case 114:
  1254. goto st42
  1255. }
  1256. switch {
  1257. case (m.data)[(m.p)] < 65:
  1258. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1259. goto st7
  1260. }
  1261. case (m.data)[(m.p)] > 90:
  1262. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1263. goto st7
  1264. }
  1265. default:
  1266. goto st7
  1267. }
  1268. goto tr6
  1269. st42:
  1270. if (m.p)++; (m.p) == (m.pe) {
  1271. goto _test_eof42
  1272. }
  1273. st_case_42:
  1274. switch (m.data)[(m.p)] {
  1275. case 45:
  1276. goto st8
  1277. case 58:
  1278. goto tr10
  1279. case 78:
  1280. goto st43
  1281. case 110:
  1282. goto st43
  1283. }
  1284. switch {
  1285. case (m.data)[(m.p)] < 65:
  1286. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1287. goto st8
  1288. }
  1289. case (m.data)[(m.p)] > 90:
  1290. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1291. goto st8
  1292. }
  1293. default:
  1294. goto st8
  1295. }
  1296. goto tr50
  1297. st43:
  1298. if (m.p)++; (m.p) == (m.pe) {
  1299. goto _test_eof43
  1300. }
  1301. st_case_43:
  1302. if (m.data)[(m.p)] == 45 {
  1303. goto st9
  1304. }
  1305. switch {
  1306. case (m.data)[(m.p)] < 65:
  1307. if 48 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 57 {
  1308. goto st9
  1309. }
  1310. case (m.data)[(m.p)] > 90:
  1311. if 97 <= (m.data)[(m.p)] && (m.data)[(m.p)] <= 122 {
  1312. goto st9
  1313. }
  1314. default:
  1315. goto st9
  1316. }
  1317. goto tr52
  1318. st46:
  1319. if (m.p)++; (m.p) == (m.pe) {
  1320. goto _test_eof46
  1321. }
  1322. st_case_46:
  1323. switch (m.data)[(m.p)] {
  1324. case 10:
  1325. goto st0
  1326. case 13:
  1327. goto st0
  1328. }
  1329. goto st46
  1330. st_out:
  1331. _test_eof2:
  1332. m.cs = 2
  1333. goto _test_eof
  1334. _test_eof3:
  1335. m.cs = 3
  1336. goto _test_eof
  1337. _test_eof4:
  1338. m.cs = 4
  1339. goto _test_eof
  1340. _test_eof5:
  1341. m.cs = 5
  1342. goto _test_eof
  1343. _test_eof6:
  1344. m.cs = 6
  1345. goto _test_eof
  1346. _test_eof7:
  1347. m.cs = 7
  1348. goto _test_eof
  1349. _test_eof8:
  1350. m.cs = 8
  1351. goto _test_eof
  1352. _test_eof9:
  1353. m.cs = 9
  1354. goto _test_eof
  1355. _test_eof10:
  1356. m.cs = 10
  1357. goto _test_eof
  1358. _test_eof11:
  1359. m.cs = 11
  1360. goto _test_eof
  1361. _test_eof12:
  1362. m.cs = 12
  1363. goto _test_eof
  1364. _test_eof13:
  1365. m.cs = 13
  1366. goto _test_eof
  1367. _test_eof14:
  1368. m.cs = 14
  1369. goto _test_eof
  1370. _test_eof15:
  1371. m.cs = 15
  1372. goto _test_eof
  1373. _test_eof16:
  1374. m.cs = 16
  1375. goto _test_eof
  1376. _test_eof17:
  1377. m.cs = 17
  1378. goto _test_eof
  1379. _test_eof18:
  1380. m.cs = 18
  1381. goto _test_eof
  1382. _test_eof19:
  1383. m.cs = 19
  1384. goto _test_eof
  1385. _test_eof20:
  1386. m.cs = 20
  1387. goto _test_eof
  1388. _test_eof21:
  1389. m.cs = 21
  1390. goto _test_eof
  1391. _test_eof22:
  1392. m.cs = 22
  1393. goto _test_eof
  1394. _test_eof23:
  1395. m.cs = 23
  1396. goto _test_eof
  1397. _test_eof24:
  1398. m.cs = 24
  1399. goto _test_eof
  1400. _test_eof25:
  1401. m.cs = 25
  1402. goto _test_eof
  1403. _test_eof26:
  1404. m.cs = 26
  1405. goto _test_eof
  1406. _test_eof27:
  1407. m.cs = 27
  1408. goto _test_eof
  1409. _test_eof28:
  1410. m.cs = 28
  1411. goto _test_eof
  1412. _test_eof29:
  1413. m.cs = 29
  1414. goto _test_eof
  1415. _test_eof30:
  1416. m.cs = 30
  1417. goto _test_eof
  1418. _test_eof31:
  1419. m.cs = 31
  1420. goto _test_eof
  1421. _test_eof32:
  1422. m.cs = 32
  1423. goto _test_eof
  1424. _test_eof33:
  1425. m.cs = 33
  1426. goto _test_eof
  1427. _test_eof34:
  1428. m.cs = 34
  1429. goto _test_eof
  1430. _test_eof35:
  1431. m.cs = 35
  1432. goto _test_eof
  1433. _test_eof36:
  1434. m.cs = 36
  1435. goto _test_eof
  1436. _test_eof37:
  1437. m.cs = 37
  1438. goto _test_eof
  1439. _test_eof38:
  1440. m.cs = 38
  1441. goto _test_eof
  1442. _test_eof44:
  1443. m.cs = 44
  1444. goto _test_eof
  1445. _test_eof39:
  1446. m.cs = 39
  1447. goto _test_eof
  1448. _test_eof40:
  1449. m.cs = 40
  1450. goto _test_eof
  1451. _test_eof45:
  1452. m.cs = 45
  1453. goto _test_eof
  1454. _test_eof41:
  1455. m.cs = 41
  1456. goto _test_eof
  1457. _test_eof42:
  1458. m.cs = 42
  1459. goto _test_eof
  1460. _test_eof43:
  1461. m.cs = 43
  1462. goto _test_eof
  1463. _test_eof46:
  1464. m.cs = 46
  1465. goto _test_eof
  1466. _test_eof:
  1467. {
  1468. }
  1469. if (m.p) == (m.eof) {
  1470. switch m.cs {
  1471. case 44, 45:
  1472. raw := m.text()
  1473. output.SS = string(raw)
  1474. // Iterate upper letters lowering them
  1475. for _, i := range m.tolower {
  1476. raw[i] = raw[i] + 32
  1477. }
  1478. output.norm = string(raw)
  1479. case 1, 2, 4:
  1480. m.err = fmt.Errorf(errParse, m.p)
  1481. (m.p)--
  1482. {
  1483. goto st46
  1484. }
  1485. case 3:
  1486. m.err = fmt.Errorf(errPrefix, m.p)
  1487. (m.p)--
  1488. {
  1489. goto st46
  1490. }
  1491. m.err = fmt.Errorf(errParse, m.p)
  1492. (m.p)--
  1493. {
  1494. goto st46
  1495. }
  1496. case 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 41:
  1497. m.err = fmt.Errorf(errIdentifier, m.p)
  1498. (m.p)--
  1499. {
  1500. goto st46
  1501. }
  1502. m.err = fmt.Errorf(errParse, m.p)
  1503. (m.p)--
  1504. {
  1505. goto st46
  1506. }
  1507. case 38:
  1508. m.err = fmt.Errorf(errSpecificString, m.p)
  1509. (m.p)--
  1510. {
  1511. goto st46
  1512. }
  1513. m.err = fmt.Errorf(errParse, m.p)
  1514. (m.p)--
  1515. {
  1516. goto st46
  1517. }
  1518. case 42:
  1519. m.err = fmt.Errorf(errPrefix, m.p)
  1520. (m.p)--
  1521. {
  1522. goto st46
  1523. }
  1524. m.err = fmt.Errorf(errIdentifier, m.p)
  1525. (m.p)--
  1526. {
  1527. goto st46
  1528. }
  1529. m.err = fmt.Errorf(errParse, m.p)
  1530. (m.p)--
  1531. {
  1532. goto st46
  1533. }
  1534. case 43:
  1535. m.err = fmt.Errorf(errNoUrnWithinID, m.p)
  1536. (m.p)--
  1537. {
  1538. goto st46
  1539. }
  1540. m.err = fmt.Errorf(errIdentifier, m.p)
  1541. (m.p)--
  1542. {
  1543. goto st46
  1544. }
  1545. m.err = fmt.Errorf(errParse, m.p)
  1546. (m.p)--
  1547. {
  1548. goto st46
  1549. }
  1550. case 39, 40:
  1551. m.err = fmt.Errorf(errHex, m.p)
  1552. (m.p)--
  1553. {
  1554. goto st46
  1555. }
  1556. m.err = fmt.Errorf(errSpecificString, m.p)
  1557. (m.p)--
  1558. {
  1559. goto st46
  1560. }
  1561. m.err = fmt.Errorf(errParse, m.p)
  1562. (m.p)--
  1563. {
  1564. goto st46
  1565. }
  1566. }
  1567. }
  1568. _out:
  1569. {
  1570. }
  1571. }
  1572. if m.cs < first_final || m.cs == en_fail {
  1573. return nil, m.err
  1574. }
  1575. return output, nil
  1576. }