Cface__CDefinitionScanner.st
changeset 3 110a9cbf8594
parent 1 b6c0180314d1
child 4 fc74bd43a3eb
equal deleted inserted replaced
2:cfd2c393abfe 3:110a9cbf8594
    29 <whitespace>    :       \s+     ;
    29 <whitespace>    :       \s+     ;
    30 
    30 
    31 <file>                  :       [\w-_/] [\w-_/.]* ;
    31 <file>                  :       [\w-_/] [\w-_/.]* ;
    32 "
    32 "
    33 
    33 
    34     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
    34     "Modified: / 04-07-2008 / 09:23:46 / Jan Vrany <vranyj1@fel.cvut.cz>"
    35 ! !
    35 ! !
    36 
    36 
    37 !CDefinitionScanner class methodsFor:'generated-initialization'!
    37 !CDefinitionScanner class methodsFor:'generated-initialization'!
    38 
    38 
    39 initializeKeywordMap
    39 initializeKeywordMap
    40     keywordMap := Dictionary new.
    40     keywordMap := Dictionary new.
    41     #( #(27 'argument' 5)
    41     #( #(30 'argument' 14)
    42      #(27 'array' 26)
    42      #(30 'array' 25)
    43      #(27 'char' 14)
    43      #(30 'char' 5)
    44      #(27 'const' 25)
    44      #(30 'const' 26)
    45      #(27 'double' 20)
    45      #(30 'double' 12)
    46      #(27 'enum' 17)
       
    47      #(27 'field' 16)
       
    48      #(27 'float' 22)
       
    49      #(27 'function' 11)
       
    50      #(27 'int' 13)
       
    51      #(27 'long' 3)
       
    52      #(27 'return' 6)
       
    53      #(27 'short' 4)
       
    54      #(27 'struct' 21)
       
    55      #(27 'typedef' 7)
       
    56      #(27 'union' 15)
       
    57      #(27 'unsigned' 2)
       
    58      #(27 'value' 18)
       
    59      #(27 'void' 24)
       
    60      #(30 'argument' 5)
       
    61      #(30 'array' 26)
       
    62      #(30 'char' 14)
       
    63      #(30 'const' 25)
       
    64      #(30 'double' 20)
       
    65      #(30 'enum' 17)
    46      #(30 'enum' 17)
    66      #(30 'field' 16)
    47      #(30 'field' 16)
    67      #(30 'float' 22)
    48      #(30 'float' 23)
    68      #(30 'function' 11)
    49      #(30 'function' 15)
    69      #(30 'int' 13)
    50      #(30 'int' 7)
    70      #(30 'long' 3)
    51      #(30 'long' 2)
    71      #(30 'return' 6)
    52      #(30 'return' 6)
    72      #(30 'short' 4)
    53      #(30 'short' 3)
    73      #(30 'struct' 21)
    54      #(30 'struct' 28)
    74      #(30 'typedef' 7)
    55      #(30 'typedef' 20)
    75      #(30 'union' 15)
    56      #(30 'union' 21)
    76      #(30 'unsigned' 2)
    57      #(30 'unsigned' 1)
    77      #(30 'value' 18)
    58      #(30 'value' 22)
    78      #(30 'void' 24) ) 
    59      #(30 'void' 24)
       
    60      #(33 'argument' 14)
       
    61      #(33 'array' 25)
       
    62      #(33 'char' 5)
       
    63      #(33 'const' 26)
       
    64      #(33 'double' 12)
       
    65      #(33 'enum' 17)
       
    66      #(33 'field' 16)
       
    67      #(33 'float' 23)
       
    68      #(33 'function' 15)
       
    69      #(33 'int' 7)
       
    70      #(33 'long' 2)
       
    71      #(33 'return' 6)
       
    72      #(33 'short' 3)
       
    73      #(33 'struct' 28)
       
    74      #(33 'typedef' 20)
       
    75      #(33 'union' 21)
       
    76      #(33 'unsigned' 1)
       
    77      #(33 'value' 22)
       
    78      #(33 'void' 24) ) 
    79             do:[:each | 
    79             do:[:each | 
    80                 (keywordMap at:each first ifAbsentPut:[ Dictionary new ]) at:(each at:2)
    80                 (keywordMap at:each first ifAbsentPut:[ Dictionary new ]) at:(each at:2)
    81                     put:each last
    81                     put:each last
    82             ].
    82             ].
    83     ^ keywordMap
    83     ^ keywordMap
    84 
    84 
    85     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
    85     "Modified: / 04-07-2008 / 09:23:44 / Jan Vrany <vranyj1@fel.cvut.cz>"
    86 ! !
    86 ! !
    87 
    87 
    88 !CDefinitionScanner methodsFor:'generated-scanner'!
    88 !CDefinitionScanner methodsFor:'generated-scanner'!
    89 
    89 
    90 scan1
    90 scan1
    91     [
    91     [
    92         self recordMatch:#( 27 30 ).
    92         self recordMatch:#( 30 33 ).
    93         self step.
    93         self step.
    94         (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ])
    94         (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ])
    95     ] whileTrue.
    95     ] whileTrue.
    96     (currentCharacter between:$- and:$/) ifTrue:[
    96     (currentCharacter between:$- and:$/) ifTrue:[
    97         [
    97         [
    98             self recordMatch:#( 30 ).
    98             self recordMatch:#( 33 ).
    99             self step.
    99             self step.
   100             (currentCharacter isLetterOrDigit 
   100             (currentCharacter isLetterOrDigit 
   101                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   101                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   102         ] whileTrue.
   102         ] whileTrue.
   103         ^ self reportLastMatch
   103         ^ self reportLastMatch
   104     ].
   104     ].
   105     ^ self reportLastMatch
   105     ^ self reportLastMatch
   106 
   106 
   107     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
   107     "Modified: / 04-07-2008 / 09:23:45 / Jan Vrany <vranyj1@fel.cvut.cz>"
   108 !
   108 !
   109 
   109 
   110 scan2
   110 scan2
   111     [
   111     [
   112         self recordMatch:#( 28 30 ).
   112         self recordMatch:#( 31 33 ).
   113         self step.
   113         self step.
   114         (currentCharacter isLetter) ifTrue:[
   114         (currentCharacter isLetter) ifTrue:[
   115             [
   115             [
   116                 self recordMatch:#( 28 30 ).
   116                 self recordMatch:#( 31 33 ).
   117                 self step.
   117                 self step.
   118                 (currentCharacter isLetter)
   118                 (currentCharacter isLetter)
   119             ] whileTrue.
   119             ] whileTrue.
   120             (currentCharacter isXMLDigit 
   120             (currentCharacter isXMLDigit 
   121                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
   121                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
   122                     ifTrue:[
   122                     ifTrue:[
   123                         [
   123                         [
   124                             self recordMatch:#( 30 ).
   124                             self recordMatch:#( 33 ).
   125                             self step.
   125                             self step.
   126                             (currentCharacter isLetterOrDigit 
   126                             (currentCharacter isLetterOrDigit 
   127                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   127                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   128                         ] whileTrue.
   128                         ] whileTrue.
   129                         ^ self reportLastMatch
   129                         ^ self reportLastMatch
   132         ].
   132         ].
   133         (currentCharacter isXMLDigit)
   133         (currentCharacter isXMLDigit)
   134     ] whileTrue.
   134     ] whileTrue.
   135     ((currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ]) ifTrue:[
   135     ((currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ]) ifTrue:[
   136         [
   136         [
   137             self recordMatch:#( 30 ).
   137             self recordMatch:#( 33 ).
   138             self step.
   138             self step.
   139             (currentCharacter isLetterOrDigit 
   139             (currentCharacter isLetterOrDigit 
   140                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   140                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   141         ] whileTrue.
   141         ] whileTrue.
   142         ^ self reportLastMatch
   142         ^ self reportLastMatch
   143     ].
   143     ].
   144     ^ self reportLastMatch
   144     ^ self reportLastMatch
   145 
   145 
   146     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
   146     "Modified: / 04-07-2008 / 09:23:45 / Jan Vrany <vranyj1@fel.cvut.cz>"
   147 !
   147 !
   148 
   148 
   149 scan3
   149 scan3
   150     [
   150     [
   151         self recordMatch:#( 30 32 ).
   151         self recordMatch:#( 30 32 ).
   842     self step.
   842     self step.
   843     ((currentCharacter between:$A and:$Z) 
   843     ((currentCharacter between:$A and:$Z) 
   844         or:[
   844         or:[
   845             currentCharacter == $_ 
   845             currentCharacter == $_ 
   846                 or:[
   846                 or:[
   847                     (currentCharacter between:$a and:$e) 
   847                     (currentCharacter between:$a and:$d) 
   848                         or:[
   848                         or:[
   849                             (currentCharacter between:$g and:$o) 
   849                             (currentCharacter between:$g and:$o) 
   850                                 or:[ (currentCharacter between:$q and:$z) ]
   850                                 or:[
       
   851                                     (currentCharacter between:$q and:$r) 
       
   852                                         or:[ (currentCharacter between:$v and:$z) ]
       
   853                                 ]
   851                         ]
   854                         ]
   852                 ]
   855                 ]
   853         ]) 
   856         ]) 
   854             ifTrue:[ ^ self scan1 ].
   857             ifTrue:[ ^ self scan1 ].
   855     (currentCharacter isXMLDigit) ifTrue:[
   858     (currentCharacter isXMLDigit) ifTrue:[
   883                                 (currentCharacter == $t) ifTrue:[
   886                                 (currentCharacter == $t) ifTrue:[
   884                                     self step.
   887                                     self step.
   885                                     (currentCharacter == $e) ifTrue:[
   888                                     (currentCharacter == $e) ifTrue:[
   886                                         self step.
   889                                         self step.
   887                                         (currentCharacter == $d) ifTrue:[
   890                                         (currentCharacter == $d) ifTrue:[
   888                                             ^ self recordAndReportMatch:#( 8 ).
   891                                             ^ self recordAndReportMatch:#( 9 ).
   889                                         ].
   892                                         ].
   890                                         ^ self reportLastMatch
   893                                         ^ self reportLastMatch
   891                                     ].
   894                                     ].
   892                                     ^ self reportLastMatch
   895                                     ^ self reportLastMatch
   893                                 ].
   896                                 ].
   904             ^ self reportLastMatch
   907             ^ self reportLastMatch
   905         ].
   908         ].
   906         ^ self reportLastMatch
   909         ^ self reportLastMatch
   907     ].
   910     ].
   908     (currentCharacter == $() ifTrue:[
   911     (currentCharacter == $() ifTrue:[
   909         ^ self recordAndReportMatch:#( 10 ).
   912         ^ self recordAndReportMatch:#( 11 ).
   910     ].
   913     ].
   911     (currentCharacter == $)) ifTrue:[
   914     (currentCharacter == $)) ifTrue:[
   912         ^ self recordAndReportMatch:#( 12 ).
   915         ^ self recordAndReportMatch:#( 13 ).
   913     ].
   916     ].
   914     (currentCharacter == $-) ifTrue:[
   917     (currentCharacter == $-) ifTrue:[
   915         self recordMatch:#( 30 ).
   918         self recordMatch:#( 33 ).
   916         self step.
   919         self step.
   917         ((currentCharacter between:$- and:$/) 
   920         (currentCharacter isLetter 
   918             or:[
   921             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
   919                 (currentCharacter between:$A and:$Z) 
       
   920                     or:[
       
   921                         currentCharacter == $_ 
       
   922                             or:[
       
   923                                 (currentCharacter between:$a and:$e) 
       
   924                                     or:[ (currentCharacter between:$g and:$z) ]
       
   925                             ]
       
   926                     ]
       
   927             ]) 
       
   928                 ifTrue:[
   922                 ifTrue:[
   929                     [
   923                     [
   930                         self recordMatch:#( 30 ).
   924                         self recordMatch:#( 33 ).
   931                         self step.
   925                         self step.
   932                         (currentCharacter isLetterOrDigit 
   926                         (currentCharacter isLetterOrDigit 
   933                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   927                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   934                     ] whileTrue.
   928                     ] whileTrue.
   935                     ^ self reportLastMatch
   929                     ^ self reportLastMatch
   936                 ].
   930                 ].
   937         (currentCharacter isXMLDigit) ifTrue:[
   931         (currentCharacter isXMLDigit) ifTrue:[
   938             ^ self scan2
   932             ^ self scan2
   939         ].
   933         ].
   940         (currentCharacter == $f) ifTrue:[
   934         ^ self reportLastMatch
   941             self recordMatch:#( 30 ).
   935     ].
       
   936     (currentCharacter == $/) ifTrue:[
       
   937         [
       
   938             self recordMatch:#( 33 ).
       
   939             self step.
       
   940             (currentCharacter isLetterOrDigit 
       
   941                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
   942         ] whileTrue.
       
   943         ^ self reportLastMatch
       
   944     ].
       
   945     (currentCharacter == $e) ifTrue:[
       
   946         self recordMatch:#( 30 33 ).
       
   947         self step.
       
   948         ((currentCharacter between:$0 and:$9) 
       
   949             or:[
       
   950                 (currentCharacter between:$A and:$Z) 
       
   951                     or:[
       
   952                         currentCharacter == $_ 
       
   953                             or:[
       
   954                                 (currentCharacter between:$a and:$m) 
       
   955                                     or:[ (currentCharacter between:$o and:$z) ]
       
   956                             ]
       
   957                     ]
       
   958             ]) 
       
   959                 ifTrue:[ ^ self scan1 ].
       
   960         (currentCharacter between:$- and:$/) ifTrue:[
       
   961             [
       
   962                 self recordMatch:#( 33 ).
       
   963                 self step.
       
   964                 (currentCharacter isLetterOrDigit 
       
   965                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
   966             ] whileTrue.
       
   967             ^ self reportLastMatch
       
   968         ].
       
   969         (currentCharacter == $n) ifTrue:[
       
   970             self recordMatch:#( 30 33 ).
   942             self step.
   971             self step.
   943             (currentCharacter isXMLDigit 
   972             (currentCharacter isXMLDigit 
   944                 or:[
   973                 or:[
   945                     (currentCharacter between:$- and:$/) 
   974                     (currentCharacter between:$A and:$Z) 
   946                         or:[
   975                         or:[
   947                             (currentCharacter between:$A and:$Z) 
   976                             currentCharacter == $_ 
   948                                 or:[
   977                                 or:[
   949                                     currentCharacter == $_ 
   978                                     (currentCharacter between:$a and:$t) 
   950                                         or:[
   979                                         or:[ (currentCharacter between:$v and:$z) ]
   951                                             (currentCharacter between:$a and:$n) 
       
   952                                                 or:[ (currentCharacter between:$p and:$z) ]
       
   953                                         ]
       
   954                                 ]
   980                                 ]
   955                         ]
   981                         ]
   956                 ]) 
   982                 ]) 
   957                     ifTrue:[
   983                     ifTrue:[ ^ self scan1 ].
       
   984             (currentCharacter between:$- and:$/) ifTrue:[
       
   985                 [
       
   986                     self recordMatch:#( 33 ).
       
   987                     self step.
       
   988                     (currentCharacter isLetterOrDigit 
       
   989                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
   990                 ] whileTrue.
       
   991                 ^ self reportLastMatch
       
   992             ].
       
   993             (currentCharacter == $u) ifTrue:[
       
   994                 self recordMatch:#( 30 33 ).
       
   995                 self step.
       
   996                 ((currentCharacter between:$0 and:$9) 
       
   997                     or:[
       
   998                         (currentCharacter between:$A and:$Z) 
       
   999                             or:[
       
  1000                                 currentCharacter == $_ 
       
  1001                                     or:[
       
  1002                                         (currentCharacter between:$a and:$l) 
       
  1003                                             or:[ (currentCharacter between:$n and:$z) ]
       
  1004                                     ]
       
  1005                             ]
       
  1006                     ]) 
       
  1007                         ifTrue:[ ^ self scan1 ].
       
  1008                 (currentCharacter between:$- and:$/) ifTrue:[
       
  1009                     [
       
  1010                         self recordMatch:#( 33 ).
       
  1011                         self step.
       
  1012                         (currentCharacter isLetterOrDigit 
       
  1013                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1014                     ] whileTrue.
       
  1015                     ^ self reportLastMatch
       
  1016                 ].
       
  1017                 (currentCharacter == $m) ifTrue:[
       
  1018                     self recordMatch:#( 30 33 ).
       
  1019                     self step.
       
  1020                     (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
       
  1021                         ^ self scan1
       
  1022                     ].
       
  1023                     (currentCharacter between:$. and:$/) ifTrue:[
   958                         [
  1024                         [
   959                             self recordMatch:#( 30 ).
  1025                             self recordMatch:#( 33 ).
   960                             self step.
  1026                             self step.
   961                             (currentCharacter isLetterOrDigit 
  1027                             (currentCharacter isLetterOrDigit 
   962                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1028                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
   963                         ] whileTrue.
  1029                         ] whileTrue.
   964                         ^ self reportLastMatch
  1030                         ^ self reportLastMatch
   965                     ].
  1031                     ].
   966             (currentCharacter == $o) ifTrue:[
  1032                     (currentCharacter == $-) ifTrue:[
   967                 self recordMatch:#( 30 ).
  1033                         self recordMatch:#( 33 ).
   968                 self step.
  1034                         self step.
   969                 ((currentCharacter between:$- and:$9) 
  1035                         ((currentCharacter between:$- and:$9) 
   970                     or:[
       
   971                         (currentCharacter between:$A and:$Z) 
       
   972                             or:[
  1036                             or:[
   973                                 currentCharacter == $_ 
  1037                                 (currentCharacter between:$A and:$Z) 
   974                                     or:[
  1038                                     or:[
   975                                         (currentCharacter between:$a and:$q) 
  1039                                         currentCharacter == $_ 
   976                                             or:[ (currentCharacter between:$s and:$z) ]
       
   977                                     ]
       
   978                             ]
       
   979                     ]) 
       
   980                         ifTrue:[
       
   981                             [
       
   982                                 self recordMatch:#( 30 ).
       
   983                                 self step.
       
   984                                 (currentCharacter isLetterOrDigit 
       
   985                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
   986                             ] whileTrue.
       
   987                             ^ self reportLastMatch
       
   988                         ].
       
   989                 (currentCharacter == $r) ifTrue:[
       
   990                     self recordMatch:#( 30 ).
       
   991                     self step.
       
   992                     (currentCharacter isXMLDigit 
       
   993                         or:[
       
   994                             (currentCharacter between:$- and:$/) 
       
   995                                 or:[
       
   996                                     (currentCharacter between:$A and:$Z) 
       
   997                                         or:[
       
   998                                             currentCharacter == $_ 
       
   999                                                 or:[
       
  1000                                                     (currentCharacter between:$a and:$d) 
       
  1001                                                         or:[ (currentCharacter between:$f and:$z) ]
       
  1002                                                 ]
       
  1003                                         ]
       
  1004                                 ]
       
  1005                         ]) 
       
  1006                             ifTrue:[
       
  1007                                 [
       
  1008                                     self recordMatch:#( 30 ).
       
  1009                                     self step.
       
  1010                                     (currentCharacter isLetterOrDigit 
       
  1011                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1012                                 ] whileTrue.
       
  1013                                 ^ self reportLastMatch
       
  1014                             ].
       
  1015                     (currentCharacter == $e) ifTrue:[
       
  1016                         self recordMatch:#( 30 ).
       
  1017                         self step.
       
  1018                         (currentCharacter isXMLDigit 
       
  1019                             or:[
       
  1020                                 (currentCharacter between:$- and:$/) 
       
  1021                                     or:[
       
  1022                                         (currentCharacter between:$A and:$Z) 
       
  1023                                             or:[
  1040                                             or:[
  1024                                                 currentCharacter == $_ 
  1041                                                 (currentCharacter between:$a and:$e) 
  1025                                                     or:[
  1042                                                     or:[ (currentCharacter between:$g and:$z) ]
  1026                                                         (currentCharacter between:$a and:$h) 
       
  1027                                                             or:[ (currentCharacter between:$j and:$z) ]
       
  1028                                                     ]
       
  1029                                             ]
  1043                                             ]
  1030                                     ]
  1044                                     ]
  1031                             ]) 
  1045                             ]) 
  1032                                 ifTrue:[
  1046                                 ifTrue:[
  1033                                     [
  1047                                     [
  1034                                         self recordMatch:#( 30 ).
  1048                                         self recordMatch:#( 33 ).
  1035                                         self step.
  1049                                         self step.
  1036                                         (currentCharacter isLetterOrDigit 
  1050                                         (currentCharacter isLetterOrDigit 
  1037                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1051                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1038                                     ] whileTrue.
  1052                                     ] whileTrue.
  1039                                     ^ self reportLastMatch
  1053                                     ^ self reportLastMatch
  1040                                 ].
  1054                                 ].
  1041                         (currentCharacter == $i) ifTrue:[
  1055                         (currentCharacter == $f) ifTrue:[
  1042                             self recordMatch:#( 30 ).
  1056                             self recordMatch:#( 33 ).
  1043                             self step.
  1057                             self step.
  1044                             ((currentCharacter between:$- and:$9) 
  1058                             (currentCharacter isXMLDigit 
  1045                                 or:[
  1059                                 or:[
  1046                                     (currentCharacter between:$A and:$Z) 
  1060                                     (currentCharacter between:$- and:$/) 
  1047                                         or:[
  1061                                         or:[
  1048                                             currentCharacter == $_ 
  1062                                             (currentCharacter between:$A and:$Z) 
  1049                                                 or:[
  1063                                                 or:[
  1050                                                     (currentCharacter between:$a and:$f) 
  1064                                                     currentCharacter == $_ 
  1051                                                         or:[ (currentCharacter between:$h and:$z) ]
  1065                                                         or:[
       
  1066                                                             (currentCharacter between:$a and:$n) 
       
  1067                                                                 or:[ (currentCharacter between:$p and:$z) ]
       
  1068                                                         ]
  1052                                                 ]
  1069                                                 ]
  1053                                         ]
  1070                                         ]
  1054                                 ]) 
  1071                                 ]) 
  1055                                     ifTrue:[
  1072                                     ifTrue:[
  1056                                         [
  1073                                         [
  1057                                             self recordMatch:#( 30 ).
  1074                                             self recordMatch:#( 33 ).
  1058                                             self step.
  1075                                             self step.
  1059                                             (currentCharacter isLetterOrDigit 
  1076                                             (currentCharacter isLetterOrDigit 
  1060                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1077                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1061                                         ] whileTrue.
  1078                                         ] whileTrue.
  1062                                         ^ self reportLastMatch
  1079                                         ^ self reportLastMatch
  1063                                     ].
  1080                                     ].
  1064                             (currentCharacter == $g) ifTrue:[
  1081                             (currentCharacter == $o) ifTrue:[
  1065                                 self recordMatch:#( 30 ).
  1082                                 self recordMatch:#( 33 ).
  1066                                 self step.
  1083                                 self step.
  1067                                 ((currentCharacter between:$- and:$9) 
  1084                                 ((currentCharacter between:$- and:$9) 
  1068                                     or:[
  1085                                     or:[
  1069                                         (currentCharacter between:$A and:$Z) 
  1086                                         (currentCharacter between:$A and:$Z) 
  1070                                             or:[
  1087                                             or:[
  1071                                                 currentCharacter == $_ 
  1088                                                 currentCharacter == $_ 
  1072                                                     or:[
  1089                                                     or:[
  1073                                                         (currentCharacter between:$a and:$m) 
  1090                                                         (currentCharacter between:$a and:$q) 
  1074                                                             or:[ (currentCharacter between:$o and:$z) ]
  1091                                                             or:[ (currentCharacter between:$s and:$z) ]
  1075                                                     ]
  1092                                                     ]
  1076                                             ]
  1093                                             ]
  1077                                     ]) 
  1094                                     ]) 
  1078                                         ifTrue:[
  1095                                         ifTrue:[
  1079                                             [
  1096                                             [
  1080                                                 self recordMatch:#( 30 ).
  1097                                                 self recordMatch:#( 33 ).
  1081                                                 self step.
  1098                                                 self step.
  1082                                                 (currentCharacter isLetterOrDigit 
  1099                                                 (currentCharacter isLetterOrDigit 
  1083                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1100                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1084                                             ] whileTrue.
  1101                                             ] whileTrue.
  1085                                             ^ self reportLastMatch
  1102                                             ^ self reportLastMatch
  1086                                         ].
  1103                                         ].
  1087                                 (currentCharacter == $n) ifTrue:[
  1104                                 (currentCharacter == $r) ifTrue:[
  1088                                     self recordMatch:#( 19 30 ).
  1105                                     self recordMatch:#( 33 ).
  1089                                     self step.
  1106                                     self step.
  1090                                     (currentCharacter isLetterOrDigit 
  1107                                     (currentCharacter isXMLDigit 
  1091                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
  1108                                         or:[
       
  1109                                             (currentCharacter between:$- and:$/) 
       
  1110                                                 or:[
       
  1111                                                     (currentCharacter between:$A and:$Z) 
       
  1112                                                         or:[
       
  1113                                                             currentCharacter == $_ 
       
  1114                                                                 or:[
       
  1115                                                                     (currentCharacter between:$a and:$d) 
       
  1116                                                                         or:[ (currentCharacter between:$f and:$z) ]
       
  1117                                                                 ]
       
  1118                                                         ]
       
  1119                                                 ]
       
  1120                                         ]) 
  1092                                             ifTrue:[
  1121                                             ifTrue:[
  1093                                                 [
  1122                                                 [
  1094                                                     self recordMatch:#( 30 ).
  1123                                                     self recordMatch:#( 33 ).
  1095                                                     self step.
  1124                                                     self step.
  1096                                                     (currentCharacter isLetterOrDigit 
  1125                                                     (currentCharacter isLetterOrDigit 
  1097                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1126                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1098                                                 ] whileTrue.
  1127                                                 ] whileTrue.
  1099                                                 ^ self reportLastMatch
  1128                                                 ^ self reportLastMatch
  1100                                             ].
  1129                                             ].
       
  1130                                     (currentCharacter == $e) ifTrue:[
       
  1131                                         self recordMatch:#( 33 ).
       
  1132                                         self step.
       
  1133                                         (currentCharacter isXMLDigit 
       
  1134                                             or:[
       
  1135                                                 (currentCharacter between:$- and:$/) 
       
  1136                                                     or:[
       
  1137                                                         (currentCharacter between:$A and:$Z) 
       
  1138                                                             or:[
       
  1139                                                                 currentCharacter == $_ 
       
  1140                                                                     or:[
       
  1141                                                                         (currentCharacter between:$a and:$h) 
       
  1142                                                                             or:[ (currentCharacter between:$j and:$z) ]
       
  1143                                                                     ]
       
  1144                                                             ]
       
  1145                                                     ]
       
  1146                                             ]) 
       
  1147                                                 ifTrue:[
       
  1148                                                     [
       
  1149                                                         self recordMatch:#( 33 ).
       
  1150                                                         self step.
       
  1151                                                         (currentCharacter isLetterOrDigit 
       
  1152                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1153                                                     ] whileTrue.
       
  1154                                                     ^ self reportLastMatch
       
  1155                                                 ].
       
  1156                                         (currentCharacter == $i) ifTrue:[
       
  1157                                             self recordMatch:#( 33 ).
       
  1158                                             self step.
       
  1159                                             ((currentCharacter between:$- and:$9) 
       
  1160                                                 or:[
       
  1161                                                     (currentCharacter between:$A and:$Z) 
       
  1162                                                         or:[
       
  1163                                                             currentCharacter == $_ 
       
  1164                                                                 or:[
       
  1165                                                                     (currentCharacter between:$a and:$f) 
       
  1166                                                                         or:[ (currentCharacter between:$h and:$z) ]
       
  1167                                                                 ]
       
  1168                                                         ]
       
  1169                                                 ]) 
       
  1170                                                     ifTrue:[
       
  1171                                                         [
       
  1172                                                             self recordMatch:#( 33 ).
       
  1173                                                             self step.
       
  1174                                                             (currentCharacter isLetterOrDigit 
       
  1175                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1176                                                         ] whileTrue.
       
  1177                                                         ^ self reportLastMatch
       
  1178                                                     ].
       
  1179                                             (currentCharacter == $g) ifTrue:[
       
  1180                                                 self recordMatch:#( 33 ).
       
  1181                                                 self step.
       
  1182                                                 ((currentCharacter between:$- and:$9) 
       
  1183                                                     or:[
       
  1184                                                         (currentCharacter between:$A and:$Z) 
       
  1185                                                             or:[
       
  1186                                                                 currentCharacter == $_ 
       
  1187                                                                     or:[
       
  1188                                                                         (currentCharacter between:$a and:$m) 
       
  1189                                                                             or:[ (currentCharacter between:$o and:$z) ]
       
  1190                                                                     ]
       
  1191                                                             ]
       
  1192                                                     ]) 
       
  1193                                                         ifTrue:[
       
  1194                                                             [
       
  1195                                                                 self recordMatch:#( 33 ).
       
  1196                                                                 self step.
       
  1197                                                                 (currentCharacter isLetterOrDigit 
       
  1198                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1199                                                             ] whileTrue.
       
  1200                                                             ^ self reportLastMatch
       
  1201                                                         ].
       
  1202                                                 (currentCharacter == $n) ifTrue:[
       
  1203                                                     self recordMatch:#( 18 33 ).
       
  1204                                                     self step.
       
  1205                                                     (currentCharacter isLetterOrDigit 
       
  1206                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
       
  1207                                                             ifTrue:[
       
  1208                                                                 [
       
  1209                                                                     self recordMatch:#( 33 ).
       
  1210                                                                     self step.
       
  1211                                                                     (currentCharacter isLetterOrDigit 
       
  1212                                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1213                                                                 ] whileTrue.
       
  1214                                                                 ^ self reportLastMatch
       
  1215                                                             ].
       
  1216                                                     ^ self reportLastMatch
       
  1217                                                 ].
       
  1218                                                 ^ self reportLastMatch
       
  1219                                             ].
       
  1220                                             ^ self reportLastMatch
       
  1221                                         ].
       
  1222                                         ^ self reportLastMatch
       
  1223                                     ].
  1101                                     ^ self reportLastMatch
  1224                                     ^ self reportLastMatch
  1102                                 ].
  1225                                 ].
  1103                                 ^ self reportLastMatch
  1226                                 ^ self reportLastMatch
  1104                             ].
  1227                             ].
  1105                             ^ self reportLastMatch
  1228                             ^ self reportLastMatch
  1112             ].
  1235             ].
  1113             ^ self reportLastMatch
  1236             ^ self reportLastMatch
  1114         ].
  1237         ].
  1115         ^ self reportLastMatch
  1238         ^ self reportLastMatch
  1116     ].
  1239     ].
  1117     (currentCharacter == $/) ifTrue:[
       
  1118         [
       
  1119             self recordMatch:#( 30 ).
       
  1120             self step.
       
  1121             (currentCharacter isLetterOrDigit 
       
  1122                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1123         ] whileTrue.
       
  1124         ^ self reportLastMatch
       
  1125     ].
       
  1126     (currentCharacter == $f) ifTrue:[
  1240     (currentCharacter == $f) ifTrue:[
  1127         self recordMatch:#( 27 30 ).
  1241         self recordMatch:#( 30 33 ).
  1128         self step.
  1242         self step.
  1129         (currentCharacter isXMLDigit 
  1243         (currentCharacter isXMLDigit 
  1130             or:[
  1244             or:[
  1131                 (currentCharacter between:$A and:$Z) 
  1245                 (currentCharacter between:$A and:$Z) 
  1132                     or:[
  1246                     or:[
  1141                     ]
  1255                     ]
  1142             ]) 
  1256             ]) 
  1143                 ifTrue:[ ^ self scan1 ].
  1257                 ifTrue:[ ^ self scan1 ].
  1144         (currentCharacter between:$- and:$/) ifTrue:[
  1258         (currentCharacter between:$- and:$/) ifTrue:[
  1145             [
  1259             [
  1146                 self recordMatch:#( 30 ).
  1260                 self recordMatch:#( 33 ).
  1147                 self step.
  1261                 self step.
  1148                 (currentCharacter isLetterOrDigit 
  1262                 (currentCharacter isLetterOrDigit 
  1149                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1263                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1150             ] whileTrue.
  1264             ] whileTrue.
  1151             ^ self reportLastMatch
  1265             ^ self reportLastMatch
  1152         ].
  1266         ].
  1153         (currentCharacter == $r) ifTrue:[
  1267         (currentCharacter == $r) ifTrue:[
  1154             self recordMatch:#( 27 30 ).
  1268             self recordMatch:#( 30 33 ).
  1155             self step.
  1269             self step.
  1156             (currentCharacter isXMLDigit 
  1270             (currentCharacter isXMLDigit 
  1157                 or:[
  1271                 or:[
  1158                     (currentCharacter between:$A and:$Z) 
  1272                     (currentCharacter between:$A and:$Z) 
  1159                         or:[
  1273                         or:[
  1165                         ]
  1279                         ]
  1166                 ]) 
  1280                 ]) 
  1167                     ifTrue:[ ^ self scan1 ].
  1281                     ifTrue:[ ^ self scan1 ].
  1168             (currentCharacter between:$- and:$/) ifTrue:[
  1282             (currentCharacter between:$- and:$/) ifTrue:[
  1169                 [
  1283                 [
  1170                     self recordMatch:#( 30 ).
  1284                     self recordMatch:#( 33 ).
  1171                     self step.
  1285                     self step.
  1172                     (currentCharacter isLetterOrDigit 
  1286                     (currentCharacter isLetterOrDigit 
  1173                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1287                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1174                 ] whileTrue.
  1288                 ] whileTrue.
  1175                 ^ self reportLastMatch
  1289                 ^ self reportLastMatch
  1176             ].
  1290             ].
  1177             (currentCharacter == $o) ifTrue:[
  1291             (currentCharacter == $o) ifTrue:[
  1178                 self recordMatch:#( 27 30 ).
  1292                 self recordMatch:#( 30 33 ).
  1179                 self step.
  1293                 self step.
  1180                 ((currentCharacter between:$0 and:$9) 
  1294                 ((currentCharacter between:$0 and:$9) 
  1181                     or:[
  1295                     or:[
  1182                         (currentCharacter between:$A and:$Z) 
  1296                         (currentCharacter between:$A and:$Z) 
  1183                             or:[
  1297                             or:[
  1189                             ]
  1303                             ]
  1190                     ]) 
  1304                     ]) 
  1191                         ifTrue:[ ^ self scan1 ].
  1305                         ifTrue:[ ^ self scan1 ].
  1192                 (currentCharacter between:$- and:$/) ifTrue:[
  1306                 (currentCharacter between:$- and:$/) ifTrue:[
  1193                     [
  1307                     [
  1194                         self recordMatch:#( 30 ).
  1308                         self recordMatch:#( 33 ).
  1195                         self step.
  1309                         self step.
  1196                         (currentCharacter isLetterOrDigit 
  1310                         (currentCharacter isLetterOrDigit 
  1197                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1311                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1198                     ] whileTrue.
  1312                     ] whileTrue.
  1199                     ^ self reportLastMatch
  1313                     ^ self reportLastMatch
  1200                 ].
  1314                 ].
  1201                 (currentCharacter == $m) ifTrue:[
  1315                 (currentCharacter == $m) ifTrue:[
  1202                     self recordMatch:#( 27 30 ).
  1316                     self recordMatch:#( 30 33 ).
  1203                     self step.
  1317                     self step.
  1204                     (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
  1318                     (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
  1205                         ^ self scan1
  1319                         ^ self scan1
  1206                     ].
  1320                     ].
  1207                     (currentCharacter between:$- and:$/) ifTrue:[
  1321                     (currentCharacter between:$- and:$/) ifTrue:[
  1208                         [
  1322                         [
  1209                             self recordMatch:#( 30 ).
  1323                             self recordMatch:#( 33 ).
  1210                             self step.
  1324                             self step.
  1211                             (currentCharacter isLetterOrDigit 
  1325                             (currentCharacter isLetterOrDigit 
  1212                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1326                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1213                         ] whileTrue.
  1327                         ] whileTrue.
  1214                         ^ self reportLastMatch
  1328                         ^ self reportLastMatch
  1215                     ].
  1329                     ].
  1216                     (currentCharacter == $:) ifTrue:[
  1330                     (currentCharacter == $:) ifTrue:[
  1217                         ^ self recordAndReportMatch:#( 9 ).
  1331                         ^ self recordAndReportMatch:#( 10 ).
  1218                     ].
  1332                     ].
  1219                     ^ self reportLastMatch
  1333                     ^ self reportLastMatch
  1220                 ].
  1334                 ].
  1221                 ^ self reportLastMatch
  1335                 ^ self reportLastMatch
  1222             ].
  1336             ].
  1223             ^ self reportLastMatch
  1337             ^ self reportLastMatch
  1224         ].
  1338         ].
  1225         (currentCharacter == $u) ifTrue:[
  1339         (currentCharacter == $u) ifTrue:[
  1226             self recordMatch:#( 27 30 ).
  1340             self recordMatch:#( 30 33 ).
  1227             self step.
  1341             self step.
  1228             ((currentCharacter between:$0 and:$9) 
  1342             ((currentCharacter between:$0 and:$9) 
  1229                 or:[
  1343                 or:[
  1230                     (currentCharacter between:$A and:$Z) 
  1344                     (currentCharacter between:$A and:$Z) 
  1231                         or:[
  1345                         or:[
  1237                         ]
  1351                         ]
  1238                 ]) 
  1352                 ]) 
  1239                     ifTrue:[ ^ self scan1 ].
  1353                     ifTrue:[ ^ self scan1 ].
  1240             (currentCharacter between:$- and:$/) ifTrue:[
  1354             (currentCharacter between:$- and:$/) ifTrue:[
  1241                 [
  1355                 [
  1242                     self recordMatch:#( 30 ).
  1356                     self recordMatch:#( 33 ).
  1243                     self step.
  1357                     self step.
  1244                     (currentCharacter isLetterOrDigit 
  1358                     (currentCharacter isLetterOrDigit 
  1245                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1359                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1246                 ] whileTrue.
  1360                 ] whileTrue.
  1247                 ^ self reportLastMatch
  1361                 ^ self reportLastMatch
  1248             ].
  1362             ].
  1249             (currentCharacter == $n) ifTrue:[
  1363             (currentCharacter == $n) ifTrue:[
  1250                 self recordMatch:#( 27 30 ).
  1364                 self recordMatch:#( 30 33 ).
  1251                 self step.
  1365                 self step.
  1252                 ((currentCharacter between:$0 and:$9) 
  1366                 ((currentCharacter between:$0 and:$9) 
  1253                     or:[
  1367                     or:[
  1254                         (currentCharacter between:$A and:$Z) 
  1368                         (currentCharacter between:$A and:$Z) 
  1255                             or:[
  1369                             or:[
  1261                             ]
  1375                             ]
  1262                     ]) 
  1376                     ]) 
  1263                         ifTrue:[ ^ self scan1 ].
  1377                         ifTrue:[ ^ self scan1 ].
  1264                 (currentCharacter between:$- and:$/) ifTrue:[
  1378                 (currentCharacter between:$- and:$/) ifTrue:[
  1265                     [
  1379                     [
  1266                         self recordMatch:#( 30 ).
  1380                         self recordMatch:#( 33 ).
  1267                         self step.
  1381                         self step.
  1268                         (currentCharacter isLetterOrDigit 
  1382                         (currentCharacter isLetterOrDigit 
  1269                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1383                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1270                     ] whileTrue.
  1384                     ] whileTrue.
  1271                     ^ self reportLastMatch
  1385                     ^ self reportLastMatch
  1272                 ].
  1386                 ].
  1273                 (currentCharacter == $c) ifTrue:[
  1387                 (currentCharacter == $c) ifTrue:[
  1274                     self recordMatch:#( 27 30 ).
  1388                     self recordMatch:#( 30 33 ).
  1275                     self step.
  1389                     self step.
  1276                     ((currentCharacter between:$0 and:$9) 
  1390                     ((currentCharacter between:$0 and:$9) 
  1277                         or:[
  1391                         or:[
  1278                             (currentCharacter between:$A and:$Z) 
  1392                             (currentCharacter between:$A and:$Z) 
  1279                                 or:[
  1393                                 or:[
  1285                                 ]
  1399                                 ]
  1286                         ]) 
  1400                         ]) 
  1287                             ifTrue:[ ^ self scan1 ].
  1401                             ifTrue:[ ^ self scan1 ].
  1288                     (currentCharacter between:$- and:$/) ifTrue:[
  1402                     (currentCharacter between:$- and:$/) ifTrue:[
  1289                         [
  1403                         [
  1290                             self recordMatch:#( 30 ).
  1404                             self recordMatch:#( 33 ).
  1291                             self step.
  1405                             self step.
  1292                             (currentCharacter isLetterOrDigit 
  1406                             (currentCharacter isLetterOrDigit 
  1293                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1407                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1294                         ] whileTrue.
  1408                         ] whileTrue.
  1295                         ^ self reportLastMatch
  1409                         ^ self reportLastMatch
  1296                     ].
  1410                     ].
  1297                     (currentCharacter == $t) ifTrue:[
  1411                     (currentCharacter == $t) ifTrue:[
  1298                         self recordMatch:#( 27 30 ).
  1412                         self recordMatch:#( 30 33 ).
  1299                         self step.
  1413                         self step.
  1300                         (currentCharacter isXMLDigit 
  1414                         (currentCharacter isXMLDigit 
  1301                             or:[
  1415                             or:[
  1302                                 (currentCharacter between:$A and:$Z) 
  1416                                 (currentCharacter between:$A and:$Z) 
  1303                                     or:[
  1417                                     or:[
  1309                                     ]
  1423                                     ]
  1310                             ]) 
  1424                             ]) 
  1311                                 ifTrue:[ ^ self scan1 ].
  1425                                 ifTrue:[ ^ self scan1 ].
  1312                         (currentCharacter between:$- and:$/) ifTrue:[
  1426                         (currentCharacter between:$- and:$/) ifTrue:[
  1313                             [
  1427                             [
  1314                                 self recordMatch:#( 30 ).
  1428                                 self recordMatch:#( 33 ).
  1315                                 self step.
  1429                                 self step.
  1316                                 (currentCharacter isLetterOrDigit 
  1430                                 (currentCharacter isLetterOrDigit 
  1317                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1431                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1318                             ] whileTrue.
  1432                             ] whileTrue.
  1319                             ^ self reportLastMatch
  1433                             ^ self reportLastMatch
  1320                         ].
  1434                         ].
  1321                         (currentCharacter == $i) ifTrue:[
  1435                         (currentCharacter == $i) ifTrue:[
  1322                             self recordMatch:#( 27 30 ).
  1436                             self recordMatch:#( 30 33 ).
  1323                             self step.
  1437                             self step.
  1324                             (currentCharacter isXMLDigit 
  1438                             (currentCharacter isXMLDigit 
  1325                                 or:[
  1439                                 or:[
  1326                                     (currentCharacter between:$A and:$Z) 
  1440                                     (currentCharacter between:$A and:$Z) 
  1327                                         or:[
  1441                                         or:[
  1333                                         ]
  1447                                         ]
  1334                                 ]) 
  1448                                 ]) 
  1335                                     ifTrue:[ ^ self scan1 ].
  1449                                     ifTrue:[ ^ self scan1 ].
  1336                             (currentCharacter between:$- and:$/) ifTrue:[
  1450                             (currentCharacter between:$- and:$/) ifTrue:[
  1337                                 [
  1451                                 [
  1338                                     self recordMatch:#( 30 ).
  1452                                     self recordMatch:#( 33 ).
  1339                                     self step.
  1453                                     self step.
  1340                                     (currentCharacter isLetterOrDigit 
  1454                                     (currentCharacter isLetterOrDigit 
  1341                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1455                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1342                                 ] whileTrue.
  1456                                 ] whileTrue.
  1343                                 ^ self reportLastMatch
  1457                                 ^ self reportLastMatch
  1344                             ].
  1458                             ].
  1345                             (currentCharacter == $o) ifTrue:[
  1459                             (currentCharacter == $o) ifTrue:[
  1346                                 self recordMatch:#( 27 30 ).
  1460                                 self recordMatch:#( 30 33 ).
  1347                                 self step.
  1461                                 self step.
  1348                                 ((currentCharacter between:$0 and:$9) 
  1462                                 ((currentCharacter between:$0 and:$9) 
  1349                                     or:[
  1463                                     or:[
  1350                                         (currentCharacter between:$A and:$Z) 
  1464                                         (currentCharacter between:$A and:$Z) 
  1351                                             or:[
  1465                                             or:[
  1357                                             ]
  1471                                             ]
  1358                                     ]) 
  1472                                     ]) 
  1359                                         ifTrue:[ ^ self scan1 ].
  1473                                         ifTrue:[ ^ self scan1 ].
  1360                                 (currentCharacter between:$- and:$/) ifTrue:[
  1474                                 (currentCharacter between:$- and:$/) ifTrue:[
  1361                                     [
  1475                                     [
  1362                                         self recordMatch:#( 30 ).
  1476                                         self recordMatch:#( 33 ).
  1363                                         self step.
  1477                                         self step.
  1364                                         (currentCharacter isLetterOrDigit 
  1478                                         (currentCharacter isLetterOrDigit 
  1365                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1479                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1366                                     ] whileTrue.
  1480                                     ] whileTrue.
  1367                                     ^ self reportLastMatch
  1481                                     ^ self reportLastMatch
  1368                                 ].
  1482                                 ].
  1369                                 (currentCharacter == $n) ifTrue:[
  1483                                 (currentCharacter == $n) ifTrue:[
  1370                                     self recordMatch:#( 27 30 ).
  1484                                     self recordMatch:#( 30 33 ).
  1371                                     self step.
  1485                                     self step.
  1372                                     (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
  1486                                     (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
  1373                                         ^ self scan1
  1487                                         ^ self scan1
  1374                                     ].
  1488                                     ].
  1375                                     (currentCharacter between:$. and:$/) ifTrue:[
  1489                                     (currentCharacter between:$. and:$/) ifTrue:[
  1376                                         [
  1490                                         [
  1377                                             self recordMatch:#( 30 ).
  1491                                             self recordMatch:#( 33 ).
  1378                                             self step.
  1492                                             self step.
  1379                                             (currentCharacter isLetterOrDigit 
  1493                                             (currentCharacter isLetterOrDigit 
  1380                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1494                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1381                                         ] whileTrue.
  1495                                         ] whileTrue.
  1382                                         ^ self reportLastMatch
  1496                                         ^ self reportLastMatch
  1383                                     ].
  1497                                     ].
  1384                                     (currentCharacter == $-) ifTrue:[
  1498                                     (currentCharacter == $-) ifTrue:[
  1385                                         self recordMatch:#( 30 ).
  1499                                         self recordMatch:#( 33 ).
  1386                                         self step.
  1500                                         self step.
  1387                                         ((currentCharacter between:$- and:$9) 
  1501                                         ((currentCharacter between:$- and:$9) 
  1388                                             or:[
  1502                                             or:[
  1389                                                 (currentCharacter between:$A and:$Z) 
  1503                                                 (currentCharacter between:$A and:$Z) 
  1390                                                     or:[
  1504                                                     or:[
  1395                                                             ]
  1509                                                             ]
  1396                                                     ]
  1510                                                     ]
  1397                                             ]) 
  1511                                             ]) 
  1398                                                 ifTrue:[
  1512                                                 ifTrue:[
  1399                                                     [
  1513                                                     [
  1400                                                         self recordMatch:#( 30 ).
  1514                                                         self recordMatch:#( 33 ).
  1401                                                         self step.
  1515                                                         self step.
  1402                                                         (currentCharacter isLetterOrDigit 
  1516                                                         (currentCharacter isLetterOrDigit 
  1403                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1517                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1404                                                     ] whileTrue.
  1518                                                     ] whileTrue.
  1405                                                     ^ self reportLastMatch
  1519                                                     ^ self reportLastMatch
  1406                                                 ].
  1520                                                 ].
  1407                                         (currentCharacter == $t) ifTrue:[
  1521                                         (currentCharacter == $t) ifTrue:[
  1408                                             self recordMatch:#( 30 ).
  1522                                             self recordMatch:#( 33 ).
  1409                                             self step.
  1523                                             self step.
  1410                                             ((currentCharacter between:$- and:$9) 
  1524                                             ((currentCharacter between:$- and:$9) 
  1411                                                 or:[
  1525                                                 or:[
  1412                                                     (currentCharacter between:$A and:$Z) 
  1526                                                     (currentCharacter between:$A and:$Z) 
  1413                                                         or:[
  1527                                                         or:[
  1415                                                                 or:[ (currentCharacter between:$a and:$x) or:[ currentCharacter == $z ] ]
  1529                                                                 or:[ (currentCharacter between:$a and:$x) or:[ currentCharacter == $z ] ]
  1416                                                         ]
  1530                                                         ]
  1417                                                 ]) 
  1531                                                 ]) 
  1418                                                     ifTrue:[
  1532                                                     ifTrue:[
  1419                                                         [
  1533                                                         [
  1420                                                             self recordMatch:#( 30 ).
  1534                                                             self recordMatch:#( 33 ).
  1421                                                             self step.
  1535                                                             self step.
  1422                                                             (currentCharacter isLetterOrDigit 
  1536                                                             (currentCharacter isLetterOrDigit 
  1423                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1537                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1424                                                         ] whileTrue.
  1538                                                         ] whileTrue.
  1425                                                         ^ self reportLastMatch
  1539                                                         ^ self reportLastMatch
  1426                                                     ].
  1540                                                     ].
  1427                                             (currentCharacter == $y) ifTrue:[
  1541                                             (currentCharacter == $y) ifTrue:[
  1428                                                 self recordMatch:#( 30 ).
  1542                                                 self recordMatch:#( 33 ).
  1429                                                 self step.
  1543                                                 self step.
  1430                                                 ((currentCharacter between:$- and:$9) 
  1544                                                 ((currentCharacter between:$- and:$9) 
  1431                                                     or:[
  1545                                                     or:[
  1432                                                         (currentCharacter between:$A and:$Z) 
  1546                                                         (currentCharacter between:$A and:$Z) 
  1433                                                             or:[
  1547                                                             or:[
  1438                                                                     ]
  1552                                                                     ]
  1439                                                             ]
  1553                                                             ]
  1440                                                     ]) 
  1554                                                     ]) 
  1441                                                         ifTrue:[
  1555                                                         ifTrue:[
  1442                                                             [
  1556                                                             [
  1443                                                                 self recordMatch:#( 30 ).
  1557                                                                 self recordMatch:#( 33 ).
  1444                                                                 self step.
  1558                                                                 self step.
  1445                                                                 (currentCharacter isLetterOrDigit 
  1559                                                                 (currentCharacter isLetterOrDigit 
  1446                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1560                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1447                                                             ] whileTrue.
  1561                                                             ] whileTrue.
  1448                                                             ^ self reportLastMatch
  1562                                                             ^ self reportLastMatch
  1449                                                         ].
  1563                                                         ].
  1450                                                 (currentCharacter == $p) ifTrue:[
  1564                                                 (currentCharacter == $p) ifTrue:[
  1451                                                     self recordMatch:#( 30 ).
  1565                                                     self recordMatch:#( 33 ).
  1452                                                     self step.
  1566                                                     self step.
  1453                                                     (currentCharacter isXMLDigit 
  1567                                                     (currentCharacter isXMLDigit 
  1454                                                         or:[
  1568                                                         or:[
  1455                                                             (currentCharacter between:$- and:$/) 
  1569                                                             (currentCharacter between:$- and:$/) 
  1456                                                                 or:[
  1570                                                                 or:[
  1464                                                                         ]
  1578                                                                         ]
  1465                                                                 ]
  1579                                                                 ]
  1466                                                         ]) 
  1580                                                         ]) 
  1467                                                             ifTrue:[
  1581                                                             ifTrue:[
  1468                                                                 [
  1582                                                                 [
  1469                                                                     self recordMatch:#( 30 ).
  1583                                                                     self recordMatch:#( 33 ).
  1470                                                                     self step.
  1584                                                                     self step.
  1471                                                                     (currentCharacter isLetterOrDigit 
  1585                                                                     (currentCharacter isLetterOrDigit 
  1472                                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1586                                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1473                                                                 ] whileTrue.
  1587                                                                 ] whileTrue.
  1474                                                                 ^ self reportLastMatch
  1588                                                                 ^ self reportLastMatch
  1475                                                             ].
  1589                                                             ].
  1476                                                     (currentCharacter == $e) ifTrue:[
  1590                                                     (currentCharacter == $e) ifTrue:[
  1477                                                         self recordMatch:#( 1 30 ).
  1591                                                         self recordMatch:#( 4 33 ).
  1478                                                         self step.
  1592                                                         self step.
  1479                                                         (currentCharacter isLetterOrDigit 
  1593                                                         (currentCharacter isLetterOrDigit 
  1480                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
  1594                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
  1481                                                                 ifTrue:[
  1595                                                                 ifTrue:[
  1482                                                                     [
  1596                                                                     [
  1483                                                                         self recordMatch:#( 30 ).
  1597                                                                         self recordMatch:#( 33 ).
  1484                                                                         self step.
  1598                                                                         self step.
  1485                                                                         (currentCharacter isLetterOrDigit 
  1599                                                                         (currentCharacter isLetterOrDigit 
  1486                                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1600                                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1487                                                                     ] whileTrue.
  1601                                                                     ] whileTrue.
  1488                                                                     ^ self reportLastMatch
  1602                                                                     ^ self reportLastMatch
  1512             ^ self reportLastMatch
  1626             ^ self reportLastMatch
  1513         ].
  1627         ].
  1514         ^ self reportLastMatch
  1628         ^ self reportLastMatch
  1515     ].
  1629     ].
  1516     (currentCharacter == $p) ifTrue:[
  1630     (currentCharacter == $p) ifTrue:[
  1517         self recordMatch:#( 27 30 ).
  1631         self recordMatch:#( 30 33 ).
  1518         self step.
  1632         self step.
  1519         (currentCharacter isXMLDigit 
  1633         (currentCharacter isXMLDigit 
  1520             or:[
  1634             or:[
  1521                 (currentCharacter between:$A and:$Z) 
  1635                 (currentCharacter between:$A and:$Z) 
  1522                     or:[
  1636                     or:[
  1528                     ]
  1642                     ]
  1529             ]) 
  1643             ]) 
  1530                 ifTrue:[ ^ self scan1 ].
  1644                 ifTrue:[ ^ self scan1 ].
  1531         (currentCharacter between:$- and:$/) ifTrue:[
  1645         (currentCharacter between:$- and:$/) ifTrue:[
  1532             [
  1646             [
  1533                 self recordMatch:#( 30 ).
  1647                 self recordMatch:#( 33 ).
  1534                 self step.
  1648                 self step.
  1535                 (currentCharacter isLetterOrDigit 
  1649                 (currentCharacter isLetterOrDigit 
  1536                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1650                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1537             ] whileTrue.
  1651             ] whileTrue.
  1538             ^ self reportLastMatch
  1652             ^ self reportLastMatch
  1539         ].
  1653         ].
  1540         (currentCharacter == $o) ifTrue:[
  1654         (currentCharacter == $o) ifTrue:[
  1541             self recordMatch:#( 27 30 ).
  1655             self recordMatch:#( 30 33 ).
  1542             self step.
  1656             self step.
  1543             (currentCharacter isXMLDigit 
  1657             (currentCharacter isXMLDigit 
  1544                 or:[
  1658                 or:[
  1545                     (currentCharacter between:$A and:$Z) 
  1659                     (currentCharacter between:$A and:$Z) 
  1546                         or:[
  1660                         or:[
  1552                         ]
  1666                         ]
  1553                 ]) 
  1667                 ]) 
  1554                     ifTrue:[ ^ self scan1 ].
  1668                     ifTrue:[ ^ self scan1 ].
  1555             (currentCharacter between:$- and:$/) ifTrue:[
  1669             (currentCharacter between:$- and:$/) ifTrue:[
  1556                 [
  1670                 [
  1557                     self recordMatch:#( 30 ).
  1671                     self recordMatch:#( 33 ).
  1558                     self step.
  1672                     self step.
  1559                     (currentCharacter isLetterOrDigit 
  1673                     (currentCharacter isLetterOrDigit 
  1560                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1674                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1561                 ] whileTrue.
  1675                 ] whileTrue.
  1562                 ^ self reportLastMatch
  1676                 ^ self reportLastMatch
  1563             ].
  1677             ].
  1564             (currentCharacter == $i) ifTrue:[
  1678             (currentCharacter == $i) ifTrue:[
  1565                 self recordMatch:#( 27 30 ).
  1679                 self recordMatch:#( 30 33 ).
  1566                 self step.
  1680                 self step.
  1567                 ((currentCharacter between:$0 and:$9) 
  1681                 ((currentCharacter between:$0 and:$9) 
  1568                     or:[
  1682                     or:[
  1569                         (currentCharacter between:$A and:$Z) 
  1683                         (currentCharacter between:$A and:$Z) 
  1570                             or:[
  1684                             or:[
  1576                             ]
  1690                             ]
  1577                     ]) 
  1691                     ]) 
  1578                         ifTrue:[ ^ self scan1 ].
  1692                         ifTrue:[ ^ self scan1 ].
  1579                 (currentCharacter between:$- and:$/) ifTrue:[
  1693                 (currentCharacter between:$- and:$/) ifTrue:[
  1580                     [
  1694                     [
  1581                         self recordMatch:#( 30 ).
  1695                         self recordMatch:#( 33 ).
  1582                         self step.
  1696                         self step.
  1583                         (currentCharacter isLetterOrDigit 
  1697                         (currentCharacter isLetterOrDigit 
  1584                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1698                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1585                     ] whileTrue.
  1699                     ] whileTrue.
  1586                     ^ self reportLastMatch
  1700                     ^ self reportLastMatch
  1587                 ].
  1701                 ].
  1588                 (currentCharacter == $n) ifTrue:[
  1702                 (currentCharacter == $n) ifTrue:[
  1589                     self recordMatch:#( 27 30 ).
  1703                     self recordMatch:#( 30 33 ).
  1590                     self step.
  1704                     self step.
  1591                     ((currentCharacter between:$0 and:$9) 
  1705                     ((currentCharacter between:$0 and:$9) 
  1592                         or:[
  1706                         or:[
  1593                             (currentCharacter between:$A and:$Z) 
  1707                             (currentCharacter between:$A and:$Z) 
  1594                                 or:[
  1708                                 or:[
  1600                                 ]
  1714                                 ]
  1601                         ]) 
  1715                         ]) 
  1602                             ifTrue:[ ^ self scan1 ].
  1716                             ifTrue:[ ^ self scan1 ].
  1603                     (currentCharacter between:$- and:$/) ifTrue:[
  1717                     (currentCharacter between:$- and:$/) ifTrue:[
  1604                         [
  1718                         [
  1605                             self recordMatch:#( 30 ).
  1719                             self recordMatch:#( 33 ).
  1606                             self step.
  1720                             self step.
  1607                             (currentCharacter isLetterOrDigit 
  1721                             (currentCharacter isLetterOrDigit 
  1608                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1722                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1609                         ] whileTrue.
  1723                         ] whileTrue.
  1610                         ^ self reportLastMatch
  1724                         ^ self reportLastMatch
  1611                     ].
  1725                     ].
  1612                     (currentCharacter == $t) ifTrue:[
  1726                     (currentCharacter == $t) ifTrue:[
  1613                         self recordMatch:#( 27 30 ).
  1727                         self recordMatch:#( 30 33 ).
  1614                         self step.
  1728                         self step.
  1615                         (currentCharacter isXMLDigit 
  1729                         (currentCharacter isXMLDigit 
  1616                             or:[
  1730                             or:[
  1617                                 (currentCharacter between:$A and:$Z) 
  1731                                 (currentCharacter between:$A and:$Z) 
  1618                                     or:[
  1732                                     or:[
  1624                                     ]
  1738                                     ]
  1625                             ]) 
  1739                             ]) 
  1626                                 ifTrue:[ ^ self scan1 ].
  1740                                 ifTrue:[ ^ self scan1 ].
  1627                         (currentCharacter between:$- and:$/) ifTrue:[
  1741                         (currentCharacter between:$- and:$/) ifTrue:[
  1628                             [
  1742                             [
  1629                                 self recordMatch:#( 30 ).
  1743                                 self recordMatch:#( 33 ).
  1630                                 self step.
  1744                                 self step.
  1631                                 (currentCharacter isLetterOrDigit 
  1745                                 (currentCharacter isLetterOrDigit 
  1632                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1746                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1633                             ] whileTrue.
  1747                             ] whileTrue.
  1634                             ^ self reportLastMatch
  1748                             ^ self reportLastMatch
  1635                         ].
  1749                         ].
  1636                         (currentCharacter == $e) ifTrue:[
  1750                         (currentCharacter == $e) ifTrue:[
  1637                             self recordMatch:#( 27 30 ).
  1751                             self recordMatch:#( 30 33 ).
  1638                             self step.
  1752                             self step.
  1639                             ((currentCharacter between:$0 and:$9) 
  1753                             ((currentCharacter between:$0 and:$9) 
  1640                                 or:[
  1754                                 or:[
  1641                                     (currentCharacter between:$A and:$Z) 
  1755                                     (currentCharacter between:$A and:$Z) 
  1642                                         or:[
  1756                                         or:[
  1648                                         ]
  1762                                         ]
  1649                                 ]) 
  1763                                 ]) 
  1650                                     ifTrue:[ ^ self scan1 ].
  1764                                     ifTrue:[ ^ self scan1 ].
  1651                             (currentCharacter between:$- and:$/) ifTrue:[
  1765                             (currentCharacter between:$- and:$/) ifTrue:[
  1652                                 [
  1766                                 [
  1653                                     self recordMatch:#( 30 ).
  1767                                     self recordMatch:#( 33 ).
  1654                                     self step.
  1768                                     self step.
  1655                                     (currentCharacter isLetterOrDigit 
  1769                                     (currentCharacter isLetterOrDigit 
  1656                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1770                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1657                                 ] whileTrue.
  1771                                 ] whileTrue.
  1658                                 ^ self reportLastMatch
  1772                                 ^ self reportLastMatch
  1659                             ].
  1773                             ].
  1660                             (currentCharacter == $r) ifTrue:[
  1774                             (currentCharacter == $r) ifTrue:[
  1661                                 self recordMatch:#( 27 30 ).
  1775                                 self recordMatch:#( 30 33 ).
  1662                                 self step.
  1776                                 self step.
  1663                                 (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
  1777                                 (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
  1664                                     ^ self scan1
  1778                                     ^ self scan1
  1665                                 ].
  1779                                 ].
  1666                                 (currentCharacter between:$. and:$/) ifTrue:[
  1780                                 (currentCharacter between:$. and:$/) ifTrue:[
  1667                                     [
  1781                                     [
  1668                                         self recordMatch:#( 30 ).
  1782                                         self recordMatch:#( 33 ).
  1669                                         self step.
  1783                                         self step.
  1670                                         (currentCharacter isLetterOrDigit 
  1784                                         (currentCharacter isLetterOrDigit 
  1671                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1785                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1672                                     ] whileTrue.
  1786                                     ] whileTrue.
  1673                                     ^ self reportLastMatch
  1787                                     ^ self reportLastMatch
  1674                                 ].
  1788                                 ].
  1675                                 (currentCharacter == $-) ifTrue:[
  1789                                 (currentCharacter == $-) ifTrue:[
  1676                                     self recordMatch:#( 30 ).
  1790                                     self recordMatch:#( 33 ).
  1677                                     self step.
  1791                                     self step.
  1678                                     ((currentCharacter between:$- and:$9) 
  1792                                     ((currentCharacter between:$- and:$9) 
  1679                                         or:[
  1793                                         or:[
  1680                                             (currentCharacter between:$A and:$Z) 
  1794                                             (currentCharacter between:$A and:$Z) 
  1681                                                 or:[
  1795                                                 or:[
  1686                                                         ]
  1800                                                         ]
  1687                                                 ]
  1801                                                 ]
  1688                                         ]) 
  1802                                         ]) 
  1689                                             ifTrue:[
  1803                                             ifTrue:[
  1690                                                 [
  1804                                                 [
  1691                                                     self recordMatch:#( 30 ).
  1805                                                     self recordMatch:#( 33 ).
  1692                                                     self step.
  1806                                                     self step.
  1693                                                     (currentCharacter isLetterOrDigit 
  1807                                                     (currentCharacter isLetterOrDigit 
  1694                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1808                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1695                                                 ] whileTrue.
  1809                                                 ] whileTrue.
  1696                                                 ^ self reportLastMatch
  1810                                                 ^ self reportLastMatch
  1697                                             ].
  1811                                             ].
  1698                                     (currentCharacter == $t) ifTrue:[
  1812                                     (currentCharacter == $t) ifTrue:[
  1699                                         self recordMatch:#( 30 ).
  1813                                         self recordMatch:#( 33 ).
  1700                                         self step.
  1814                                         self step.
  1701                                         (currentCharacter isXMLDigit 
  1815                                         (currentCharacter isXMLDigit 
  1702                                             or:[
  1816                                             or:[
  1703                                                 (currentCharacter between:$- and:$/) 
  1817                                                 (currentCharacter between:$- and:$/) 
  1704                                                     or:[
  1818                                                     or:[
  1712                                                             ]
  1826                                                             ]
  1713                                                     ]
  1827                                                     ]
  1714                                             ]) 
  1828                                             ]) 
  1715                                                 ifTrue:[
  1829                                                 ifTrue:[
  1716                                                     [
  1830                                                     [
  1717                                                         self recordMatch:#( 30 ).
  1831                                                         self recordMatch:#( 33 ).
  1718                                                         self step.
  1832                                                         self step.
  1719                                                         (currentCharacter isLetterOrDigit 
  1833                                                         (currentCharacter isLetterOrDigit 
  1720                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1834                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1721                                                     ] whileTrue.
  1835                                                     ] whileTrue.
  1722                                                     ^ self reportLastMatch
  1836                                                     ^ self reportLastMatch
  1723                                                 ].
  1837                                                 ].
  1724                                         (currentCharacter == $o) ifTrue:[
  1838                                         (currentCharacter == $o) ifTrue:[
  1725                                             self recordMatch:#( 23 30 ).
  1839                                             self recordMatch:#( 29 33 ).
  1726                                             self step.
  1840                                             self step.
  1727                                             (currentCharacter isLetterOrDigit 
  1841                                             (currentCharacter isLetterOrDigit 
  1728                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
  1842                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
  1729                                                     ifTrue:[
  1843                                                     ifTrue:[
  1730                                                         [
  1844                                                         [
  1731                                                             self recordMatch:#( 30 ).
  1845                                                             self recordMatch:#( 33 ).
  1732                                                             self step.
  1846                                                             self step.
  1733                                                             (currentCharacter isLetterOrDigit 
  1847                                                             (currentCharacter isLetterOrDigit 
  1734                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1848                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
  1735                                                         ] whileTrue.
  1849                                                         ] whileTrue.
  1736                                                         ^ self reportLastMatch
  1850                                                         ^ self reportLastMatch
  1753             ].
  1867             ].
  1754             ^ self reportLastMatch
  1868             ^ self reportLastMatch
  1755         ].
  1869         ].
  1756         ^ self reportLastMatch
  1870         ^ self reportLastMatch
  1757     ].
  1871     ].
       
  1872     (currentCharacter == $s) ifTrue:[
       
  1873         self recordMatch:#( 30 33 ).
       
  1874         self step.
       
  1875         ((currentCharacter between:$0 and:$9) 
       
  1876             or:[
       
  1877                 (currentCharacter between:$A and:$Z) 
       
  1878                     or:[
       
  1879                         currentCharacter == $_ 
       
  1880                             or:[
       
  1881                                 (currentCharacter between:$a and:$s) 
       
  1882                                     or:[ (currentCharacter between:$u and:$z) ]
       
  1883                             ]
       
  1884                     ]
       
  1885             ]) 
       
  1886                 ifTrue:[ ^ self scan1 ].
       
  1887         (currentCharacter between:$- and:$/) ifTrue:[
       
  1888             [
       
  1889                 self recordMatch:#( 33 ).
       
  1890                 self step.
       
  1891                 (currentCharacter isLetterOrDigit 
       
  1892                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1893             ] whileTrue.
       
  1894             ^ self reportLastMatch
       
  1895         ].
       
  1896         (currentCharacter == $t) ifTrue:[
       
  1897             self recordMatch:#( 30 33 ).
       
  1898             self step.
       
  1899             ((currentCharacter between:$0 and:$9) 
       
  1900                 or:[
       
  1901                     (currentCharacter between:$A and:$Z) 
       
  1902                         or:[
       
  1903                             currentCharacter == $_ 
       
  1904                                 or:[
       
  1905                                     (currentCharacter between:$a and:$q) 
       
  1906                                         or:[ (currentCharacter between:$s and:$z) ]
       
  1907                                 ]
       
  1908                         ]
       
  1909                 ]) 
       
  1910                     ifTrue:[ ^ self scan1 ].
       
  1911             (currentCharacter between:$- and:$/) ifTrue:[
       
  1912                 [
       
  1913                     self recordMatch:#( 33 ).
       
  1914                     self step.
       
  1915                     (currentCharacter isLetterOrDigit 
       
  1916                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1917                 ] whileTrue.
       
  1918                 ^ self reportLastMatch
       
  1919             ].
       
  1920             (currentCharacter == $r) ifTrue:[
       
  1921                 self recordMatch:#( 30 33 ).
       
  1922                 self step.
       
  1923                 (currentCharacter isXMLDigit 
       
  1924                     or:[
       
  1925                         (currentCharacter between:$A and:$Z) 
       
  1926                             or:[
       
  1927                                 currentCharacter == $_ 
       
  1928                                     or:[
       
  1929                                         (currentCharacter between:$a and:$t) 
       
  1930                                             or:[ (currentCharacter between:$v and:$z) ]
       
  1931                                     ]
       
  1932                             ]
       
  1933                     ]) 
       
  1934                         ifTrue:[ ^ self scan1 ].
       
  1935                 (currentCharacter between:$- and:$/) ifTrue:[
       
  1936                     [
       
  1937                         self recordMatch:#( 33 ).
       
  1938                         self step.
       
  1939                         (currentCharacter isLetterOrDigit 
       
  1940                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1941                     ] whileTrue.
       
  1942                     ^ self reportLastMatch
       
  1943                 ].
       
  1944                 (currentCharacter == $u) ifTrue:[
       
  1945                     self recordMatch:#( 30 33 ).
       
  1946                     self step.
       
  1947                     ((currentCharacter between:$0 and:$9) 
       
  1948                         or:[
       
  1949                             (currentCharacter between:$A and:$Z) 
       
  1950                                 or:[
       
  1951                                     currentCharacter == $_ 
       
  1952                                         or:[
       
  1953                                             (currentCharacter between:$a and:$b) 
       
  1954                                                 or:[ (currentCharacter between:$d and:$z) ]
       
  1955                                         ]
       
  1956                                 ]
       
  1957                         ]) 
       
  1958                             ifTrue:[ ^ self scan1 ].
       
  1959                     (currentCharacter between:$- and:$/) ifTrue:[
       
  1960                         [
       
  1961                             self recordMatch:#( 33 ).
       
  1962                             self step.
       
  1963                             (currentCharacter isLetterOrDigit 
       
  1964                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1965                         ] whileTrue.
       
  1966                         ^ self reportLastMatch
       
  1967                     ].
       
  1968                     (currentCharacter == $c) ifTrue:[
       
  1969                         self recordMatch:#( 30 33 ).
       
  1970                         self step.
       
  1971                         ((currentCharacter between:$0 and:$9) 
       
  1972                             or:[
       
  1973                                 (currentCharacter between:$A and:$Z) 
       
  1974                                     or:[
       
  1975                                         currentCharacter == $_ 
       
  1976                                             or:[
       
  1977                                                 (currentCharacter between:$a and:$s) 
       
  1978                                                     or:[ (currentCharacter between:$u and:$z) ]
       
  1979                                             ]
       
  1980                                     ]
       
  1981                             ]) 
       
  1982                                 ifTrue:[ ^ self scan1 ].
       
  1983                         (currentCharacter between:$- and:$/) ifTrue:[
       
  1984                             [
       
  1985                                 self recordMatch:#( 33 ).
       
  1986                                 self step.
       
  1987                                 (currentCharacter isLetterOrDigit 
       
  1988                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  1989                             ] whileTrue.
       
  1990                             ^ self reportLastMatch
       
  1991                         ].
       
  1992                         (currentCharacter == $t) ifTrue:[
       
  1993                             self recordMatch:#( 30 33 ).
       
  1994                             self step.
       
  1995                             (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
       
  1996                                 ^ self scan1
       
  1997                             ].
       
  1998                             (currentCharacter between:$. and:$/) ifTrue:[
       
  1999                                 [
       
  2000                                     self recordMatch:#( 33 ).
       
  2001                                     self step.
       
  2002                                     (currentCharacter isLetterOrDigit 
       
  2003                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2004                                 ] whileTrue.
       
  2005                                 ^ self reportLastMatch
       
  2006                             ].
       
  2007                             (currentCharacter == $-) ifTrue:[
       
  2008                                 self recordMatch:#( 33 ).
       
  2009                                 self step.
       
  2010                                 ((currentCharacter between:$- and:$9) 
       
  2011                                     or:[
       
  2012                                         (currentCharacter between:$A and:$Z) 
       
  2013                                             or:[
       
  2014                                                 currentCharacter == $_ 
       
  2015                                                     or:[
       
  2016                                                         (currentCharacter between:$a and:$e) 
       
  2017                                                             or:[ (currentCharacter between:$g and:$z) ]
       
  2018                                                     ]
       
  2019                                             ]
       
  2020                                     ]) 
       
  2021                                         ifTrue:[
       
  2022                                             [
       
  2023                                                 self recordMatch:#( 33 ).
       
  2024                                                 self step.
       
  2025                                                 (currentCharacter isLetterOrDigit 
       
  2026                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2027                                             ] whileTrue.
       
  2028                                             ^ self reportLastMatch
       
  2029                                         ].
       
  2030                                 (currentCharacter == $f) ifTrue:[
       
  2031                                     self recordMatch:#( 33 ).
       
  2032                                     self step.
       
  2033                                     (currentCharacter isXMLDigit 
       
  2034                                         or:[
       
  2035                                             (currentCharacter between:$- and:$/) 
       
  2036                                                 or:[
       
  2037                                                     (currentCharacter between:$A and:$Z) 
       
  2038                                                         or:[
       
  2039                                                             currentCharacter == $_ 
       
  2040                                                                 or:[
       
  2041                                                                     (currentCharacter between:$a and:$n) 
       
  2042                                                                         or:[ (currentCharacter between:$p and:$z) ]
       
  2043                                                                 ]
       
  2044                                                         ]
       
  2045                                                 ]
       
  2046                                         ]) 
       
  2047                                             ifTrue:[
       
  2048                                                 [
       
  2049                                                     self recordMatch:#( 33 ).
       
  2050                                                     self step.
       
  2051                                                     (currentCharacter isLetterOrDigit 
       
  2052                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2053                                                 ] whileTrue.
       
  2054                                                 ^ self reportLastMatch
       
  2055                                             ].
       
  2056                                     (currentCharacter == $o) ifTrue:[
       
  2057                                         self recordMatch:#( 33 ).
       
  2058                                         self step.
       
  2059                                         ((currentCharacter between:$- and:$9) 
       
  2060                                             or:[
       
  2061                                                 (currentCharacter between:$A and:$Z) 
       
  2062                                                     or:[
       
  2063                                                         currentCharacter == $_ 
       
  2064                                                             or:[
       
  2065                                                                 (currentCharacter between:$a and:$q) 
       
  2066                                                                     or:[ (currentCharacter between:$s and:$z) ]
       
  2067                                                             ]
       
  2068                                                     ]
       
  2069                                             ]) 
       
  2070                                                 ifTrue:[
       
  2071                                                     [
       
  2072                                                         self recordMatch:#( 33 ).
       
  2073                                                         self step.
       
  2074                                                         (currentCharacter isLetterOrDigit 
       
  2075                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2076                                                     ] whileTrue.
       
  2077                                                     ^ self reportLastMatch
       
  2078                                                 ].
       
  2079                                         (currentCharacter == $r) ifTrue:[
       
  2080                                             self recordMatch:#( 33 ).
       
  2081                                             self step.
       
  2082                                             (currentCharacter isXMLDigit 
       
  2083                                                 or:[
       
  2084                                                     (currentCharacter between:$- and:$/) 
       
  2085                                                         or:[
       
  2086                                                             (currentCharacter between:$A and:$Z) 
       
  2087                                                                 or:[
       
  2088                                                                     currentCharacter == $_ 
       
  2089                                                                         or:[
       
  2090                                                                             (currentCharacter between:$a and:$d) 
       
  2091                                                                                 or:[ (currentCharacter between:$f and:$z) ]
       
  2092                                                                         ]
       
  2093                                                                 ]
       
  2094                                                         ]
       
  2095                                                 ]) 
       
  2096                                                     ifTrue:[
       
  2097                                                         [
       
  2098                                                             self recordMatch:#( 33 ).
       
  2099                                                             self step.
       
  2100                                                             (currentCharacter isLetterOrDigit 
       
  2101                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2102                                                         ] whileTrue.
       
  2103                                                         ^ self reportLastMatch
       
  2104                                                     ].
       
  2105                                             (currentCharacter == $e) ifTrue:[
       
  2106                                                 self recordMatch:#( 33 ).
       
  2107                                                 self step.
       
  2108                                                 (currentCharacter isXMLDigit 
       
  2109                                                     or:[
       
  2110                                                         (currentCharacter between:$- and:$/) 
       
  2111                                                             or:[
       
  2112                                                                 (currentCharacter between:$A and:$Z) 
       
  2113                                                                     or:[
       
  2114                                                                         currentCharacter == $_ 
       
  2115                                                                             or:[
       
  2116                                                                                 (currentCharacter between:$a and:$h) 
       
  2117                                                                                     or:[ (currentCharacter between:$j and:$z) ]
       
  2118                                                                             ]
       
  2119                                                                     ]
       
  2120                                                             ]
       
  2121                                                     ]) 
       
  2122                                                         ifTrue:[
       
  2123                                                             [
       
  2124                                                                 self recordMatch:#( 33 ).
       
  2125                                                                 self step.
       
  2126                                                                 (currentCharacter isLetterOrDigit 
       
  2127                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2128                                                             ] whileTrue.
       
  2129                                                             ^ self reportLastMatch
       
  2130                                                         ].
       
  2131                                                 (currentCharacter == $i) ifTrue:[
       
  2132                                                     self recordMatch:#( 33 ).
       
  2133                                                     self step.
       
  2134                                                     ((currentCharacter between:$- and:$9) 
       
  2135                                                         or:[
       
  2136                                                             (currentCharacter between:$A and:$Z) 
       
  2137                                                                 or:[
       
  2138                                                                     currentCharacter == $_ 
       
  2139                                                                         or:[
       
  2140                                                                             (currentCharacter between:$a and:$f) 
       
  2141                                                                                 or:[ (currentCharacter between:$h and:$z) ]
       
  2142                                                                         ]
       
  2143                                                                 ]
       
  2144                                                         ]) 
       
  2145                                                             ifTrue:[
       
  2146                                                                 [
       
  2147                                                                     self recordMatch:#( 33 ).
       
  2148                                                                     self step.
       
  2149                                                                     (currentCharacter isLetterOrDigit 
       
  2150                                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2151                                                                 ] whileTrue.
       
  2152                                                                 ^ self reportLastMatch
       
  2153                                                             ].
       
  2154                                                     (currentCharacter == $g) ifTrue:[
       
  2155                                                         self recordMatch:#( 33 ).
       
  2156                                                         self step.
       
  2157                                                         ((currentCharacter between:$- and:$9) 
       
  2158                                                             or:[
       
  2159                                                                 (currentCharacter between:$A and:$Z) 
       
  2160                                                                     or:[
       
  2161                                                                         currentCharacter == $_ 
       
  2162                                                                             or:[
       
  2163                                                                                 (currentCharacter between:$a and:$m) 
       
  2164                                                                                     or:[ (currentCharacter between:$o and:$z) ]
       
  2165                                                                             ]
       
  2166                                                                     ]
       
  2167                                                             ]) 
       
  2168                                                                 ifTrue:[
       
  2169                                                                     [
       
  2170                                                                         self recordMatch:#( 33 ).
       
  2171                                                                         self step.
       
  2172                                                                         (currentCharacter isLetterOrDigit 
       
  2173                                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2174                                                                     ] whileTrue.
       
  2175                                                                     ^ self reportLastMatch
       
  2176                                                                 ].
       
  2177                                                         (currentCharacter == $n) ifTrue:[
       
  2178                                                             self recordMatch:#( 27 33 ).
       
  2179                                                             self step.
       
  2180                                                             (currentCharacter isLetterOrDigit 
       
  2181                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
       
  2182                                                                     ifTrue:[
       
  2183                                                                         [
       
  2184                                                                             self recordMatch:#( 33 ).
       
  2185                                                                             self step.
       
  2186                                                                             (currentCharacter isLetterOrDigit 
       
  2187                                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2188                                                                         ] whileTrue.
       
  2189                                                                         ^ self reportLastMatch
       
  2190                                                                     ].
       
  2191                                                             ^ self reportLastMatch
       
  2192                                                         ].
       
  2193                                                         ^ self reportLastMatch
       
  2194                                                     ].
       
  2195                                                     ^ self reportLastMatch
       
  2196                                                 ].
       
  2197                                                 ^ self reportLastMatch
       
  2198                                             ].
       
  2199                                             ^ self reportLastMatch
       
  2200                                         ].
       
  2201                                         ^ self reportLastMatch
       
  2202                                     ].
       
  2203                                     ^ self reportLastMatch
       
  2204                                 ].
       
  2205                                 ^ self reportLastMatch
       
  2206                             ].
       
  2207                             ^ self reportLastMatch
       
  2208                         ].
       
  2209                         ^ self reportLastMatch
       
  2210                     ].
       
  2211                     ^ self reportLastMatch
       
  2212                 ].
       
  2213                 ^ self reportLastMatch
       
  2214             ].
       
  2215             ^ self reportLastMatch
       
  2216         ].
       
  2217         ^ self reportLastMatch
       
  2218     ].
       
  2219     (currentCharacter == $t) ifTrue:[
       
  2220         self recordMatch:#( 30 33 ).
       
  2221         self step.
       
  2222         ((currentCharacter between:$0 and:$9) 
       
  2223             or:[
       
  2224                 (currentCharacter between:$A and:$Z) 
       
  2225                     or:[
       
  2226                         currentCharacter == $_ 
       
  2227                             or:[ (currentCharacter between:$a and:$x) or:[ currentCharacter == $z ] ]
       
  2228                     ]
       
  2229             ]) 
       
  2230                 ifTrue:[ ^ self scan1 ].
       
  2231         (currentCharacter between:$- and:$/) ifTrue:[
       
  2232             [
       
  2233                 self recordMatch:#( 33 ).
       
  2234                 self step.
       
  2235                 (currentCharacter isLetterOrDigit 
       
  2236                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2237             ] whileTrue.
       
  2238             ^ self reportLastMatch
       
  2239         ].
       
  2240         (currentCharacter == $y) ifTrue:[
       
  2241             self recordMatch:#( 30 33 ).
       
  2242             self step.
       
  2243             ((currentCharacter between:$0 and:$9) 
       
  2244                 or:[
       
  2245                     (currentCharacter between:$A and:$Z) 
       
  2246                         or:[
       
  2247                             currentCharacter == $_ 
       
  2248                                 or:[
       
  2249                                     (currentCharacter between:$a and:$o) 
       
  2250                                         or:[ (currentCharacter between:$q and:$z) ]
       
  2251                                 ]
       
  2252                         ]
       
  2253                 ]) 
       
  2254                     ifTrue:[ ^ self scan1 ].
       
  2255             (currentCharacter between:$- and:$/) ifTrue:[
       
  2256                 [
       
  2257                     self recordMatch:#( 33 ).
       
  2258                     self step.
       
  2259                     (currentCharacter isLetterOrDigit 
       
  2260                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2261                 ] whileTrue.
       
  2262                 ^ self reportLastMatch
       
  2263             ].
       
  2264             (currentCharacter == $p) ifTrue:[
       
  2265                 self recordMatch:#( 30 33 ).
       
  2266                 self step.
       
  2267                 (currentCharacter isXMLDigit 
       
  2268                     or:[
       
  2269                         (currentCharacter between:$A and:$Z) 
       
  2270                             or:[
       
  2271                                 currentCharacter == $_ 
       
  2272                                     or:[
       
  2273                                         (currentCharacter between:$a and:$d) 
       
  2274                                             or:[ (currentCharacter between:$f and:$z) ]
       
  2275                                     ]
       
  2276                             ]
       
  2277                     ]) 
       
  2278                         ifTrue:[ ^ self scan1 ].
       
  2279                 (currentCharacter between:$- and:$/) ifTrue:[
       
  2280                     [
       
  2281                         self recordMatch:#( 33 ).
       
  2282                         self step.
       
  2283                         (currentCharacter isLetterOrDigit 
       
  2284                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2285                     ] whileTrue.
       
  2286                     ^ self reportLastMatch
       
  2287                 ].
       
  2288                 (currentCharacter == $e) ifTrue:[
       
  2289                     self recordMatch:#( 30 33 ).
       
  2290                     self step.
       
  2291                     ((currentCharacter between:$0 and:$9) 
       
  2292                         or:[
       
  2293                             (currentCharacter between:$A and:$Z) 
       
  2294                                 or:[
       
  2295                                     currentCharacter == $_ 
       
  2296                                         or:[
       
  2297                                             (currentCharacter between:$a and:$c) 
       
  2298                                                 or:[ (currentCharacter between:$e and:$z) ]
       
  2299                                         ]
       
  2300                                 ]
       
  2301                         ]) 
       
  2302                             ifTrue:[ ^ self scan1 ].
       
  2303                     (currentCharacter between:$- and:$/) ifTrue:[
       
  2304                         [
       
  2305                             self recordMatch:#( 33 ).
       
  2306                             self step.
       
  2307                             (currentCharacter isLetterOrDigit 
       
  2308                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2309                         ] whileTrue.
       
  2310                         ^ self reportLastMatch
       
  2311                     ].
       
  2312                     (currentCharacter == $d) ifTrue:[
       
  2313                         self recordMatch:#( 30 33 ).
       
  2314                         self step.
       
  2315                         (currentCharacter isXMLDigit 
       
  2316                             or:[
       
  2317                                 (currentCharacter between:$A and:$Z) 
       
  2318                                     or:[
       
  2319                                         currentCharacter == $_ 
       
  2320                                             or:[
       
  2321                                                 (currentCharacter between:$a and:$d) 
       
  2322                                                     or:[ (currentCharacter between:$f and:$z) ]
       
  2323                                             ]
       
  2324                                     ]
       
  2325                             ]) 
       
  2326                                 ifTrue:[ ^ self scan1 ].
       
  2327                         (currentCharacter between:$- and:$/) ifTrue:[
       
  2328                             [
       
  2329                                 self recordMatch:#( 33 ).
       
  2330                                 self step.
       
  2331                                 (currentCharacter isLetterOrDigit 
       
  2332                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2333                             ] whileTrue.
       
  2334                             ^ self reportLastMatch
       
  2335                         ].
       
  2336                         (currentCharacter == $e) ifTrue:[
       
  2337                             self recordMatch:#( 30 33 ).
       
  2338                             self step.
       
  2339                             ((currentCharacter between:$0 and:$9) 
       
  2340                                 or:[
       
  2341                                     (currentCharacter between:$A and:$Z) 
       
  2342                                         or:[
       
  2343                                             currentCharacter == $_ 
       
  2344                                                 or:[
       
  2345                                                     (currentCharacter between:$a and:$e) 
       
  2346                                                         or:[ (currentCharacter between:$g and:$z) ]
       
  2347                                                 ]
       
  2348                                         ]
       
  2349                                 ]) 
       
  2350                                     ifTrue:[ ^ self scan1 ].
       
  2351                             (currentCharacter between:$- and:$/) ifTrue:[
       
  2352                                 [
       
  2353                                     self recordMatch:#( 33 ).
       
  2354                                     self step.
       
  2355                                     (currentCharacter isLetterOrDigit 
       
  2356                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2357                                 ] whileTrue.
       
  2358                                 ^ self reportLastMatch
       
  2359                             ].
       
  2360                             (currentCharacter == $f) ifTrue:[
       
  2361                                 self recordMatch:#( 30 33 ).
       
  2362                                 self step.
       
  2363                                 (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
       
  2364                                     ^ self scan1
       
  2365                                 ].
       
  2366                                 (currentCharacter between:$. and:$/) ifTrue:[
       
  2367                                     [
       
  2368                                         self recordMatch:#( 33 ).
       
  2369                                         self step.
       
  2370                                         (currentCharacter isLetterOrDigit 
       
  2371                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2372                                     ] whileTrue.
       
  2373                                     ^ self reportLastMatch
       
  2374                                 ].
       
  2375                                 (currentCharacter == $-) ifTrue:[
       
  2376                                     self recordMatch:#( 33 ).
       
  2377                                     self step.
       
  2378                                     ((currentCharacter between:$- and:$9) 
       
  2379                                         or:[
       
  2380                                             (currentCharacter between:$A and:$Z) 
       
  2381                                                 or:[
       
  2382                                                     currentCharacter == $_ 
       
  2383                                                         or:[
       
  2384                                                             (currentCharacter between:$a and:$e) 
       
  2385                                                                 or:[ (currentCharacter between:$g and:$z) ]
       
  2386                                                         ]
       
  2387                                                 ]
       
  2388                                         ]) 
       
  2389                                             ifTrue:[
       
  2390                                                 [
       
  2391                                                     self recordMatch:#( 33 ).
       
  2392                                                     self step.
       
  2393                                                     (currentCharacter isLetterOrDigit 
       
  2394                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2395                                                 ] whileTrue.
       
  2396                                                 ^ self reportLastMatch
       
  2397                                             ].
       
  2398                                     (currentCharacter == $f) ifTrue:[
       
  2399                                         self recordMatch:#( 33 ).
       
  2400                                         self step.
       
  2401                                         (currentCharacter isXMLDigit 
       
  2402                                             or:[
       
  2403                                                 (currentCharacter between:$- and:$/) 
       
  2404                                                     or:[
       
  2405                                                         (currentCharacter between:$A and:$Z) 
       
  2406                                                             or:[
       
  2407                                                                 currentCharacter == $_ 
       
  2408                                                                     or:[
       
  2409                                                                         (currentCharacter between:$a and:$n) 
       
  2410                                                                             or:[ (currentCharacter between:$p and:$z) ]
       
  2411                                                                     ]
       
  2412                                                             ]
       
  2413                                                     ]
       
  2414                                             ]) 
       
  2415                                                 ifTrue:[
       
  2416                                                     [
       
  2417                                                         self recordMatch:#( 33 ).
       
  2418                                                         self step.
       
  2419                                                         (currentCharacter isLetterOrDigit 
       
  2420                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2421                                                     ] whileTrue.
       
  2422                                                     ^ self reportLastMatch
       
  2423                                                 ].
       
  2424                                         (currentCharacter == $o) ifTrue:[
       
  2425                                             self recordMatch:#( 33 ).
       
  2426                                             self step.
       
  2427                                             ((currentCharacter between:$- and:$9) 
       
  2428                                                 or:[
       
  2429                                                     (currentCharacter between:$A and:$Z) 
       
  2430                                                         or:[
       
  2431                                                             currentCharacter == $_ 
       
  2432                                                                 or:[
       
  2433                                                                     (currentCharacter between:$a and:$q) 
       
  2434                                                                         or:[ (currentCharacter between:$s and:$z) ]
       
  2435                                                                 ]
       
  2436                                                         ]
       
  2437                                                 ]) 
       
  2438                                                     ifTrue:[
       
  2439                                                         [
       
  2440                                                             self recordMatch:#( 33 ).
       
  2441                                                             self step.
       
  2442                                                             (currentCharacter isLetterOrDigit 
       
  2443                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2444                                                         ] whileTrue.
       
  2445                                                         ^ self reportLastMatch
       
  2446                                                     ].
       
  2447                                             (currentCharacter == $r) ifTrue:[
       
  2448                                                 self recordMatch:#( 33 ).
       
  2449                                                 self step.
       
  2450                                                 (currentCharacter isXMLDigit 
       
  2451                                                     or:[
       
  2452                                                         (currentCharacter between:$- and:$/) 
       
  2453                                                             or:[
       
  2454                                                                 (currentCharacter between:$A and:$Z) 
       
  2455                                                                     or:[
       
  2456                                                                         currentCharacter == $_ 
       
  2457                                                                             or:[
       
  2458                                                                                 (currentCharacter between:$a and:$d) 
       
  2459                                                                                     or:[ (currentCharacter between:$f and:$z) ]
       
  2460                                                                             ]
       
  2461                                                                     ]
       
  2462                                                             ]
       
  2463                                                     ]) 
       
  2464                                                         ifTrue:[
       
  2465                                                             [
       
  2466                                                                 self recordMatch:#( 33 ).
       
  2467                                                                 self step.
       
  2468                                                                 (currentCharacter isLetterOrDigit 
       
  2469                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2470                                                             ] whileTrue.
       
  2471                                                             ^ self reportLastMatch
       
  2472                                                         ].
       
  2473                                                 (currentCharacter == $e) ifTrue:[
       
  2474                                                     self recordMatch:#( 33 ).
       
  2475                                                     self step.
       
  2476                                                     (currentCharacter isXMLDigit 
       
  2477                                                         or:[
       
  2478                                                             (currentCharacter between:$- and:$/) 
       
  2479                                                                 or:[
       
  2480                                                                     (currentCharacter between:$A and:$Z) 
       
  2481                                                                         or:[
       
  2482                                                                             currentCharacter == $_ 
       
  2483                                                                                 or:[
       
  2484                                                                                     (currentCharacter between:$a and:$h) 
       
  2485                                                                                         or:[ (currentCharacter between:$j and:$z) ]
       
  2486                                                                                 ]
       
  2487                                                                         ]
       
  2488                                                                 ]
       
  2489                                                         ]) 
       
  2490                                                             ifTrue:[
       
  2491                                                                 [
       
  2492                                                                     self recordMatch:#( 33 ).
       
  2493                                                                     self step.
       
  2494                                                                     (currentCharacter isLetterOrDigit 
       
  2495                                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2496                                                                 ] whileTrue.
       
  2497                                                                 ^ self reportLastMatch
       
  2498                                                             ].
       
  2499                                                     (currentCharacter == $i) ifTrue:[
       
  2500                                                         self recordMatch:#( 33 ).
       
  2501                                                         self step.
       
  2502                                                         ((currentCharacter between:$- and:$9) 
       
  2503                                                             or:[
       
  2504                                                                 (currentCharacter between:$A and:$Z) 
       
  2505                                                                     or:[
       
  2506                                                                         currentCharacter == $_ 
       
  2507                                                                             or:[
       
  2508                                                                                 (currentCharacter between:$a and:$f) 
       
  2509                                                                                     or:[ (currentCharacter between:$h and:$z) ]
       
  2510                                                                             ]
       
  2511                                                                     ]
       
  2512                                                             ]) 
       
  2513                                                                 ifTrue:[
       
  2514                                                                     [
       
  2515                                                                         self recordMatch:#( 33 ).
       
  2516                                                                         self step.
       
  2517                                                                         (currentCharacter isLetterOrDigit 
       
  2518                                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2519                                                                     ] whileTrue.
       
  2520                                                                     ^ self reportLastMatch
       
  2521                                                                 ].
       
  2522                                                         (currentCharacter == $g) ifTrue:[
       
  2523                                                             self recordMatch:#( 33 ).
       
  2524                                                             self step.
       
  2525                                                             ((currentCharacter between:$- and:$9) 
       
  2526                                                                 or:[
       
  2527                                                                     (currentCharacter between:$A and:$Z) 
       
  2528                                                                         or:[
       
  2529                                                                             currentCharacter == $_ 
       
  2530                                                                                 or:[
       
  2531                                                                                     (currentCharacter between:$a and:$m) 
       
  2532                                                                                         or:[ (currentCharacter between:$o and:$z) ]
       
  2533                                                                                 ]
       
  2534                                                                         ]
       
  2535                                                                 ]) 
       
  2536                                                                     ifTrue:[
       
  2537                                                                         [
       
  2538                                                                             self recordMatch:#( 33 ).
       
  2539                                                                             self step.
       
  2540                                                                             (currentCharacter isLetterOrDigit 
       
  2541                                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2542                                                                         ] whileTrue.
       
  2543                                                                         ^ self reportLastMatch
       
  2544                                                                     ].
       
  2545                                                             (currentCharacter == $n) ifTrue:[
       
  2546                                                                 self recordMatch:#( 8 33 ).
       
  2547                                                                 self step.
       
  2548                                                                 (currentCharacter isLetterOrDigit 
       
  2549                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
       
  2550                                                                         ifTrue:[
       
  2551                                                                             [
       
  2552                                                                                 self recordMatch:#( 33 ).
       
  2553                                                                                 self step.
       
  2554                                                                                 (currentCharacter isLetterOrDigit 
       
  2555                                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2556                                                                             ] whileTrue.
       
  2557                                                                             ^ self reportLastMatch
       
  2558                                                                         ].
       
  2559                                                                 ^ self reportLastMatch
       
  2560                                                             ].
       
  2561                                                             ^ self reportLastMatch
       
  2562                                                         ].
       
  2563                                                         ^ self reportLastMatch
       
  2564                                                     ].
       
  2565                                                     ^ self reportLastMatch
       
  2566                                                 ].
       
  2567                                                 ^ self reportLastMatch
       
  2568                                             ].
       
  2569                                             ^ self reportLastMatch
       
  2570                                         ].
       
  2571                                         ^ self reportLastMatch
       
  2572                                     ].
       
  2573                                     ^ self reportLastMatch
       
  2574                                 ].
       
  2575                                 ^ self reportLastMatch
       
  2576                             ].
       
  2577                             ^ self reportLastMatch
       
  2578                         ].
       
  2579                         ^ self reportLastMatch
       
  2580                     ].
       
  2581                     ^ self reportLastMatch
       
  2582                 ].
       
  2583                 ^ self reportLastMatch
       
  2584             ].
       
  2585             ^ self reportLastMatch
       
  2586         ].
       
  2587         ^ self reportLastMatch
       
  2588     ].
       
  2589     (currentCharacter == $u) ifTrue:[
       
  2590         self recordMatch:#( 30 33 ).
       
  2591         self step.
       
  2592         ((currentCharacter between:$0 and:$9) 
       
  2593             or:[
       
  2594                 (currentCharacter between:$A and:$Z) 
       
  2595                     or:[
       
  2596                         currentCharacter == $_ 
       
  2597                             or:[
       
  2598                                 (currentCharacter between:$a and:$m) 
       
  2599                                     or:[ (currentCharacter between:$o and:$z) ]
       
  2600                             ]
       
  2601                     ]
       
  2602             ]) 
       
  2603                 ifTrue:[ ^ self scan1 ].
       
  2604         (currentCharacter between:$- and:$/) ifTrue:[
       
  2605             [
       
  2606                 self recordMatch:#( 33 ).
       
  2607                 self step.
       
  2608                 (currentCharacter isLetterOrDigit 
       
  2609                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2610             ] whileTrue.
       
  2611             ^ self reportLastMatch
       
  2612         ].
       
  2613         (currentCharacter == $n) ifTrue:[
       
  2614             self recordMatch:#( 30 33 ).
       
  2615             self step.
       
  2616             (currentCharacter isXMLDigit 
       
  2617                 or:[
       
  2618                     (currentCharacter between:$A and:$Z) 
       
  2619                         or:[
       
  2620                             currentCharacter == $_ 
       
  2621                                 or:[
       
  2622                                     (currentCharacter between:$a and:$h) 
       
  2623                                         or:[ (currentCharacter between:$j and:$z) ]
       
  2624                                 ]
       
  2625                         ]
       
  2626                 ]) 
       
  2627                     ifTrue:[ ^ self scan1 ].
       
  2628             (currentCharacter between:$- and:$/) ifTrue:[
       
  2629                 [
       
  2630                     self recordMatch:#( 33 ).
       
  2631                     self step.
       
  2632                     (currentCharacter isLetterOrDigit 
       
  2633                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2634                 ] whileTrue.
       
  2635                 ^ self reportLastMatch
       
  2636             ].
       
  2637             (currentCharacter == $i) ifTrue:[
       
  2638                 self recordMatch:#( 30 33 ).
       
  2639                 self step.
       
  2640                 (currentCharacter isXMLDigit 
       
  2641                     or:[
       
  2642                         (currentCharacter between:$A and:$Z) 
       
  2643                             or:[
       
  2644                                 currentCharacter == $_ 
       
  2645                                     or:[
       
  2646                                         (currentCharacter between:$a and:$n) 
       
  2647                                             or:[ (currentCharacter between:$p and:$z) ]
       
  2648                                     ]
       
  2649                             ]
       
  2650                     ]) 
       
  2651                         ifTrue:[ ^ self scan1 ].
       
  2652                 (currentCharacter between:$- and:$/) ifTrue:[
       
  2653                     [
       
  2654                         self recordMatch:#( 33 ).
       
  2655                         self step.
       
  2656                         (currentCharacter isLetterOrDigit 
       
  2657                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2658                     ] whileTrue.
       
  2659                     ^ self reportLastMatch
       
  2660                 ].
       
  2661                 (currentCharacter == $o) ifTrue:[
       
  2662                     self recordMatch:#( 30 33 ).
       
  2663                     self step.
       
  2664                     ((currentCharacter between:$0 and:$9) 
       
  2665                         or:[
       
  2666                             (currentCharacter between:$A and:$Z) 
       
  2667                                 or:[
       
  2668                                     currentCharacter == $_ 
       
  2669                                         or:[
       
  2670                                             (currentCharacter between:$a and:$m) 
       
  2671                                                 or:[ (currentCharacter between:$o and:$z) ]
       
  2672                                         ]
       
  2673                                 ]
       
  2674                         ]) 
       
  2675                             ifTrue:[ ^ self scan1 ].
       
  2676                     (currentCharacter between:$- and:$/) ifTrue:[
       
  2677                         [
       
  2678                             self recordMatch:#( 33 ).
       
  2679                             self step.
       
  2680                             (currentCharacter isLetterOrDigit 
       
  2681                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2682                         ] whileTrue.
       
  2683                         ^ self reportLastMatch
       
  2684                     ].
       
  2685                     (currentCharacter == $n) ifTrue:[
       
  2686                         self recordMatch:#( 30 33 ).
       
  2687                         self step.
       
  2688                         (currentCharacter isLetterOrDigit or:[ currentCharacter == $_ ]) ifTrue:[
       
  2689                             ^ self scan1
       
  2690                         ].
       
  2691                         (currentCharacter between:$. and:$/) ifTrue:[
       
  2692                             [
       
  2693                                 self recordMatch:#( 33 ).
       
  2694                                 self step.
       
  2695                                 (currentCharacter isLetterOrDigit 
       
  2696                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2697                             ] whileTrue.
       
  2698                             ^ self reportLastMatch
       
  2699                         ].
       
  2700                         (currentCharacter == $-) ifTrue:[
       
  2701                             self recordMatch:#( 33 ).
       
  2702                             self step.
       
  2703                             ((currentCharacter between:$- and:$9) 
       
  2704                                 or:[
       
  2705                                     (currentCharacter between:$A and:$Z) 
       
  2706                                         or:[
       
  2707                                             currentCharacter == $_ 
       
  2708                                                 or:[
       
  2709                                                     (currentCharacter between:$a and:$e) 
       
  2710                                                         or:[ (currentCharacter between:$g and:$z) ]
       
  2711                                                 ]
       
  2712                                         ]
       
  2713                                 ]) 
       
  2714                                     ifTrue:[
       
  2715                                         [
       
  2716                                             self recordMatch:#( 33 ).
       
  2717                                             self step.
       
  2718                                             (currentCharacter isLetterOrDigit 
       
  2719                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2720                                         ] whileTrue.
       
  2721                                         ^ self reportLastMatch
       
  2722                                     ].
       
  2723                             (currentCharacter == $f) ifTrue:[
       
  2724                                 self recordMatch:#( 33 ).
       
  2725                                 self step.
       
  2726                                 (currentCharacter isXMLDigit 
       
  2727                                     or:[
       
  2728                                         (currentCharacter between:$- and:$/) 
       
  2729                                             or:[
       
  2730                                                 (currentCharacter between:$A and:$Z) 
       
  2731                                                     or:[
       
  2732                                                         currentCharacter == $_ 
       
  2733                                                             or:[
       
  2734                                                                 (currentCharacter between:$a and:$n) 
       
  2735                                                                     or:[ (currentCharacter between:$p and:$z) ]
       
  2736                                                             ]
       
  2737                                                     ]
       
  2738                                             ]
       
  2739                                     ]) 
       
  2740                                         ifTrue:[
       
  2741                                             [
       
  2742                                                 self recordMatch:#( 33 ).
       
  2743                                                 self step.
       
  2744                                                 (currentCharacter isLetterOrDigit 
       
  2745                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2746                                             ] whileTrue.
       
  2747                                             ^ self reportLastMatch
       
  2748                                         ].
       
  2749                                 (currentCharacter == $o) ifTrue:[
       
  2750                                     self recordMatch:#( 33 ).
       
  2751                                     self step.
       
  2752                                     ((currentCharacter between:$- and:$9) 
       
  2753                                         or:[
       
  2754                                             (currentCharacter between:$A and:$Z) 
       
  2755                                                 or:[
       
  2756                                                     currentCharacter == $_ 
       
  2757                                                         or:[
       
  2758                                                             (currentCharacter between:$a and:$q) 
       
  2759                                                                 or:[ (currentCharacter between:$s and:$z) ]
       
  2760                                                         ]
       
  2761                                                 ]
       
  2762                                         ]) 
       
  2763                                             ifTrue:[
       
  2764                                                 [
       
  2765                                                     self recordMatch:#( 33 ).
       
  2766                                                     self step.
       
  2767                                                     (currentCharacter isLetterOrDigit 
       
  2768                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2769                                                 ] whileTrue.
       
  2770                                                 ^ self reportLastMatch
       
  2771                                             ].
       
  2772                                     (currentCharacter == $r) ifTrue:[
       
  2773                                         self recordMatch:#( 33 ).
       
  2774                                         self step.
       
  2775                                         (currentCharacter isXMLDigit 
       
  2776                                             or:[
       
  2777                                                 (currentCharacter between:$- and:$/) 
       
  2778                                                     or:[
       
  2779                                                         (currentCharacter between:$A and:$Z) 
       
  2780                                                             or:[
       
  2781                                                                 currentCharacter == $_ 
       
  2782                                                                     or:[
       
  2783                                                                         (currentCharacter between:$a and:$d) 
       
  2784                                                                             or:[ (currentCharacter between:$f and:$z) ]
       
  2785                                                                     ]
       
  2786                                                             ]
       
  2787                                                     ]
       
  2788                                             ]) 
       
  2789                                                 ifTrue:[
       
  2790                                                     [
       
  2791                                                         self recordMatch:#( 33 ).
       
  2792                                                         self step.
       
  2793                                                         (currentCharacter isLetterOrDigit 
       
  2794                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2795                                                     ] whileTrue.
       
  2796                                                     ^ self reportLastMatch
       
  2797                                                 ].
       
  2798                                         (currentCharacter == $e) ifTrue:[
       
  2799                                             self recordMatch:#( 33 ).
       
  2800                                             self step.
       
  2801                                             (currentCharacter isXMLDigit 
       
  2802                                                 or:[
       
  2803                                                     (currentCharacter between:$- and:$/) 
       
  2804                                                         or:[
       
  2805                                                             (currentCharacter between:$A and:$Z) 
       
  2806                                                                 or:[
       
  2807                                                                     currentCharacter == $_ 
       
  2808                                                                         or:[
       
  2809                                                                             (currentCharacter between:$a and:$h) 
       
  2810                                                                                 or:[ (currentCharacter between:$j and:$z) ]
       
  2811                                                                         ]
       
  2812                                                                 ]
       
  2813                                                         ]
       
  2814                                                 ]) 
       
  2815                                                     ifTrue:[
       
  2816                                                         [
       
  2817                                                             self recordMatch:#( 33 ).
       
  2818                                                             self step.
       
  2819                                                             (currentCharacter isLetterOrDigit 
       
  2820                                                                 or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2821                                                         ] whileTrue.
       
  2822                                                         ^ self reportLastMatch
       
  2823                                                     ].
       
  2824                                             (currentCharacter == $i) ifTrue:[
       
  2825                                                 self recordMatch:#( 33 ).
       
  2826                                                 self step.
       
  2827                                                 ((currentCharacter between:$- and:$9) 
       
  2828                                                     or:[
       
  2829                                                         (currentCharacter between:$A and:$Z) 
       
  2830                                                             or:[
       
  2831                                                                 currentCharacter == $_ 
       
  2832                                                                     or:[
       
  2833                                                                         (currentCharacter between:$a and:$f) 
       
  2834                                                                             or:[ (currentCharacter between:$h and:$z) ]
       
  2835                                                                     ]
       
  2836                                                             ]
       
  2837                                                     ]) 
       
  2838                                                         ifTrue:[
       
  2839                                                             [
       
  2840                                                                 self recordMatch:#( 33 ).
       
  2841                                                                 self step.
       
  2842                                                                 (currentCharacter isLetterOrDigit 
       
  2843                                                                     or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2844                                                             ] whileTrue.
       
  2845                                                             ^ self reportLastMatch
       
  2846                                                         ].
       
  2847                                                 (currentCharacter == $g) ifTrue:[
       
  2848                                                     self recordMatch:#( 33 ).
       
  2849                                                     self step.
       
  2850                                                     ((currentCharacter between:$- and:$9) 
       
  2851                                                         or:[
       
  2852                                                             (currentCharacter between:$A and:$Z) 
       
  2853                                                                 or:[
       
  2854                                                                     currentCharacter == $_ 
       
  2855                                                                         or:[
       
  2856                                                                             (currentCharacter between:$a and:$m) 
       
  2857                                                                                 or:[ (currentCharacter between:$o and:$z) ]
       
  2858                                                                         ]
       
  2859                                                                 ]
       
  2860                                                         ]) 
       
  2861                                                             ifTrue:[
       
  2862                                                                 [
       
  2863                                                                     self recordMatch:#( 33 ).
       
  2864                                                                     self step.
       
  2865                                                                     (currentCharacter isLetterOrDigit 
       
  2866                                                                         or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2867                                                                 ] whileTrue.
       
  2868                                                                 ^ self reportLastMatch
       
  2869                                                             ].
       
  2870                                                     (currentCharacter == $n) ifTrue:[
       
  2871                                                         self recordMatch:#( 19 33 ).
       
  2872                                                         self step.
       
  2873                                                         (currentCharacter isLetterOrDigit 
       
  2874                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ]) 
       
  2875                                                                 ifTrue:[
       
  2876                                                                     [
       
  2877                                                                         self recordMatch:#( 33 ).
       
  2878                                                                         self step.
       
  2879                                                                         (currentCharacter isLetterOrDigit 
       
  2880                                                                             or:[ (currentCharacter between:$- and:$/) or:[ currentCharacter == $_ ] ])
       
  2881                                                                     ] whileTrue.
       
  2882                                                                     ^ self reportLastMatch
       
  2883                                                                 ].
       
  2884                                                         ^ self reportLastMatch
       
  2885                                                     ].
       
  2886                                                     ^ self reportLastMatch
       
  2887                                                 ].
       
  2888                                                 ^ self reportLastMatch
       
  2889                                             ].
       
  2890                                             ^ self reportLastMatch
       
  2891                                         ].
       
  2892                                         ^ self reportLastMatch
       
  2893                                     ].
       
  2894                                     ^ self reportLastMatch
       
  2895                                 ].
       
  2896                                 ^ self reportLastMatch
       
  2897                             ].
       
  2898                             ^ self reportLastMatch
       
  2899                         ].
       
  2900                         ^ self reportLastMatch
       
  2901                     ].
       
  2902                     ^ self reportLastMatch
       
  2903                 ].
       
  2904                 ^ self reportLastMatch
       
  2905             ].
       
  2906             ^ self reportLastMatch
       
  2907         ].
       
  2908         ^ self reportLastMatch
       
  2909     ].
  1758     ^ self reportLastMatch
  2910     ^ self reportLastMatch
  1759 
  2911 
  1760     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
  2912     "Modified: / 04-07-2008 / 09:23:45 / Jan Vrany <vranyj1@fel.cvut.cz>"
  1761 ! !
  2913 ! !
  1762 
  2914 
  1763 !CDefinitionScanner methodsFor:'generated-tokens'!
  2915 !CDefinitionScanner methodsFor:'generated-tokens'!
  1764 
  2916 
  1765 emptySymbolTokenId
  2917 emptySymbolTokenId
  1766 	^59
  2918 	^60
  1767 
  2919 
  1768     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
  2920     "Modified: / 04-07-2008 / 09:23:45 / Jan Vrany <vranyj1@fel.cvut.cz>"
  1769 !
  2921 !
  1770 
  2922 
  1771 errorTokenId
  2923 errorTokenId
  1772 	^60
  2924 	^61
  1773 
  2925 
  1774     "Modified: / 17-02-2008 / 18:45:28 / janfrog"
  2926     "Modified: / 04-07-2008 / 09:23:45 / Jan Vrany <vranyj1@fel.cvut.cz>"
  1775 ! !
  2927 ! !
  1776 
  2928 
  1777 !CDefinitionScanner class methodsFor:'documentation'!
  2929 !CDefinitionScanner class methodsFor:'documentation'!
  1778 
  2930 
  1779 version
  2931 version