xquery/trunk/XQuery__XQueryScanner.st
changeset 0 5057afe1ec87
child 18 3476eed46de5
equal deleted inserted replaced
-1:000000000000 0:5057afe1ec87
       
     1 "{ Package: 'stx:goodies/xmlsuite/xquery' }"
       
     2 
       
     3 "{ NameSpace: XQuery }"
       
     4 
       
     5 Perseus::Scanner subclass:#XQueryScanner
       
     6 	instanceVariableNames:''
       
     7 	classVariableNames:''
       
     8 	poolDictionaries:''
       
     9 	category:'XQuery-Executor'
       
    10 !
       
    11 
       
    12 
       
    13 !XQueryScanner class methodsFor:'generated-comments'!
       
    14 
       
    15 scannerDefinitionComment
       
    16 
       
    17 	"<whitespace> : \s+;
       
    18 <char> : [a-zA-Z];
       
    19 <digit> : [0-9];
       
    20 <char_ref> : ((&\#[0-9]+\;) | (&\#x[0-9a-fA-F]+\;));
       
    21 
       
    22 <ncnamechar> : (<char> | <digit> | \. | \- | \_);
       
    23 <ncname> : (<char> | \_) (<ncnamechar>)*;
       
    24 <qname> : (<ncname> \:)? <ncname>;
       
    25 
       
    26 <digits> : [0-9]+;
       
    27 <integer_literal> : <digits>;
       
    28 <decimal_literal> : (\.<digits>) | (<digits>\.[0-9]*);
       
    29 <double_literal> : ((\.<digits>) | (<digits>(\.[0-9]*)?)) [eE] [\+\-]? <digits>;
       
    30 
       
    31 <predefined_entity_ref> : &(lt | gt | amp | quot | apos)\;;
       
    32 <escape_quot> : """";
       
    33 <escape_apos> : '';
       
    34 
       
    35 <string_literal> : ("" (<predefined_entity_ref> | <char_ref> | <escape_quot> | [^""&])* "") | (' (<predefined_entity_ref> | <char_ref> | <escape_apos> | [^'&])* ');
       
    36 
       
    37 <element_content_char> : <char> - [{}<&];
       
    38 <qout_attr_content_char> : <char> - [""{}<&];
       
    39 <apos_attr_content_char> : <char> - ['{}<&];
       
    40 "
       
    41 ! !
       
    42 
       
    43 !XQueryScanner class methodsFor:'generated-initialization'!
       
    44 
       
    45 initializeKeywordMap
       
    46     keywordMap := Dictionary new.
       
    47     #( #(112 'after' 71)
       
    48      #(112 'ancestor' 108)
       
    49      #(112 'and' 6)
       
    50      #(112 'as' 69)
       
    51      #(112 'ascending' 44)
       
    52      #(112 'at' 51)
       
    53      #(112 'attribute' 87)
       
    54      #(112 'before' 72)
       
    55      #(112 'by' 48)
       
    56      #(112 'child' 90)
       
    57      #(112 'comment' comment)
       
    58      #(112 'copy' 74)
       
    59      #(112 'declare' 37)
       
    60      #(112 'default' 38)
       
    61      #(112 'delete' 60)
       
    62      #(112 'descendant' 86)
       
    63      #(112 'descending' 45)
       
    64      #(112 'div' 7)
       
    65      #(112 'do' 59)
       
    66      #(112 'document' 67)
       
    67      #(112 'element' 39)
       
    68      #(112 'else' 12)
       
    69      #(112 'empty' 46)
       
    70      #(112 'eq' 17)
       
    71      #(112 'every' 9)
       
    72      #(112 'except' 25)
       
    73      #(112 'first' 75)
       
    74      #(112 'following' 105)
       
    75      #(112 'for' 55)
       
    76      #(112 'function' 33)
       
    77      #(112 'ge' 92)
       
    78      #(112 'greatest' 49)
       
    79      #(112 'gt' 84)
       
    80      #(112 'idiv' 13)
       
    81      #(112 'if' 10)
       
    82      #(112 'in' 50)
       
    83      #(112 'insert' 81)
       
    84      #(112 'intersect' 24)
       
    85      #(112 'into' 82)
       
    86      #(112 'is' 93)
       
    87      #(112 'last' 76)
       
    88      #(112 'le' 42)
       
    89      #(112 'least' 21)
       
    90      #(112 'let' 52)
       
    91      #(112 'lt' 28)
       
    92      #(112 'mod' 27)
       
    93      #(112 'modify' 56)
       
    94      #(112 'namespace' 40)
       
    95      #(112 'ne' 18)
       
    96      #(112 'node' 57)
       
    97      #(112 'of' 79)
       
    98      #(112 'or' 5)
       
    99      #(112 'order' 47)
       
   100      #(112 'ordered' 98)
       
   101      #(112 'parent' 107)
       
   102      #(112 'preceding' 103)
       
   103      #(112 'rename' 63)
       
   104      #(112 'replace' 83)
       
   105      #(112 'return' 41)
       
   106      #(112 'satisfies' 8)
       
   107      #(112 'self' 88)
       
   108      #(112 'some' 14)
       
   109      #(112 'stable' 43)
       
   110      #(112 'text' 68)
       
   111      #(112 'then' 11)
       
   112      #(112 'to' 1)
       
   113      #(112 'transform' 73)
       
   114      #(112 'union' 22)
       
   115      #(112 'unordered' 64)
       
   116      #(112 'updating' 29)
       
   117      #(112 'value' 78)
       
   118      #(112 'where' 54)
       
   119      #(112 'with' 80)
       
   120      #(113 'after' 71)
       
   121      #(113 'ancestor' 108)
       
   122      #(113 'and' 6)
       
   123      #(113 'as' 69)
       
   124      #(113 'ascending' 44)
       
   125      #(113 'at' 51)
       
   126      #(113 'attribute' 87)
       
   127      #(113 'before' 72)
       
   128      #(113 'by' 48)
       
   129      #(113 'child' 90)
       
   130      #(113 'comment' comment)
       
   131      #(113 'copy' 74)
       
   132      #(113 'declare' 37)
       
   133      #(113 'default' 38)
       
   134      #(113 'delete' 60)
       
   135      #(113 'descendant' 86)
       
   136      #(113 'descending' 45)
       
   137      #(113 'div' 7)
       
   138      #(113 'do' 59)
       
   139      #(113 'document' 67)
       
   140      #(113 'element' 39)
       
   141      #(113 'else' 12)
       
   142      #(113 'empty' 46)
       
   143      #(113 'eq' 17)
       
   144      #(113 'every' 9)
       
   145      #(113 'except' 25)
       
   146      #(113 'first' 75)
       
   147      #(113 'following' 105)
       
   148      #(113 'for' 55)
       
   149      #(113 'function' 33)
       
   150      #(113 'ge' 92)
       
   151      #(113 'greatest' 49)
       
   152      #(113 'gt' 84)
       
   153      #(113 'idiv' 13)
       
   154      #(113 'if' 10)
       
   155      #(113 'in' 50)
       
   156      #(113 'insert' 81)
       
   157      #(113 'intersect' 24)
       
   158      #(113 'into' 82)
       
   159      #(113 'is' 93)
       
   160      #(113 'last' 76)
       
   161      #(113 'le' 42)
       
   162      #(113 'least' 21)
       
   163      #(113 'let' 52)
       
   164      #(113 'lt' 28)
       
   165      #(113 'mod' 27)
       
   166      #(113 'modify' 56)
       
   167      #(113 'namespace' 40)
       
   168      #(113 'ne' 18)
       
   169      #(113 'node' 57)
       
   170      #(113 'of' 79)
       
   171      #(113 'or' 5)
       
   172      #(113 'order' 47)
       
   173      #(113 'ordered' 98)
       
   174      #(113 'parent' 107)
       
   175      #(113 'preceding' 103)
       
   176      #(113 'rename' 63)
       
   177      #(113 'replace' 83)
       
   178      #(113 'return' 41)
       
   179      #(113 'satisfies' 8)
       
   180      #(113 'self' 88)
       
   181      #(113 'some' 14)
       
   182      #(113 'stable' 43)
       
   183      #(113 'text' 68)
       
   184      #(113 'then' 11)
       
   185      #(113 'to' 1)
       
   186      #(113 'transform' 73)
       
   187      #(113 'union' 22)
       
   188      #(113 'unordered' 64)
       
   189      #(113 'updating' 29)
       
   190      #(113 'value' 78)
       
   191      #(113 'where' 54)
       
   192      #(113 'with' 80) ) 
       
   193             do:[:each | 
       
   194                 (keywordMap at:each first ifAbsentPut:[ Dictionary new ]) at:(each at:2)
       
   195                     put:each last
       
   196             ].
       
   197     ^ keywordMap
       
   198 ! !
       
   199 
       
   200 !XQueryScanner methodsFor:'accessing'!
       
   201 
       
   202 source
       
   203 
       
   204     ^stream isExternalStream
       
   205         ifTrue:[self sourceFromExternalStream]
       
   206         ifFalse:[self sourceFromInternalStream]
       
   207 
       
   208     "Created: / 12-04-2007 / 11:52:21 / janfrog"
       
   209 !
       
   210 
       
   211 sourceFromExternalStream
       
   212 
       
   213     ^self shouldImplement "not yet implemented"
       
   214 
       
   215     "Created: / 12-04-2007 / 11:53:47 / janfrog"
       
   216 !
       
   217 
       
   218 sourceFromInternalStream
       
   219 
       
   220     ^stream collection asString.
       
   221 
       
   222     "Created: / 12-04-2007 / 11:54:00 / janfrog"
       
   223 !
       
   224 
       
   225 stream
       
   226     ^stream
       
   227 
       
   228     "Created: / 24-10-2007 / 15:55:43 / janfrog"
       
   229 ! !
       
   230 
       
   231 !XQueryScanner methodsFor:'generated-scanner'!
       
   232 
       
   233 scan1
       
   234     self step.
       
   235     (currentCharacter isLetter or:[ currentCharacter == $_ ]) ifTrue:[
       
   236         [
       
   237             self recordMatch:#( 113 ).
       
   238             self step.
       
   239             (currentCharacter isLetterOrDigit 
       
   240                 or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ])
       
   241         ] whileTrue.
       
   242         ^ self reportLastMatch
       
   243     ].
       
   244     ^ self reportLastMatch
       
   245 !
       
   246 
       
   247 scan10
       
   248     [
       
   249         self step.
       
   250         (currentCharacter <= $% or:[ currentCharacter >= $( ])
       
   251     ] whileTrue.
       
   252     (currentCharacter == $&) ifTrue:[
       
   253         self step.
       
   254         (currentCharacter == $g or:[ currentCharacter == $l ]) ifTrue:[
       
   255             ^ self scan8
       
   256         ].
       
   257         (currentCharacter == $#) ifTrue:[
       
   258             self step.
       
   259             (currentCharacter isXMLDigit) ifTrue:[
       
   260                 [
       
   261                     self step.
       
   262                     (currentCharacter isXMLDigit)
       
   263                 ] whileTrue.
       
   264                 (currentCharacter == $;) ifTrue:[
       
   265                     ^ self scan10
       
   266                 ].
       
   267                 ^ self reportLastMatch
       
   268             ].
       
   269             (currentCharacter == $x) ifTrue:[
       
   270                 self step.
       
   271                 (currentCharacter isXMLDigit 
       
   272                     or:[
       
   273                         (currentCharacter between:$A and:$F) 
       
   274                             or:[ (currentCharacter between:$a and:$f) ]
       
   275                     ]) 
       
   276                         ifTrue:[
       
   277                             [
       
   278                                 self step.
       
   279                                 (currentCharacter isXMLDigit 
       
   280                                     or:[
       
   281                                         (currentCharacter between:$A and:$F) 
       
   282                                             or:[ (currentCharacter between:$a and:$f) ]
       
   283                                     ])
       
   284                             ] whileTrue.
       
   285                             (currentCharacter == $;) ifTrue:[
       
   286                                 ^ self scan10
       
   287                             ].
       
   288                             ^ self reportLastMatch
       
   289                         ].
       
   290                 ^ self reportLastMatch
       
   291             ].
       
   292             ^ self reportLastMatch
       
   293         ].
       
   294         (currentCharacter == $a) ifTrue:[
       
   295             self step.
       
   296             (currentCharacter == $m) ifTrue:[
       
   297                 self step.
       
   298                 (currentCharacter == $p) ifTrue:[
       
   299                     ^ self scan9
       
   300                 ].
       
   301                 ^ self reportLastMatch
       
   302             ].
       
   303             (currentCharacter == $p) ifTrue:[
       
   304                 self step.
       
   305                 (currentCharacter == $o) ifTrue:[
       
   306                     self step.
       
   307                     (currentCharacter == $s) ifTrue:[
       
   308                         ^ self scan9
       
   309                     ].
       
   310                     ^ self reportLastMatch
       
   311                 ].
       
   312                 ^ self reportLastMatch
       
   313             ].
       
   314             ^ self reportLastMatch
       
   315         ].
       
   316         (currentCharacter == $q) ifTrue:[
       
   317             self step.
       
   318             (currentCharacter == $u) ifTrue:[
       
   319                 self step.
       
   320                 (currentCharacter == $o) ifTrue:[
       
   321                     ^ self scan8
       
   322                 ].
       
   323                 ^ self reportLastMatch
       
   324             ].
       
   325             ^ self reportLastMatch
       
   326         ].
       
   327         ^ self reportLastMatch
       
   328     ].
       
   329     (currentCharacter == $') ifTrue:[
       
   330         self recordMatch:#( 118 ).
       
   331         self step.
       
   332         (currentCharacter == $') ifTrue:[
       
   333             ^ self scan10
       
   334         ].
       
   335         ^ self reportLastMatch
       
   336     ].
       
   337     ^ self reportLastMatch
       
   338 !
       
   339 
       
   340 scan11
       
   341     [
       
   342         self recordMatch:#( 112 113 ).
       
   343         self step.
       
   344         (currentCharacter isLetterOrDigit 
       
   345             or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ])
       
   346     ] whileTrue.
       
   347     (currentCharacter == $:) ifTrue:[
       
   348         ^ self scan1
       
   349     ].
       
   350     ^ self reportLastMatch
       
   351 !
       
   352 
       
   353 scan12
       
   354     self recordMatch:#( 112 113 ).
       
   355     self step.
       
   356     ((currentCharacter between:$- and:$.) 
       
   357         or:[
       
   358             (currentCharacter between:$0 and:$9) 
       
   359                 or:[
       
   360                     (currentCharacter between:$A and:$Z) 
       
   361                         or:[
       
   362                             currentCharacter == $_ 
       
   363                                 or:[
       
   364                                     (currentCharacter between:$a and:$q) 
       
   365                                         or:[ (currentCharacter between:$s and:$z) ]
       
   366                                 ]
       
   367                         ]
       
   368                 ]
       
   369         ]) 
       
   370             ifTrue:[ ^ self scan11 ].
       
   371     (currentCharacter == $:) ifTrue:[
       
   372         ^ self scan1
       
   373     ].
       
   374     (currentCharacter == $r) ifTrue:[
       
   375         ^ self scan15
       
   376     ].
       
   377     ^ self reportLastMatch
       
   378 !
       
   379 
       
   380 scan13
       
   381     self recordMatch:#( 112 113 ).
       
   382     self step.
       
   383     (currentCharacter isXMLDigit 
       
   384         or:[
       
   385             (currentCharacter between:$- and:$.) 
       
   386                 or:[
       
   387                     (currentCharacter between:$A and:$Z) 
       
   388                         or:[
       
   389                             currentCharacter == $_ 
       
   390                                 or:[
       
   391                                     (currentCharacter between:$a and:$d) 
       
   392                                         or:[
       
   393                                             (currentCharacter between:$f and:$n) 
       
   394                                                 or:[ (currentCharacter between:$p and:$z) ]
       
   395                                         ]
       
   396                                 ]
       
   397                         ]
       
   398                 ]
       
   399         ]) 
       
   400             ifTrue:[ ^ self scan11 ].
       
   401     (currentCharacter == $:) ifTrue:[
       
   402         ^ self scan1
       
   403     ].
       
   404     (currentCharacter == $e) ifTrue:[
       
   405         self recordMatch:#( 112 113 ).
       
   406         self step.
       
   407         ((currentCharacter between:$- and:$.) 
       
   408             or:[
       
   409                 (currentCharacter between:$0 and:$9) 
       
   410                     or:[
       
   411                         (currentCharacter between:$A and:$Z) 
       
   412                             or:[
       
   413                                 currentCharacter == $_ 
       
   414                                     or:[
       
   415                                         (currentCharacter between:$a and:$r) 
       
   416                                             or:[ (currentCharacter between:$t and:$z) ]
       
   417                                     ]
       
   418                             ]
       
   419                     ]
       
   420             ]) 
       
   421                 ifTrue:[ ^ self scan11 ].
       
   422         (currentCharacter == $:) ifTrue:[
       
   423             ^ self scan1
       
   424         ].
       
   425         (currentCharacter == $s) ifTrue:[
       
   426             self recordMatch:#( 112 113 ).
       
   427             self step.
       
   428             ((currentCharacter between:$- and:$.) 
       
   429                 or:[
       
   430                     (currentCharacter between:$0 and:$9) 
       
   431                         or:[
       
   432                             (currentCharacter between:$A and:$Z) 
       
   433                                 or:[
       
   434                                     currentCharacter == $_ 
       
   435                                         or:[
       
   436                                             (currentCharacter between:$a and:$b) 
       
   437                                                 or:[ (currentCharacter between:$d and:$z) ]
       
   438                                         ]
       
   439                                 ]
       
   440                         ]
       
   441                 ]) 
       
   442                     ifTrue:[ ^ self scan11 ].
       
   443             (currentCharacter == $:) ifTrue:[
       
   444                 ^ self scan1
       
   445             ].
       
   446             (currentCharacter == $c) ifTrue:[
       
   447                 self recordMatch:#( 112 113 ).
       
   448                 self step.
       
   449                 (currentCharacter isXMLDigit 
       
   450                     or:[
       
   451                         (currentCharacter between:$- and:$.) 
       
   452                             or:[
       
   453                                 (currentCharacter between:$A and:$Z) 
       
   454                                     or:[
       
   455                                         currentCharacter == $_ 
       
   456                                             or:[
       
   457                                                 (currentCharacter between:$a and:$d) 
       
   458                                                     or:[ (currentCharacter between:$f and:$z) ]
       
   459                                             ]
       
   460                                     ]
       
   461                             ]
       
   462                     ]) 
       
   463                         ifTrue:[ ^ self scan11 ].
       
   464                 (currentCharacter == $:) ifTrue:[
       
   465                     ^ self scan1
       
   466                 ].
       
   467                 (currentCharacter == $e) ifTrue:[
       
   468                     self recordMatch:#( 112 113 ).
       
   469                     self step.
       
   470                     ((currentCharacter between:$- and:$.) 
       
   471                         or:[
       
   472                             (currentCharacter between:$0 and:$9) 
       
   473                                 or:[
       
   474                                     (currentCharacter between:$A and:$Z) 
       
   475                                         or:[
       
   476                                             currentCharacter == $_ 
       
   477                                                 or:[
       
   478                                                     (currentCharacter between:$a and:$m) 
       
   479                                                         or:[ (currentCharacter between:$o and:$z) ]
       
   480                                                 ]
       
   481                                         ]
       
   482                                 ]
       
   483                         ]) 
       
   484                             ifTrue:[ ^ self scan11 ].
       
   485                     (currentCharacter == $:) ifTrue:[
       
   486                         ^ self scan1
       
   487                     ].
       
   488                     (currentCharacter == $n) ifTrue:[
       
   489                         self recordMatch:#( 112 113 ).
       
   490                         self step.
       
   491                         ((currentCharacter between:$- and:$.) 
       
   492                             or:[
       
   493                                 (currentCharacter between:$0 and:$9) 
       
   494                                     or:[
       
   495                                         (currentCharacter between:$A and:$Z) 
       
   496                                             or:[
       
   497                                                 currentCharacter == $_ 
       
   498                                                     or:[
       
   499                                                         (currentCharacter between:$a and:$c) 
       
   500                                                             or:[ (currentCharacter between:$e and:$z) ]
       
   501                                                     ]
       
   502                                             ]
       
   503                                     ]
       
   504                             ]) 
       
   505                                 ifTrue:[ ^ self scan11 ].
       
   506                         (currentCharacter == $:) ifTrue:[
       
   507                             ^ self scan1
       
   508                         ].
       
   509                         (currentCharacter == $d) ifTrue:[
       
   510                             self recordMatch:#( 112 113 ).
       
   511                             self step.
       
   512                             (currentCharacter isXMLDigit 
       
   513                                 or:[
       
   514                                     (currentCharacter between:$- and:$.) 
       
   515                                         or:[
       
   516                                             (currentCharacter between:$A and:$Z) 
       
   517                                                 or:[ currentCharacter == $_ or:[ (currentCharacter between:$b and:$z) ] ]
       
   518                                         ]
       
   519                                 ]) 
       
   520                                     ifTrue:[ ^ self scan11 ].
       
   521                             (currentCharacter == $:) ifTrue:[
       
   522                                 ^ self scan1
       
   523                             ].
       
   524                             (currentCharacter == $a) ifTrue:[
       
   525                                 self recordMatch:#( 112 113 ).
       
   526                                 self step.
       
   527                                 ((currentCharacter between:$- and:$.) 
       
   528                                     or:[
       
   529                                         (currentCharacter between:$0 and:$9) 
       
   530                                             or:[
       
   531                                                 (currentCharacter between:$A and:$Z) 
       
   532                                                     or:[
       
   533                                                         currentCharacter == $_ 
       
   534                                                             or:[
       
   535                                                                 (currentCharacter between:$a and:$m) 
       
   536                                                                     or:[ (currentCharacter between:$o and:$z) ]
       
   537                                                             ]
       
   538                                                     ]
       
   539                                             ]
       
   540                                     ]) 
       
   541                                         ifTrue:[ ^ self scan11 ].
       
   542                                 (currentCharacter == $:) ifTrue:[
       
   543                                     ^ self scan1
       
   544                                 ].
       
   545                                 (currentCharacter == $n) ifTrue:[
       
   546                                     self recordMatch:#( 112 113 ).
       
   547                                     self step.
       
   548                                     ((currentCharacter between:$- and:$.) 
       
   549                                         or:[
       
   550                                             (currentCharacter between:$0 and:$9) 
       
   551                                                 or:[
       
   552                                                     (currentCharacter between:$A and:$Z) 
       
   553                                                         or:[
       
   554                                                             currentCharacter == $_ 
       
   555                                                                 or:[
       
   556                                                                     (currentCharacter between:$a and:$s) 
       
   557                                                                         or:[ (currentCharacter between:$u and:$z) ]
       
   558                                                                 ]
       
   559                                                         ]
       
   560                                                 ]
       
   561                                         ]) 
       
   562                                             ifTrue:[ ^ self scan11 ].
       
   563                                     (currentCharacter == $:) ifTrue:[
       
   564                                         ^ self scan1
       
   565                                     ].
       
   566                                     (currentCharacter == $t) ifTrue:[
       
   567                                         self recordMatch:#( 112 113 ).
       
   568                                         self step.
       
   569                                         (currentCharacter isLetterOrDigit 
       
   570                                             or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
   571                                                 ifTrue:[ ^ self scan11 ].
       
   572                                         (currentCharacter == $-) ifTrue:[
       
   573                                             self recordMatch:#( 112 113 ).
       
   574                                             self step.
       
   575                                             (currentCharacter isXMLDigit 
       
   576                                                 or:[
       
   577                                                     (currentCharacter between:$- and:$.) 
       
   578                                                         or:[
       
   579                                                             (currentCharacter between:$A and:$Z) 
       
   580                                                                 or:[
       
   581                                                                     currentCharacter == $_ 
       
   582                                                                         or:[
       
   583                                                                             (currentCharacter between:$a and:$n) 
       
   584                                                                                 or:[ (currentCharacter between:$p and:$z) ]
       
   585                                                                         ]
       
   586                                                                 ]
       
   587                                                         ]
       
   588                                                 ]) 
       
   589                                                     ifTrue:[ ^ self scan11 ].
       
   590                                             (currentCharacter == $:) ifTrue:[
       
   591                                                 ^ self scan1
       
   592                                             ].
       
   593                                             (currentCharacter == $o) ifTrue:[
       
   594                                                 self recordMatch:#( 112 113 ).
       
   595                                                 self step.
       
   596                                                 ((currentCharacter between:$- and:$.) 
       
   597                                                     or:[
       
   598                                                         (currentCharacter between:$0 and:$9) 
       
   599                                                             or:[
       
   600                                                                 (currentCharacter between:$A and:$Z) 
       
   601                                                                     or:[
       
   602                                                                         currentCharacter == $_ 
       
   603                                                                             or:[
       
   604                                                                                 (currentCharacter between:$a and:$q) 
       
   605                                                                                     or:[ (currentCharacter between:$s and:$z) ]
       
   606                                                                             ]
       
   607                                                                     ]
       
   608                                                             ]
       
   609                                                     ]) 
       
   610                                                         ifTrue:[ ^ self scan11 ].
       
   611                                                 (currentCharacter == $:) ifTrue:[
       
   612                                                     ^ self scan1
       
   613                                                 ].
       
   614                                                 (currentCharacter == $r) ifTrue:[
       
   615                                                     self recordMatch:#( 112 113 ).
       
   616                                                     self step.
       
   617                                                     (currentCharacter isLetterOrDigit 
       
   618                                                         or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
   619                                                             ifTrue:[ ^ self scan11 ].
       
   620                                                     (currentCharacter == $-) ifTrue:[
       
   621                                                         self recordMatch:#( 112 113 ).
       
   622                                                         self step.
       
   623                                                         ((currentCharacter between:$- and:$.) 
       
   624                                                             or:[
       
   625                                                                 (currentCharacter between:$0 and:$9) 
       
   626                                                                     or:[
       
   627                                                                         (currentCharacter between:$A and:$Z) 
       
   628                                                                             or:[
       
   629                                                                                 currentCharacter == $_ 
       
   630                                                                                     or:[
       
   631                                                                                         (currentCharacter between:$a and:$r) 
       
   632                                                                                             or:[ (currentCharacter between:$t and:$z) ]
       
   633                                                                                     ]
       
   634                                                                             ]
       
   635                                                                     ]
       
   636                                                             ]) 
       
   637                                                                 ifTrue:[ ^ self scan11 ].
       
   638                                                         (currentCharacter == $:) ifTrue:[
       
   639                                                             ^ self scan1
       
   640                                                         ].
       
   641                                                         (currentCharacter == $s) ifTrue:[
       
   642                                                             self recordMatch:#( 112 113 ).
       
   643                                                             self step.
       
   644                                                             (currentCharacter isXMLDigit 
       
   645                                                                 or:[
       
   646                                                                     (currentCharacter between:$- and:$.) 
       
   647                                                                         or:[
       
   648                                                                             (currentCharacter between:$A and:$Z) 
       
   649                                                                                 or:[
       
   650                                                                                     currentCharacter == $_ 
       
   651                                                                                         or:[
       
   652                                                                                             (currentCharacter between:$a and:$d) 
       
   653                                                                                                 or:[ (currentCharacter between:$f and:$z) ]
       
   654                                                                                         ]
       
   655                                                                                 ]
       
   656                                                                         ]
       
   657                                                                 ]) 
       
   658                                                                     ifTrue:[ ^ self scan11 ].
       
   659                                                             (currentCharacter == $:) ifTrue:[
       
   660                                                                 ^ self scan1
       
   661                                                             ].
       
   662                                                             (currentCharacter == $e) ifTrue:[
       
   663                                                                 self recordMatch:#( 112 113 ).
       
   664                                                                 self step.
       
   665                                                                 ((currentCharacter between:$- and:$.) 
       
   666                                                                     or:[
       
   667                                                                         (currentCharacter between:$0 and:$9) 
       
   668                                                                             or:[
       
   669                                                                                 (currentCharacter between:$A and:$Z) 
       
   670                                                                                     or:[
       
   671                                                                                         currentCharacter == $_ 
       
   672                                                                                             or:[
       
   673                                                                                                 (currentCharacter between:$a and:$k) 
       
   674                                                                                                     or:[ (currentCharacter between:$m and:$z) ]
       
   675                                                                                             ]
       
   676                                                                                     ]
       
   677                                                                             ]
       
   678                                                                     ]) 
       
   679                                                                         ifTrue:[ ^ self scan11 ].
       
   680                                                                 (currentCharacter == $:) ifTrue:[
       
   681                                                                     ^ self scan1
       
   682                                                                 ].
       
   683                                                                 (currentCharacter == $l) ifTrue:[
       
   684                                                                     self recordMatch:#( 112 113 ).
       
   685                                                                     self step.
       
   686                                                                     ((currentCharacter between:$- and:$.) 
       
   687                                                                         or:[
       
   688                                                                             (currentCharacter between:$0 and:$9) 
       
   689                                                                                 or:[
       
   690                                                                                     (currentCharacter between:$A and:$Z) 
       
   691                                                                                         or:[
       
   692                                                                                             currentCharacter == $_ 
       
   693                                                                                                 or:[
       
   694                                                                                                     (currentCharacter between:$a and:$e) 
       
   695                                                                                                         or:[ (currentCharacter between:$g and:$z) ]
       
   696                                                                                                 ]
       
   697                                                                                         ]
       
   698                                                                                 ]
       
   699                                                                         ]) 
       
   700                                                                             ifTrue:[ ^ self scan11 ].
       
   701                                                                     (currentCharacter == $:) ifTrue:[
       
   702                                                                         ^ self scan1
       
   703                                                                     ].
       
   704                                                                     (currentCharacter == $f) ifTrue:[
       
   705                                                                         self recordMatch:#( 91 112 113 ).
       
   706                                                                         self step.
       
   707                                                                         (currentCharacter isLetterOrDigit 
       
   708                                                                             or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ]) 
       
   709                                                                                 ifTrue:[ ^ self scan11 ].
       
   710                                                                         (currentCharacter == $:) ifTrue:[
       
   711                                                                             ^ self scan1
       
   712                                                                         ].
       
   713                                                                         ^ self reportLastMatch
       
   714                                                                     ].
       
   715                                                                     ^ self reportLastMatch
       
   716                                                                 ].
       
   717                                                                 ^ self reportLastMatch
       
   718                                                             ].
       
   719                                                             ^ self reportLastMatch
       
   720                                                         ].
       
   721                                                         ^ self reportLastMatch
       
   722                                                     ].
       
   723                                                     (currentCharacter == $:) ifTrue:[
       
   724                                                         ^ self scan1
       
   725                                                     ].
       
   726                                                     ^ self reportLastMatch
       
   727                                                 ].
       
   728                                                 ^ self reportLastMatch
       
   729                                             ].
       
   730                                             ^ self reportLastMatch
       
   731                                         ].
       
   732                                         (currentCharacter == $:) ifTrue:[
       
   733                                             ^ self scan1
       
   734                                         ].
       
   735                                         ^ self reportLastMatch
       
   736                                     ].
       
   737                                     ^ self reportLastMatch
       
   738                                 ].
       
   739                                 ^ self reportLastMatch
       
   740                             ].
       
   741                             ^ self reportLastMatch
       
   742                         ].
       
   743                         ^ self reportLastMatch
       
   744                     ].
       
   745                     ^ self reportLastMatch
       
   746                 ].
       
   747                 ^ self reportLastMatch
       
   748             ].
       
   749             ^ self reportLastMatch
       
   750         ].
       
   751         ^ self reportLastMatch
       
   752     ].
       
   753     (currentCharacter == $o) ifTrue:[
       
   754         self recordMatch:#( 112 113 ).
       
   755         self step.
       
   756         ((currentCharacter between:$- and:$.) 
       
   757             or:[
       
   758                 (currentCharacter between:$0 and:$9) 
       
   759                     or:[
       
   760                         (currentCharacter between:$A and:$Z) 
       
   761                             or:[
       
   762                                 currentCharacter == $_ 
       
   763                                     or:[
       
   764                                         (currentCharacter between:$a and:$b) 
       
   765                                             or:[ (currentCharacter between:$d and:$z) ]
       
   766                                     ]
       
   767                             ]
       
   768                     ]
       
   769             ]) 
       
   770                 ifTrue:[ ^ self scan11 ].
       
   771         (currentCharacter == $:) ifTrue:[
       
   772             ^ self scan1
       
   773         ].
       
   774         (currentCharacter == $c) ifTrue:[
       
   775             self recordMatch:#( 112 113 ).
       
   776             self step.
       
   777             (currentCharacter isXMLDigit 
       
   778                 or:[
       
   779                     (currentCharacter between:$- and:$.) 
       
   780                         or:[
       
   781                             (currentCharacter between:$A and:$Z) 
       
   782                                 or:[
       
   783                                     currentCharacter == $_ 
       
   784                                         or:[
       
   785                                             (currentCharacter between:$a and:$t) 
       
   786                                                 or:[ (currentCharacter between:$v and:$z) ]
       
   787                                         ]
       
   788                                 ]
       
   789                         ]
       
   790                 ]) 
       
   791                     ifTrue:[ ^ self scan11 ].
       
   792             (currentCharacter == $:) ifTrue:[
       
   793                 ^ self scan1
       
   794             ].
       
   795             (currentCharacter == $u) ifTrue:[
       
   796                 self recordMatch:#( 112 113 ).
       
   797                 self step.
       
   798                 ((currentCharacter between:$- and:$.) 
       
   799                     or:[
       
   800                         (currentCharacter between:$0 and:$9) 
       
   801                             or:[
       
   802                                 (currentCharacter between:$A and:$Z) 
       
   803                                     or:[
       
   804                                         currentCharacter == $_ 
       
   805                                             or:[
       
   806                                                 (currentCharacter between:$a and:$l) 
       
   807                                                     or:[ (currentCharacter between:$n and:$z) ]
       
   808                                             ]
       
   809                                     ]
       
   810                             ]
       
   811                     ]) 
       
   812                         ifTrue:[ ^ self scan11 ].
       
   813                 (currentCharacter == $:) ifTrue:[
       
   814                     ^ self scan1
       
   815                 ].
       
   816                 (currentCharacter == $m) ifTrue:[
       
   817                     self recordMatch:#( 112 113 ).
       
   818                     self step.
       
   819                     (currentCharacter isXMLDigit 
       
   820                         or:[
       
   821                             (currentCharacter between:$- and:$.) 
       
   822                                 or:[
       
   823                                     (currentCharacter between:$A and:$Z) 
       
   824                                         or:[
       
   825                                             currentCharacter == $_ 
       
   826                                                 or:[
       
   827                                                     (currentCharacter between:$a and:$d) 
       
   828                                                         or:[ (currentCharacter between:$f and:$z) ]
       
   829                                                 ]
       
   830                                         ]
       
   831                                 ]
       
   832                         ]) 
       
   833                             ifTrue:[ ^ self scan11 ].
       
   834                     (currentCharacter == $:) ifTrue:[
       
   835                         ^ self scan1
       
   836                     ].
       
   837                     (currentCharacter == $e) ifTrue:[
       
   838                         self recordMatch:#( 112 113 ).
       
   839                         self step.
       
   840                         ((currentCharacter between:$- and:$.) 
       
   841                             or:[
       
   842                                 (currentCharacter between:$0 and:$9) 
       
   843                                     or:[
       
   844                                         (currentCharacter between:$A and:$Z) 
       
   845                                             or:[
       
   846                                                 currentCharacter == $_ 
       
   847                                                     or:[
       
   848                                                         (currentCharacter between:$a and:$m) 
       
   849                                                             or:[ (currentCharacter between:$o and:$z) ]
       
   850                                                     ]
       
   851                                             ]
       
   852                                     ]
       
   853                             ]) 
       
   854                                 ifTrue:[ ^ self scan11 ].
       
   855                         (currentCharacter == $:) ifTrue:[
       
   856                             ^ self scan1
       
   857                         ].
       
   858                         (currentCharacter == $n) ifTrue:[
       
   859                             self recordMatch:#( 112 113 ).
       
   860                             self step.
       
   861                             ((currentCharacter between:$- and:$.) 
       
   862                                 or:[
       
   863                                     (currentCharacter between:$0 and:$9) 
       
   864                                         or:[
       
   865                                             (currentCharacter between:$A and:$Z) 
       
   866                                                 or:[
       
   867                                                     currentCharacter == $_ 
       
   868                                                         or:[
       
   869                                                             (currentCharacter between:$a and:$s) 
       
   870                                                                 or:[ (currentCharacter between:$u and:$z) ]
       
   871                                                         ]
       
   872                                                 ]
       
   873                                         ]
       
   874                                 ]) 
       
   875                                     ifTrue:[ ^ self scan11 ].
       
   876                             (currentCharacter == $:) ifTrue:[
       
   877                                 ^ self scan1
       
   878                             ].
       
   879                             (currentCharacter == $t) ifTrue:[
       
   880                                 self recordMatch:#( 112 113 ).
       
   881                                 self step.
       
   882                                 (currentCharacter isLetterOrDigit 
       
   883                                     or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
   884                                         ifTrue:[ ^ self scan11 ].
       
   885                                 (currentCharacter == $-) ifTrue:[
       
   886                                     self recordMatch:#( 112 113 ).
       
   887                                     self step.
       
   888                                     ((currentCharacter between:$- and:$.) 
       
   889                                         or:[
       
   890                                             (currentCharacter between:$0 and:$9) 
       
   891                                                 or:[
       
   892                                                     (currentCharacter between:$A and:$Z) 
       
   893                                                         or:[
       
   894                                                             currentCharacter == $_ 
       
   895                                                                 or:[
       
   896                                                                     (currentCharacter between:$a and:$m) 
       
   897                                                                         or:[ (currentCharacter between:$o and:$z) ]
       
   898                                                                 ]
       
   899                                                         ]
       
   900                                                 ]
       
   901                                         ]) 
       
   902                                             ifTrue:[ ^ self scan11 ].
       
   903                                     (currentCharacter == $:) ifTrue:[
       
   904                                         ^ self scan1
       
   905                                     ].
       
   906                                     (currentCharacter == $n) ifTrue:[
       
   907                                         self recordMatch:#( 112 113 ).
       
   908                                         self step.
       
   909                                         (currentCharacter isXMLDigit 
       
   910                                             or:[
       
   911                                                 (currentCharacter between:$- and:$.) 
       
   912                                                     or:[
       
   913                                                         (currentCharacter between:$A and:$Z) 
       
   914                                                             or:[
       
   915                                                                 currentCharacter == $_ 
       
   916                                                                     or:[
       
   917                                                                         (currentCharacter between:$a and:$n) 
       
   918                                                                             or:[ (currentCharacter between:$p and:$z) ]
       
   919                                                                     ]
       
   920                                                             ]
       
   921                                                     ]
       
   922                                             ]) 
       
   923                                                 ifTrue:[ ^ self scan11 ].
       
   924                                         (currentCharacter == $:) ifTrue:[
       
   925                                             ^ self scan1
       
   926                                         ].
       
   927                                         (currentCharacter == $o) ifTrue:[
       
   928                                             self recordMatch:#( 112 113 ).
       
   929                                             self step.
       
   930                                             ((currentCharacter between:$- and:$.) 
       
   931                                                 or:[
       
   932                                                     (currentCharacter between:$0 and:$9) 
       
   933                                                         or:[
       
   934                                                             (currentCharacter between:$A and:$Z) 
       
   935                                                                 or:[
       
   936                                                                     currentCharacter == $_ 
       
   937                                                                         or:[
       
   938                                                                             (currentCharacter between:$a and:$c) 
       
   939                                                                                 or:[ (currentCharacter between:$e and:$z) ]
       
   940                                                                         ]
       
   941                                                                 ]
       
   942                                                         ]
       
   943                                                 ]) 
       
   944                                                     ifTrue:[ ^ self scan11 ].
       
   945                                             (currentCharacter == $:) ifTrue:[
       
   946                                                 ^ self scan1
       
   947                                             ].
       
   948                                             (currentCharacter == $d) ifTrue:[
       
   949                                                 self recordMatch:#( 112 113 ).
       
   950                                                 self step.
       
   951                                                 (currentCharacter isXMLDigit 
       
   952                                                     or:[
       
   953                                                         (currentCharacter between:$- and:$.) 
       
   954                                                             or:[
       
   955                                                                 (currentCharacter between:$A and:$Z) 
       
   956                                                                     or:[
       
   957                                                                         currentCharacter == $_ 
       
   958                                                                             or:[
       
   959                                                                                 (currentCharacter between:$a and:$d) 
       
   960                                                                                     or:[ (currentCharacter between:$f and:$z) ]
       
   961                                                                             ]
       
   962                                                                     ]
       
   963                                                             ]
       
   964                                                     ]) 
       
   965                                                         ifTrue:[ ^ self scan11 ].
       
   966                                                 (currentCharacter == $:) ifTrue:[
       
   967                                                     ^ self scan1
       
   968                                                 ].
       
   969                                                 (currentCharacter == $e) ifTrue:[
       
   970                                                     self recordMatch:#( 58 112 113 ).
       
   971                                                     self step.
       
   972                                                     (currentCharacter isLetterOrDigit 
       
   973                                                         or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ]) 
       
   974                                                             ifTrue:[ ^ self scan11 ].
       
   975                                                     (currentCharacter == $:) ifTrue:[
       
   976                                                         ^ self scan1
       
   977                                                     ].
       
   978                                                     ^ self reportLastMatch
       
   979                                                 ].
       
   980                                                 ^ self reportLastMatch
       
   981                                             ].
       
   982                                             ^ self reportLastMatch
       
   983                                         ].
       
   984                                         ^ self reportLastMatch
       
   985                                     ].
       
   986                                     ^ self reportLastMatch
       
   987                                 ].
       
   988                                 (currentCharacter == $:) ifTrue:[
       
   989                                     ^ self scan1
       
   990                                 ].
       
   991                                 ^ self reportLastMatch
       
   992                             ].
       
   993                             ^ self reportLastMatch
       
   994                         ].
       
   995                         ^ self reportLastMatch
       
   996                     ].
       
   997                     ^ self reportLastMatch
       
   998                 ].
       
   999                 ^ self reportLastMatch
       
  1000             ].
       
  1001             ^ self reportLastMatch
       
  1002         ].
       
  1003         ^ self reportLastMatch
       
  1004     ].
       
  1005     ^ self reportLastMatch
       
  1006 !
       
  1007 
       
  1008 scan14
       
  1009     [
       
  1010         self recordMatch:#( 115 ).
       
  1011         self step.
       
  1012         (currentCharacter isXMLDigit)
       
  1013     ] whileTrue.
       
  1014     (currentCharacter == $E or:[ currentCharacter == $e ]) ifTrue:[
       
  1015         ^ self scan2
       
  1016     ].
       
  1017     ^ self reportLastMatch
       
  1018 !
       
  1019 
       
  1020 scan15
       
  1021     self recordMatch:#( 112 113 ).
       
  1022     self step.
       
  1023     (currentCharacter isXMLDigit 
       
  1024         or:[
       
  1025             (currentCharacter between:$- and:$.) 
       
  1026                 or:[
       
  1027                     (currentCharacter between:$A and:$Z) 
       
  1028                         or:[
       
  1029                             currentCharacter == $_ 
       
  1030                                 or:[
       
  1031                                     (currentCharacter between:$a and:$d) 
       
  1032                                         or:[
       
  1033                                             (currentCharacter between:$f and:$n) 
       
  1034                                                 or:[ (currentCharacter between:$p and:$z) ]
       
  1035                                         ]
       
  1036                                 ]
       
  1037                         ]
       
  1038                 ]
       
  1039         ]) 
       
  1040             ifTrue:[ ^ self scan11 ].
       
  1041     (currentCharacter == $:) ifTrue:[
       
  1042         ^ self scan1
       
  1043     ].
       
  1044     (currentCharacter == $e) ifTrue:[
       
  1045         self recordMatch:#( 112 113 ).
       
  1046         self step.
       
  1047         ((currentCharacter between:$- and:$.) 
       
  1048             or:[
       
  1049                 (currentCharacter between:$0 and:$9) 
       
  1050                     or:[
       
  1051                         (currentCharacter between:$A and:$Z) 
       
  1052                             or:[
       
  1053                                 currentCharacter == $_ 
       
  1054                                     or:[
       
  1055                                         (currentCharacter between:$a and:$b) 
       
  1056                                             or:[ (currentCharacter between:$d and:$z) ]
       
  1057                                     ]
       
  1058                             ]
       
  1059                     ]
       
  1060             ]) 
       
  1061                 ifTrue:[ ^ self scan11 ].
       
  1062         (currentCharacter == $:) ifTrue:[
       
  1063             ^ self scan1
       
  1064         ].
       
  1065         (currentCharacter == $c) ifTrue:[
       
  1066             self recordMatch:#( 112 113 ).
       
  1067             self step.
       
  1068             (currentCharacter isXMLDigit 
       
  1069                 or:[
       
  1070                     (currentCharacter between:$- and:$.) 
       
  1071                         or:[
       
  1072                             (currentCharacter between:$A and:$Z) 
       
  1073                                 or:[
       
  1074                                     currentCharacter == $_ 
       
  1075                                         or:[
       
  1076                                             (currentCharacter between:$a and:$d) 
       
  1077                                                 or:[ (currentCharacter between:$f and:$z) ]
       
  1078                                         ]
       
  1079                                 ]
       
  1080                         ]
       
  1081                 ]) 
       
  1082                     ifTrue:[ ^ self scan11 ].
       
  1083             (currentCharacter == $:) ifTrue:[
       
  1084                 ^ self scan1
       
  1085             ].
       
  1086             (currentCharacter == $e) ifTrue:[
       
  1087                 self recordMatch:#( 112 113 ).
       
  1088                 self step.
       
  1089                 ((currentCharacter between:$- and:$.) 
       
  1090                     or:[
       
  1091                         (currentCharacter between:$0 and:$9) 
       
  1092                             or:[
       
  1093                                 (currentCharacter between:$A and:$Z) 
       
  1094                                     or:[
       
  1095                                         currentCharacter == $_ 
       
  1096                                             or:[
       
  1097                                                 (currentCharacter between:$a and:$c) 
       
  1098                                                     or:[ (currentCharacter between:$e and:$z) ]
       
  1099                                             ]
       
  1100                                     ]
       
  1101                             ]
       
  1102                     ]) 
       
  1103                         ifTrue:[ ^ self scan11 ].
       
  1104                 (currentCharacter == $:) ifTrue:[
       
  1105                     ^ self scan1
       
  1106                 ].
       
  1107                 (currentCharacter == $d) ifTrue:[
       
  1108                     self recordMatch:#( 112 113 ).
       
  1109                     self step.
       
  1110                     (currentCharacter isXMLDigit 
       
  1111                         or:[
       
  1112                             (currentCharacter between:$- and:$.) 
       
  1113                                 or:[
       
  1114                                     (currentCharacter between:$A and:$Z) 
       
  1115                                         or:[
       
  1116                                             currentCharacter == $_ 
       
  1117                                                 or:[
       
  1118                                                     (currentCharacter between:$a and:$h) 
       
  1119                                                         or:[ (currentCharacter between:$j and:$z) ]
       
  1120                                                 ]
       
  1121                                         ]
       
  1122                                 ]
       
  1123                         ]) 
       
  1124                             ifTrue:[ ^ self scan11 ].
       
  1125                     (currentCharacter == $:) ifTrue:[
       
  1126                         ^ self scan1
       
  1127                     ].
       
  1128                     (currentCharacter == $i) ifTrue:[
       
  1129                         self recordMatch:#( 112 113 ).
       
  1130                         self step.
       
  1131                         ((currentCharacter between:$- and:$.) 
       
  1132                             or:[
       
  1133                                 (currentCharacter between:$0 and:$9) 
       
  1134                                     or:[
       
  1135                                         (currentCharacter between:$A and:$Z) 
       
  1136                                             or:[
       
  1137                                                 currentCharacter == $_ 
       
  1138                                                     or:[
       
  1139                                                         (currentCharacter between:$a and:$m) 
       
  1140                                                             or:[ (currentCharacter between:$o and:$z) ]
       
  1141                                                     ]
       
  1142                                             ]
       
  1143                                     ]
       
  1144                             ]) 
       
  1145                                 ifTrue:[ ^ self scan11 ].
       
  1146                         (currentCharacter == $:) ifTrue:[
       
  1147                             ^ self scan1
       
  1148                         ].
       
  1149                         (currentCharacter == $n) ifTrue:[
       
  1150                             self recordMatch:#( 112 113 ).
       
  1151                             self step.
       
  1152                             ((currentCharacter between:$- and:$.) 
       
  1153                                 or:[
       
  1154                                     (currentCharacter between:$0 and:$9) 
       
  1155                                         or:[
       
  1156                                             (currentCharacter between:$A and:$Z) 
       
  1157                                                 or:[
       
  1158                                                     currentCharacter == $_ 
       
  1159                                                         or:[
       
  1160                                                             (currentCharacter between:$a and:$f) 
       
  1161                                                                 or:[ (currentCharacter between:$h and:$z) ]
       
  1162                                                         ]
       
  1163                                                 ]
       
  1164                                         ]
       
  1165                                 ]) 
       
  1166                                     ifTrue:[ ^ self scan11 ].
       
  1167                             (currentCharacter == $:) ifTrue:[
       
  1168                                 ^ self scan1
       
  1169                             ].
       
  1170                             (currentCharacter == $g) ifTrue:[
       
  1171                                 self recordMatch:#( 112 113 ).
       
  1172                                 self step.
       
  1173                                 (currentCharacter isLetterOrDigit 
       
  1174                                     or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
  1175                                         ifTrue:[ ^ self scan11 ].
       
  1176                                 (currentCharacter == $-) ifTrue:[
       
  1177                                     self recordMatch:#( 112 113 ).
       
  1178                                     self step.
       
  1179                                     ((currentCharacter between:$- and:$.) 
       
  1180                                         or:[
       
  1181                                             (currentCharacter between:$0 and:$9) 
       
  1182                                                 or:[
       
  1183                                                     (currentCharacter between:$A and:$Z) 
       
  1184                                                         or:[
       
  1185                                                             currentCharacter == $_ 
       
  1186                                                                 or:[
       
  1187                                                                     (currentCharacter between:$a and:$r) 
       
  1188                                                                         or:[ (currentCharacter between:$t and:$z) ]
       
  1189                                                                 ]
       
  1190                                                         ]
       
  1191                                                 ]
       
  1192                                         ]) 
       
  1193                                             ifTrue:[ ^ self scan11 ].
       
  1194                                     (currentCharacter == $:) ifTrue:[
       
  1195                                         ^ self scan1
       
  1196                                     ].
       
  1197                                     (currentCharacter == $s) ifTrue:[
       
  1198                                         self recordMatch:#( 112 113 ).
       
  1199                                         self step.
       
  1200                                         (currentCharacter isXMLDigit 
       
  1201                                             or:[
       
  1202                                                 (currentCharacter between:$- and:$.) 
       
  1203                                                     or:[
       
  1204                                                         (currentCharacter between:$A and:$Z) 
       
  1205                                                             or:[
       
  1206                                                                 currentCharacter == $_ 
       
  1207                                                                     or:[
       
  1208                                                                         (currentCharacter between:$a and:$h) 
       
  1209                                                                             or:[ (currentCharacter between:$j and:$z) ]
       
  1210                                                                     ]
       
  1211                                                             ]
       
  1212                                                     ]
       
  1213                                             ]) 
       
  1214                                                 ifTrue:[ ^ self scan11 ].
       
  1215                                         (currentCharacter == $:) ifTrue:[
       
  1216                                             ^ self scan1
       
  1217                                         ].
       
  1218                                         (currentCharacter == $i) ifTrue:[
       
  1219                                             self recordMatch:#( 112 113 ).
       
  1220                                             self step.
       
  1221                                             ((currentCharacter between:$- and:$.) 
       
  1222                                                 or:[
       
  1223                                                     (currentCharacter between:$0 and:$9) 
       
  1224                                                         or:[
       
  1225                                                             (currentCharacter between:$A and:$Z) 
       
  1226                                                                 or:[
       
  1227                                                                     currentCharacter == $_ 
       
  1228                                                                         or:[ currentCharacter == $a or:[ (currentCharacter between:$c and:$z) ] ]
       
  1229                                                                 ]
       
  1230                                                         ]
       
  1231                                                 ]) 
       
  1232                                                     ifTrue:[ ^ self scan11 ].
       
  1233                                             (currentCharacter == $:) ifTrue:[
       
  1234                                                 ^ self scan1
       
  1235                                             ].
       
  1236                                             (currentCharacter == $b) ifTrue:[
       
  1237                                                 self recordMatch:#( 112 113 ).
       
  1238                                                 self step.
       
  1239                                                 ((currentCharacter between:$- and:$.) 
       
  1240                                                     or:[
       
  1241                                                         (currentCharacter between:$0 and:$9) 
       
  1242                                                             or:[
       
  1243                                                                 (currentCharacter between:$A and:$Z) 
       
  1244                                                                     or:[
       
  1245                                                                         currentCharacter == $_ 
       
  1246                                                                             or:[
       
  1247                                                                                 (currentCharacter between:$a and:$k) 
       
  1248                                                                                     or:[ (currentCharacter between:$m and:$z) ]
       
  1249                                                                             ]
       
  1250                                                                     ]
       
  1251                                                             ]
       
  1252                                                     ]) 
       
  1253                                                         ifTrue:[ ^ self scan11 ].
       
  1254                                                 (currentCharacter == $:) ifTrue:[
       
  1255                                                     ^ self scan1
       
  1256                                                 ].
       
  1257                                                 (currentCharacter == $l) ifTrue:[
       
  1258                                                     self recordMatch:#( 112 113 ).
       
  1259                                                     self step.
       
  1260                                                     (currentCharacter isXMLDigit 
       
  1261                                                         or:[
       
  1262                                                             (currentCharacter between:$- and:$.) 
       
  1263                                                                 or:[
       
  1264                                                                     (currentCharacter between:$A and:$Z) 
       
  1265                                                                         or:[
       
  1266                                                                             currentCharacter == $_ 
       
  1267                                                                                 or:[
       
  1268                                                                                     (currentCharacter between:$a and:$h) 
       
  1269                                                                                         or:[ (currentCharacter between:$j and:$z) ]
       
  1270                                                                                 ]
       
  1271                                                                         ]
       
  1272                                                                 ]
       
  1273                                                         ]) 
       
  1274                                                             ifTrue:[ ^ self scan11 ].
       
  1275                                                     (currentCharacter == $:) ifTrue:[
       
  1276                                                         ^ self scan1
       
  1277                                                     ].
       
  1278                                                     (currentCharacter == $i) ifTrue:[
       
  1279                                                         self recordMatch:#( 112 113 ).
       
  1280                                                         self step.
       
  1281                                                         ((currentCharacter between:$- and:$.) 
       
  1282                                                             or:[
       
  1283                                                                 (currentCharacter between:$0 and:$9) 
       
  1284                                                                     or:[
       
  1285                                                                         (currentCharacter between:$A and:$Z) 
       
  1286                                                                             or:[
       
  1287                                                                                 currentCharacter == $_ 
       
  1288                                                                                     or:[
       
  1289                                                                                         (currentCharacter between:$a and:$m) 
       
  1290                                                                                             or:[ (currentCharacter between:$o and:$z) ]
       
  1291                                                                                     ]
       
  1292                                                                             ]
       
  1293                                                                     ]
       
  1294                                                             ]) 
       
  1295                                                                 ifTrue:[ ^ self scan11 ].
       
  1296                                                         (currentCharacter == $:) ifTrue:[
       
  1297                                                             ^ self scan1
       
  1298                                                         ].
       
  1299                                                         (currentCharacter == $n) ifTrue:[
       
  1300                                                             self recordMatch:#( 112 113 ).
       
  1301                                                             self step.
       
  1302                                                             ((currentCharacter between:$- and:$.) 
       
  1303                                                                 or:[
       
  1304                                                                     (currentCharacter between:$0 and:$9) 
       
  1305                                                                         or:[
       
  1306                                                                             (currentCharacter between:$A and:$Z) 
       
  1307                                                                                 or:[
       
  1308                                                                                     currentCharacter == $_ 
       
  1309                                                                                         or:[
       
  1310                                                                                             (currentCharacter between:$a and:$f) 
       
  1311                                                                                                 or:[ (currentCharacter between:$h and:$z) ]
       
  1312                                                                                         ]
       
  1313                                                                                 ]
       
  1314                                                                         ]
       
  1315                                                                 ]) 
       
  1316                                                                     ifTrue:[ ^ self scan11 ].
       
  1317                                                             (currentCharacter == $:) ifTrue:[
       
  1318                                                                 ^ self scan1
       
  1319                                                             ].
       
  1320                                                             (currentCharacter == $g) ifTrue:[
       
  1321                                                                 self recordMatch:#( 110 112 113 ).
       
  1322                                                                 self step.
       
  1323                                                                 (currentCharacter isLetterOrDigit 
       
  1324                                                                     or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ]) 
       
  1325                                                                         ifTrue:[ ^ self scan11 ].
       
  1326                                                                 (currentCharacter == $:) ifTrue:[
       
  1327                                                                     ^ self scan1
       
  1328                                                                 ].
       
  1329                                                                 ^ self reportLastMatch
       
  1330                                                             ].
       
  1331                                                             ^ self reportLastMatch
       
  1332                                                         ].
       
  1333                                                         ^ self reportLastMatch
       
  1334                                                     ].
       
  1335                                                     ^ self reportLastMatch
       
  1336                                                 ].
       
  1337                                                 ^ self reportLastMatch
       
  1338                                             ].
       
  1339                                             ^ self reportLastMatch
       
  1340                                         ].
       
  1341                                         ^ self reportLastMatch
       
  1342                                     ].
       
  1343                                     ^ self reportLastMatch
       
  1344                                 ].
       
  1345                                 (currentCharacter == $:) ifTrue:[
       
  1346                                     ^ self scan1
       
  1347                                 ].
       
  1348                                 ^ self reportLastMatch
       
  1349                             ].
       
  1350                             ^ self reportLastMatch
       
  1351                         ].
       
  1352                         ^ self reportLastMatch
       
  1353                     ].
       
  1354                     ^ self reportLastMatch
       
  1355                 ].
       
  1356                 ^ self reportLastMatch
       
  1357             ].
       
  1358             ^ self reportLastMatch
       
  1359         ].
       
  1360         ^ self reportLastMatch
       
  1361     ].
       
  1362     (currentCharacter == $o) ifTrue:[
       
  1363         ^ self scan16
       
  1364     ].
       
  1365     ^ self reportLastMatch
       
  1366 !
       
  1367 
       
  1368 scan16
       
  1369     self recordMatch:#( 112 113 ).
       
  1370     self step.
       
  1371     ((currentCharacter between:$- and:$.) 
       
  1372         or:[
       
  1373             (currentCharacter between:$0 and:$9) 
       
  1374                 or:[
       
  1375                     (currentCharacter between:$A and:$Z) 
       
  1376                         or:[
       
  1377                             currentCharacter == $_ 
       
  1378                                 or:[
       
  1379                                     (currentCharacter between:$a and:$b) 
       
  1380                                         or:[ (currentCharacter between:$d and:$z) ]
       
  1381                                 ]
       
  1382                         ]
       
  1383                 ]
       
  1384         ]) 
       
  1385             ifTrue:[ ^ self scan11 ].
       
  1386     (currentCharacter == $:) ifTrue:[
       
  1387         ^ self scan1
       
  1388     ].
       
  1389     (currentCharacter == $c) ifTrue:[
       
  1390         ^ self scan17
       
  1391     ].
       
  1392     ^ self reportLastMatch
       
  1393 !
       
  1394 
       
  1395 scan17
       
  1396     self recordMatch:#( 112 113 ).
       
  1397     self step.
       
  1398     (currentCharacter isXMLDigit 
       
  1399         or:[
       
  1400             (currentCharacter between:$- and:$.) 
       
  1401                 or:[
       
  1402                     (currentCharacter between:$A and:$Z) 
       
  1403                         or:[
       
  1404                             currentCharacter == $_ 
       
  1405                                 or:[
       
  1406                                     (currentCharacter between:$a and:$d) 
       
  1407                                         or:[ (currentCharacter between:$f and:$z) ]
       
  1408                                 ]
       
  1409                         ]
       
  1410                 ]
       
  1411         ]) 
       
  1412             ifTrue:[ ^ self scan11 ].
       
  1413     (currentCharacter == $:) ifTrue:[
       
  1414         ^ self scan1
       
  1415     ].
       
  1416     (currentCharacter == $e) ifTrue:[
       
  1417         ^ self scan18
       
  1418     ].
       
  1419     ^ self reportLastMatch
       
  1420 !
       
  1421 
       
  1422 scan18
       
  1423     self recordMatch:#( 112 113 ).
       
  1424     self step.
       
  1425     ((currentCharacter between:$- and:$.) 
       
  1426         or:[
       
  1427             (currentCharacter between:$0 and:$9) 
       
  1428                 or:[
       
  1429                     (currentCharacter between:$A and:$Z) 
       
  1430                         or:[
       
  1431                             currentCharacter == $_ 
       
  1432                                 or:[
       
  1433                                     (currentCharacter between:$a and:$r) 
       
  1434                                         or:[ (currentCharacter between:$t and:$z) ]
       
  1435                                 ]
       
  1436                         ]
       
  1437                 ]
       
  1438         ]) 
       
  1439             ifTrue:[ ^ self scan11 ].
       
  1440     (currentCharacter == $:) ifTrue:[
       
  1441         ^ self scan1
       
  1442     ].
       
  1443     (currentCharacter == $s) ifTrue:[
       
  1444         self recordMatch:#( 112 113 ).
       
  1445         self step.
       
  1446         ((currentCharacter between:$- and:$.) 
       
  1447             or:[
       
  1448                 (currentCharacter between:$0 and:$9) 
       
  1449                     or:[
       
  1450                         (currentCharacter between:$A and:$Z) 
       
  1451                             or:[
       
  1452                                 currentCharacter == $_ 
       
  1453                                     or:[
       
  1454                                         (currentCharacter between:$a and:$r) 
       
  1455                                             or:[ (currentCharacter between:$t and:$z) ]
       
  1456                                     ]
       
  1457                             ]
       
  1458                     ]
       
  1459             ]) 
       
  1460                 ifTrue:[ ^ self scan11 ].
       
  1461         (currentCharacter == $:) ifTrue:[
       
  1462             ^ self scan1
       
  1463         ].
       
  1464         (currentCharacter == $s) ifTrue:[
       
  1465             self recordMatch:#( 112 113 ).
       
  1466             self step.
       
  1467             (currentCharacter isXMLDigit 
       
  1468                 or:[
       
  1469                     (currentCharacter between:$- and:$.) 
       
  1470                         or:[
       
  1471                             (currentCharacter between:$A and:$Z) 
       
  1472                                 or:[
       
  1473                                     currentCharacter == $_ 
       
  1474                                         or:[
       
  1475                                             (currentCharacter between:$a and:$h) 
       
  1476                                                 or:[ (currentCharacter between:$j and:$z) ]
       
  1477                                         ]
       
  1478                                 ]
       
  1479                         ]
       
  1480                 ]) 
       
  1481                     ifTrue:[ ^ self scan11 ].
       
  1482             (currentCharacter == $:) ifTrue:[
       
  1483                 ^ self scan1
       
  1484             ].
       
  1485             (currentCharacter == $i) ifTrue:[
       
  1486                 self recordMatch:#( 112 113 ).
       
  1487                 self step.
       
  1488                 ((currentCharacter between:$- and:$.) 
       
  1489                     or:[
       
  1490                         (currentCharacter between:$0 and:$9) 
       
  1491                             or:[
       
  1492                                 (currentCharacter between:$A and:$Z) 
       
  1493                                     or:[
       
  1494                                         currentCharacter == $_ 
       
  1495                                             or:[
       
  1496                                                 (currentCharacter between:$a and:$m) 
       
  1497                                                     or:[ (currentCharacter between:$o and:$z) ]
       
  1498                                             ]
       
  1499                                     ]
       
  1500                             ]
       
  1501                     ]) 
       
  1502                         ifTrue:[ ^ self scan11 ].
       
  1503                 (currentCharacter == $:) ifTrue:[
       
  1504                     ^ self scan1
       
  1505                 ].
       
  1506                 (currentCharacter == $n) ifTrue:[
       
  1507                     self recordMatch:#( 112 113 ).
       
  1508                     self step.
       
  1509                     ((currentCharacter between:$- and:$.) 
       
  1510                         or:[
       
  1511                             (currentCharacter between:$0 and:$9) 
       
  1512                                 or:[
       
  1513                                     (currentCharacter between:$A and:$Z) 
       
  1514                                         or:[
       
  1515                                             currentCharacter == $_ 
       
  1516                                                 or:[
       
  1517                                                     (currentCharacter between:$a and:$f) 
       
  1518                                                         or:[ (currentCharacter between:$h and:$z) ]
       
  1519                                                 ]
       
  1520                                         ]
       
  1521                                 ]
       
  1522                         ]) 
       
  1523                             ifTrue:[ ^ self scan11 ].
       
  1524                     (currentCharacter == $:) ifTrue:[
       
  1525                         ^ self scan1
       
  1526                     ].
       
  1527                     (currentCharacter == $g) ifTrue:[
       
  1528                         self recordMatch:#( 112 113 ).
       
  1529                         self step.
       
  1530                         (currentCharacter isLetterOrDigit 
       
  1531                             or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
  1532                                 ifTrue:[ ^ self scan11 ].
       
  1533                         (currentCharacter == $-) ifTrue:[
       
  1534                             self recordMatch:#( 112 113 ).
       
  1535                             self step.
       
  1536                             (currentCharacter isXMLDigit 
       
  1537                                 or:[
       
  1538                                     (currentCharacter between:$- and:$.) 
       
  1539                                         or:[
       
  1540                                             (currentCharacter between:$A and:$Z) 
       
  1541                                                 or:[
       
  1542                                                     currentCharacter == $_ 
       
  1543                                                         or:[
       
  1544                                                             (currentCharacter between:$a and:$h) 
       
  1545                                                                 or:[ (currentCharacter between:$j and:$z) ]
       
  1546                                                         ]
       
  1547                                                 ]
       
  1548                                         ]
       
  1549                                 ]) 
       
  1550                                     ifTrue:[ ^ self scan11 ].
       
  1551                             (currentCharacter == $:) ifTrue:[
       
  1552                                 ^ self scan1
       
  1553                             ].
       
  1554                             (currentCharacter == $i) ifTrue:[
       
  1555                                 self recordMatch:#( 112 113 ).
       
  1556                                 self step.
       
  1557                                 ((currentCharacter between:$- and:$.) 
       
  1558                                     or:[
       
  1559                                         (currentCharacter between:$0 and:$9) 
       
  1560                                             or:[
       
  1561                                                 (currentCharacter between:$A and:$Z) 
       
  1562                                                     or:[
       
  1563                                                         currentCharacter == $_ 
       
  1564                                                             or:[
       
  1565                                                                 (currentCharacter between:$a and:$m) 
       
  1566                                                                     or:[ (currentCharacter between:$o and:$z) ]
       
  1567                                                             ]
       
  1568                                                     ]
       
  1569                                             ]
       
  1570                                     ]) 
       
  1571                                         ifTrue:[ ^ self scan11 ].
       
  1572                                 (currentCharacter == $:) ifTrue:[
       
  1573                                     ^ self scan1
       
  1574                                 ].
       
  1575                                 (currentCharacter == $n) ifTrue:[
       
  1576                                     self recordMatch:#( 112 113 ).
       
  1577                                     self step.
       
  1578                                     ((currentCharacter between:$- and:$.) 
       
  1579                                         or:[
       
  1580                                             (currentCharacter between:$0 and:$9) 
       
  1581                                                 or:[
       
  1582                                                     (currentCharacter between:$A and:$Z) 
       
  1583                                                         or:[
       
  1584                                                             currentCharacter == $_ 
       
  1585                                                                 or:[
       
  1586                                                                     (currentCharacter between:$a and:$r) 
       
  1587                                                                         or:[ (currentCharacter between:$t and:$z) ]
       
  1588                                                                 ]
       
  1589                                                         ]
       
  1590                                                 ]
       
  1591                                         ]) 
       
  1592                                             ifTrue:[ ^ self scan11 ].
       
  1593                                     (currentCharacter == $:) ifTrue:[
       
  1594                                         ^ self scan1
       
  1595                                     ].
       
  1596                                     (currentCharacter == $s) ifTrue:[
       
  1597                                         self recordMatch:#( 112 113 ).
       
  1598                                         self step.
       
  1599                                         ((currentCharacter between:$- and:$.) 
       
  1600                                             or:[
       
  1601                                                 (currentCharacter between:$0 and:$9) 
       
  1602                                                     or:[
       
  1603                                                         (currentCharacter between:$A and:$Z) 
       
  1604                                                             or:[
       
  1605                                                                 currentCharacter == $_ 
       
  1606                                                                     or:[
       
  1607                                                                         (currentCharacter between:$a and:$s) 
       
  1608                                                                             or:[ (currentCharacter between:$u and:$z) ]
       
  1609                                                                     ]
       
  1610                                                             ]
       
  1611                                                     ]
       
  1612                                             ]) 
       
  1613                                                 ifTrue:[ ^ self scan11 ].
       
  1614                                         (currentCharacter == $:) ifTrue:[
       
  1615                                             ^ self scan1
       
  1616                                         ].
       
  1617                                         (currentCharacter == $t) ifTrue:[
       
  1618                                             self recordMatch:#( 112 113 ).
       
  1619                                             self step.
       
  1620                                             ((currentCharacter between:$- and:$.) 
       
  1621                                                 or:[
       
  1622                                                     (currentCharacter between:$0 and:$9) 
       
  1623                                                         or:[
       
  1624                                                             (currentCharacter between:$A and:$Z) 
       
  1625                                                                 or:[
       
  1626                                                                     currentCharacter == $_ 
       
  1627                                                                         or:[
       
  1628                                                                             (currentCharacter between:$a and:$q) 
       
  1629                                                                                 or:[ (currentCharacter between:$s and:$z) ]
       
  1630                                                                         ]
       
  1631                                                                 ]
       
  1632                                                         ]
       
  1633                                                 ]) 
       
  1634                                                     ifTrue:[ ^ self scan11 ].
       
  1635                                             (currentCharacter == $:) ifTrue:[
       
  1636                                                 ^ self scan1
       
  1637                                             ].
       
  1638                                             (currentCharacter == $r) ifTrue:[
       
  1639                                                 self recordMatch:#( 112 113 ).
       
  1640                                                 self step.
       
  1641                                                 (currentCharacter isXMLDigit 
       
  1642                                                     or:[
       
  1643                                                         (currentCharacter between:$- and:$.) 
       
  1644                                                             or:[
       
  1645                                                                 (currentCharacter between:$A and:$Z) 
       
  1646                                                                     or:[
       
  1647                                                                         currentCharacter == $_ 
       
  1648                                                                             or:[
       
  1649                                                                                 (currentCharacter between:$a and:$t) 
       
  1650                                                                                     or:[ (currentCharacter between:$v and:$z) ]
       
  1651                                                                             ]
       
  1652                                                                     ]
       
  1653                                                             ]
       
  1654                                                     ]) 
       
  1655                                                         ifTrue:[ ^ self scan11 ].
       
  1656                                                 (currentCharacter == $:) ifTrue:[
       
  1657                                                     ^ self scan1
       
  1658                                                 ].
       
  1659                                                 (currentCharacter == $u) ifTrue:[
       
  1660                                                     self recordMatch:#( 112 113 ).
       
  1661                                                     self step.
       
  1662                                                     ((currentCharacter between:$- and:$.) 
       
  1663                                                         or:[
       
  1664                                                             (currentCharacter between:$0 and:$9) 
       
  1665                                                                 or:[
       
  1666                                                                     (currentCharacter between:$A and:$Z) 
       
  1667                                                                         or:[
       
  1668                                                                             currentCharacter == $_ 
       
  1669                                                                                 or:[
       
  1670                                                                                     (currentCharacter between:$a and:$b) 
       
  1671                                                                                         or:[ (currentCharacter between:$d and:$z) ]
       
  1672                                                                                 ]
       
  1673                                                                         ]
       
  1674                                                                 ]
       
  1675                                                         ]) 
       
  1676                                                             ifTrue:[ ^ self scan11 ].
       
  1677                                                     (currentCharacter == $:) ifTrue:[
       
  1678                                                         ^ self scan1
       
  1679                                                     ].
       
  1680                                                     (currentCharacter == $c) ifTrue:[
       
  1681                                                         self recordMatch:#( 112 113 ).
       
  1682                                                         self step.
       
  1683                                                         ((currentCharacter between:$- and:$.) 
       
  1684                                                             or:[
       
  1685                                                                 (currentCharacter between:$0 and:$9) 
       
  1686                                                                     or:[
       
  1687                                                                         (currentCharacter between:$A and:$Z) 
       
  1688                                                                             or:[
       
  1689                                                                                 currentCharacter == $_ 
       
  1690                                                                                     or:[
       
  1691                                                                                         (currentCharacter between:$a and:$s) 
       
  1692                                                                                             or:[ (currentCharacter between:$u and:$z) ]
       
  1693                                                                                     ]
       
  1694                                                                             ]
       
  1695                                                                     ]
       
  1696                                                             ]) 
       
  1697                                                                 ifTrue:[ ^ self scan11 ].
       
  1698                                                         (currentCharacter == $:) ifTrue:[
       
  1699                                                             ^ self scan1
       
  1700                                                         ].
       
  1701                                                         (currentCharacter == $t) ifTrue:[
       
  1702                                                             self recordMatch:#( 112 113 ).
       
  1703                                                             self step.
       
  1704                                                             (currentCharacter isXMLDigit 
       
  1705                                                                 or:[
       
  1706                                                                     (currentCharacter between:$- and:$.) 
       
  1707                                                                         or:[
       
  1708                                                                             (currentCharacter between:$A and:$Z) 
       
  1709                                                                                 or:[
       
  1710                                                                                     currentCharacter == $_ 
       
  1711                                                                                         or:[
       
  1712                                                                                             (currentCharacter between:$a and:$h) 
       
  1713                                                                                                 or:[ (currentCharacter between:$j and:$z) ]
       
  1714                                                                                         ]
       
  1715                                                                                 ]
       
  1716                                                                         ]
       
  1717                                                                 ]) 
       
  1718                                                                     ifTrue:[ ^ self scan11 ].
       
  1719                                                             (currentCharacter == $:) ifTrue:[
       
  1720                                                                 ^ self scan1
       
  1721                                                             ].
       
  1722                                                             (currentCharacter == $i) ifTrue:[
       
  1723                                                                 self recordMatch:#( 112 113 ).
       
  1724                                                                 self step.
       
  1725                                                                 (currentCharacter isXMLDigit 
       
  1726                                                                     or:[
       
  1727                                                                         (currentCharacter between:$- and:$.) 
       
  1728                                                                             or:[
       
  1729                                                                                 (currentCharacter between:$A and:$Z) 
       
  1730                                                                                     or:[
       
  1731                                                                                         currentCharacter == $_ 
       
  1732                                                                                             or:[
       
  1733                                                                                                 (currentCharacter between:$a and:$n) 
       
  1734                                                                                                     or:[ (currentCharacter between:$p and:$z) ]
       
  1735                                                                                             ]
       
  1736                                                                                     ]
       
  1737                                                                             ]
       
  1738                                                                     ]) 
       
  1739                                                                         ifTrue:[ ^ self scan11 ].
       
  1740                                                                 (currentCharacter == $:) ifTrue:[
       
  1741                                                                     ^ self scan1
       
  1742                                                                 ].
       
  1743                                                                 (currentCharacter == $o) ifTrue:[
       
  1744                                                                     self recordMatch:#( 112 113 ).
       
  1745                                                                     self step.
       
  1746                                                                     ((currentCharacter between:$- and:$.) 
       
  1747                                                                         or:[
       
  1748                                                                             (currentCharacter between:$0 and:$9) 
       
  1749                                                                                 or:[
       
  1750                                                                                     (currentCharacter between:$A and:$Z) 
       
  1751                                                                                         or:[
       
  1752                                                                                             currentCharacter == $_ 
       
  1753                                                                                                 or:[
       
  1754                                                                                                     (currentCharacter between:$a and:$m) 
       
  1755                                                                                                         or:[ (currentCharacter between:$o and:$z) ]
       
  1756                                                                                                 ]
       
  1757                                                                                         ]
       
  1758                                                                                 ]
       
  1759                                                                         ]) 
       
  1760                                                                             ifTrue:[ ^ self scan11 ].
       
  1761                                                                     (currentCharacter == $:) ifTrue:[
       
  1762                                                                         ^ self scan1
       
  1763                                                                     ].
       
  1764                                                                     (currentCharacter == $n) ifTrue:[
       
  1765                                                                         self recordMatch:#( 62 112 113 ).
       
  1766                                                                         self step.
       
  1767                                                                         (currentCharacter isLetterOrDigit 
       
  1768                                                                             or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ]) 
       
  1769                                                                                 ifTrue:[ ^ self scan11 ].
       
  1770                                                                         (currentCharacter == $:) ifTrue:[
       
  1771                                                                             ^ self scan1
       
  1772                                                                         ].
       
  1773                                                                         ^ self reportLastMatch
       
  1774                                                                     ].
       
  1775                                                                     ^ self reportLastMatch
       
  1776                                                                 ].
       
  1777                                                                 ^ self reportLastMatch
       
  1778                                                             ].
       
  1779                                                             ^ self reportLastMatch
       
  1780                                                         ].
       
  1781                                                         ^ self reportLastMatch
       
  1782                                                     ].
       
  1783                                                     ^ self reportLastMatch
       
  1784                                                 ].
       
  1785                                                 ^ self reportLastMatch
       
  1786                                             ].
       
  1787                                             ^ self reportLastMatch
       
  1788                                         ].
       
  1789                                         ^ self reportLastMatch
       
  1790                                     ].
       
  1791                                     ^ self reportLastMatch
       
  1792                                 ].
       
  1793                                 ^ self reportLastMatch
       
  1794                             ].
       
  1795                             ^ self reportLastMatch
       
  1796                         ].
       
  1797                         (currentCharacter == $:) ifTrue:[
       
  1798                             ^ self scan1
       
  1799                         ].
       
  1800                         ^ self reportLastMatch
       
  1801                     ].
       
  1802                     ^ self reportLastMatch
       
  1803                 ].
       
  1804                 ^ self reportLastMatch
       
  1805             ].
       
  1806             ^ self reportLastMatch
       
  1807         ].
       
  1808         ^ self reportLastMatch
       
  1809     ].
       
  1810     ^ self reportLastMatch
       
  1811 !
       
  1812 
       
  1813 scan2
       
  1814     self step.
       
  1815     (currentCharacter isXMLDigit) ifTrue:[
       
  1816         [
       
  1817             self recordMatch:#( 116 ).
       
  1818             self step.
       
  1819             (currentCharacter isXMLDigit)
       
  1820         ] whileTrue.
       
  1821         ^ self reportLastMatch
       
  1822     ].
       
  1823     (currentCharacter == $+ or:[ currentCharacter == $- ]) ifTrue:[
       
  1824         self step.
       
  1825         (currentCharacter isXMLDigit) ifTrue:[
       
  1826             [
       
  1827                 self recordMatch:#( 116 ).
       
  1828                 self step.
       
  1829                 (currentCharacter isXMLDigit)
       
  1830             ] whileTrue.
       
  1831             ^ self reportLastMatch
       
  1832         ].
       
  1833         ^ self reportLastMatch
       
  1834     ].
       
  1835     ^ self reportLastMatch
       
  1836 !
       
  1837 
       
  1838 scan3
       
  1839     self step.
       
  1840     (currentCharacter == $t) ifTrue:[
       
  1841         ^ self scan4
       
  1842     ].
       
  1843     ^ self reportLastMatch
       
  1844 !
       
  1845 
       
  1846 scan4
       
  1847     self step.
       
  1848     (currentCharacter == $;) ifTrue:[
       
  1849         ^ self recordAndReportMatch:#( 117 ).
       
  1850     ].
       
  1851     ^ self reportLastMatch
       
  1852 !
       
  1853 
       
  1854 scan5
       
  1855     self step.
       
  1856     (currentCharacter == $t) ifTrue:[
       
  1857         ^ self scan6
       
  1858     ].
       
  1859     ^ self reportLastMatch
       
  1860 !
       
  1861 
       
  1862 scan6
       
  1863     self step.
       
  1864     (currentCharacter == $;) ifTrue:[
       
  1865         ^ self scan7
       
  1866     ].
       
  1867     ^ self reportLastMatch
       
  1868 !
       
  1869 
       
  1870 scan7
       
  1871     [
       
  1872         self step.
       
  1873         (currentCharacter <= $!! 
       
  1874             or:[ (currentCharacter between:$# and:$%) or:[ currentCharacter >= $' ] ])
       
  1875     ] whileTrue.
       
  1876     (currentCharacter == $") ifTrue:[
       
  1877         self recordMatch:#( 118 ).
       
  1878         self step.
       
  1879         (currentCharacter == $") ifTrue:[
       
  1880             ^ self scan7
       
  1881         ].
       
  1882         ^ self reportLastMatch
       
  1883     ].
       
  1884     (currentCharacter == $&) ifTrue:[
       
  1885         self step.
       
  1886         (currentCharacter == $g or:[ currentCharacter == $l ]) ifTrue:[
       
  1887             ^ self scan5
       
  1888         ].
       
  1889         (currentCharacter == $#) ifTrue:[
       
  1890             self step.
       
  1891             (currentCharacter isXMLDigit) ifTrue:[
       
  1892                 [
       
  1893                     self step.
       
  1894                     (currentCharacter isXMLDigit)
       
  1895                 ] whileTrue.
       
  1896                 (currentCharacter == $;) ifTrue:[
       
  1897                     ^ self scan7
       
  1898                 ].
       
  1899                 ^ self reportLastMatch
       
  1900             ].
       
  1901             (currentCharacter == $x) ifTrue:[
       
  1902                 self step.
       
  1903                 (currentCharacter isXMLDigit 
       
  1904                     or:[
       
  1905                         (currentCharacter between:$A and:$F) 
       
  1906                             or:[ (currentCharacter between:$a and:$f) ]
       
  1907                     ]) 
       
  1908                         ifTrue:[
       
  1909                             [
       
  1910                                 self step.
       
  1911                                 (currentCharacter isXMLDigit 
       
  1912                                     or:[
       
  1913                                         (currentCharacter between:$A and:$F) 
       
  1914                                             or:[ (currentCharacter between:$a and:$f) ]
       
  1915                                     ])
       
  1916                             ] whileTrue.
       
  1917                             (currentCharacter == $;) ifTrue:[
       
  1918                                 ^ self scan7
       
  1919                             ].
       
  1920                             ^ self reportLastMatch
       
  1921                         ].
       
  1922                 ^ self reportLastMatch
       
  1923             ].
       
  1924             ^ self reportLastMatch
       
  1925         ].
       
  1926         (currentCharacter == $a) ifTrue:[
       
  1927             self step.
       
  1928             (currentCharacter == $m) ifTrue:[
       
  1929                 self step.
       
  1930                 (currentCharacter == $p) ifTrue:[
       
  1931                     ^ self scan6
       
  1932                 ].
       
  1933                 ^ self reportLastMatch
       
  1934             ].
       
  1935             (currentCharacter == $p) ifTrue:[
       
  1936                 self step.
       
  1937                 (currentCharacter == $o) ifTrue:[
       
  1938                     self step.
       
  1939                     (currentCharacter == $s) ifTrue:[
       
  1940                         ^ self scan6
       
  1941                     ].
       
  1942                     ^ self reportLastMatch
       
  1943                 ].
       
  1944                 ^ self reportLastMatch
       
  1945             ].
       
  1946             ^ self reportLastMatch
       
  1947         ].
       
  1948         (currentCharacter == $q) ifTrue:[
       
  1949             self step.
       
  1950             (currentCharacter == $u) ifTrue:[
       
  1951                 self step.
       
  1952                 (currentCharacter == $o) ifTrue:[
       
  1953                     ^ self scan5
       
  1954                 ].
       
  1955                 ^ self reportLastMatch
       
  1956             ].
       
  1957             ^ self reportLastMatch
       
  1958         ].
       
  1959         ^ self reportLastMatch
       
  1960     ].
       
  1961     ^ self reportLastMatch
       
  1962 !
       
  1963 
       
  1964 scan8
       
  1965     self step.
       
  1966     (currentCharacter == $t) ifTrue:[
       
  1967         ^ self scan9
       
  1968     ].
       
  1969     ^ self reportLastMatch
       
  1970 !
       
  1971 
       
  1972 scan9
       
  1973     self step.
       
  1974     (currentCharacter == $;) ifTrue:[
       
  1975         ^ self scan10
       
  1976     ].
       
  1977     ^ self reportLastMatch
       
  1978 !
       
  1979 
       
  1980 scanForToken
       
  1981     self step.
       
  1982     ((currentCharacter between:$A and:$Z) 
       
  1983         or:[
       
  1984             currentCharacter == $_ 
       
  1985                 or:[
       
  1986                     (currentCharacter between:$b and:$c) 
       
  1987                         or:[
       
  1988                             currentCharacter == $e 
       
  1989                                 or:[
       
  1990                                     (currentCharacter between:$g and:$o) 
       
  1991                                         or:[ (currentCharacter between:$q and:$z) ]
       
  1992                                 ]
       
  1993                         ]
       
  1994                 ]
       
  1995         ]) 
       
  1996             ifTrue:[ ^ self scan11 ].
       
  1997     (currentCharacter isXMLDigit) ifTrue:[
       
  1998         [
       
  1999             self recordMatch:#( 114 ).
       
  2000             self step.
       
  2001             (currentCharacter isXMLDigit)
       
  2002         ] whileTrue.
       
  2003         (currentCharacter == $E or:[ currentCharacter == $e ]) ifTrue:[
       
  2004             ^ self scan2
       
  2005         ].
       
  2006         (currentCharacter == $.) ifTrue:[
       
  2007             ^ self scan14
       
  2008         ].
       
  2009         ^ self reportLastMatch
       
  2010     ].
       
  2011     (currentCharacter isSeparator 
       
  2012         or:[ currentCharacter == (Character value:16rB) ]) 
       
  2013             ifTrue:[
       
  2014                 [
       
  2015                     self recordMatch:#whitespace.
       
  2016                     self step.
       
  2017                     (currentCharacter isSeparator 
       
  2018                         or:[ currentCharacter == (Character value:16rB) ])
       
  2019                 ] whileTrue.
       
  2020                 ^ self reportLastMatch
       
  2021             ].
       
  2022     (currentCharacter == $!!) ifTrue:[
       
  2023         self step.
       
  2024         (currentCharacter == $=) ifTrue:[
       
  2025             ^ self recordAndReportMatch:#( 26 ).
       
  2026         ].
       
  2027         ^ self reportLastMatch
       
  2028     ].
       
  2029     (currentCharacter == $") ifTrue:[
       
  2030         ^ self scan7
       
  2031     ].
       
  2032     (currentCharacter == $$) ifTrue:[
       
  2033         ^ self recordAndReportMatch:#( 35 ).
       
  2034     ].
       
  2035     (currentCharacter == $&) ifTrue:[
       
  2036         self step.
       
  2037         (currentCharacter == $g or:[ currentCharacter == $l ]) ifTrue:[
       
  2038             ^ self scan3
       
  2039         ].
       
  2040         (currentCharacter == $a) ifTrue:[
       
  2041             self step.
       
  2042             (currentCharacter == $m) ifTrue:[
       
  2043                 self step.
       
  2044                 (currentCharacter == $p) ifTrue:[
       
  2045                     ^ self scan4
       
  2046                 ].
       
  2047                 ^ self reportLastMatch
       
  2048             ].
       
  2049             (currentCharacter == $p) ifTrue:[
       
  2050                 self step.
       
  2051                 (currentCharacter == $o) ifTrue:[
       
  2052                     self step.
       
  2053                     (currentCharacter == $s) ifTrue:[
       
  2054                         ^ self scan4
       
  2055                     ].
       
  2056                     ^ self reportLastMatch
       
  2057                 ].
       
  2058                 ^ self reportLastMatch
       
  2059             ].
       
  2060             ^ self reportLastMatch
       
  2061         ].
       
  2062         (currentCharacter == $q) ifTrue:[
       
  2063             self step.
       
  2064             (currentCharacter == $u) ifTrue:[
       
  2065                 self step.
       
  2066                 (currentCharacter == $o) ifTrue:[
       
  2067                     ^ self scan3
       
  2068                 ].
       
  2069                 ^ self reportLastMatch
       
  2070             ].
       
  2071             ^ self reportLastMatch
       
  2072         ].
       
  2073         ^ self reportLastMatch
       
  2074     ].
       
  2075     (currentCharacter == $') ifTrue:[
       
  2076         ^ self scan10
       
  2077     ].
       
  2078     (currentCharacter == $() ifTrue:[
       
  2079         ^ self recordAndReportMatch:#( 30 ).
       
  2080     ].
       
  2081     (currentCharacter == $)) ifTrue:[
       
  2082         ^ self recordAndReportMatch:#( 31 ).
       
  2083     ].
       
  2084     (currentCharacter == $*) ifTrue:[
       
  2085         ^ self recordAndReportMatch:#( 4 ).
       
  2086     ].
       
  2087     (currentCharacter == $+) ifTrue:[
       
  2088         ^ self recordAndReportMatch:#( 2 ).
       
  2089     ].
       
  2090     (currentCharacter == $,) ifTrue:[
       
  2091         ^ self recordAndReportMatch:#( 32 ).
       
  2092     ].
       
  2093     (currentCharacter == $-) ifTrue:[
       
  2094         ^ self recordAndReportMatch:#( 3 ).
       
  2095     ].
       
  2096     (currentCharacter == $.) ifTrue:[
       
  2097         self recordMatch:#( 102 ).
       
  2098         self step.
       
  2099         (currentCharacter isXMLDigit) ifTrue:[
       
  2100             ^ self scan14
       
  2101         ].
       
  2102         (currentCharacter == $.) ifTrue:[
       
  2103             ^ self recordAndReportMatch:#( 104 ).
       
  2104         ].
       
  2105         ^ self reportLastMatch
       
  2106     ].
       
  2107     (currentCharacter == $/) ifTrue:[
       
  2108         self recordMatch:#( 96 ).
       
  2109         self step.
       
  2110         (currentCharacter == $/) ifTrue:[
       
  2111             ^ self recordAndReportMatch:#( 89 ).
       
  2112         ].
       
  2113         (currentCharacter == $>) ifTrue:[
       
  2114             ^ self recordAndReportMatch:#( 65 ).
       
  2115         ].
       
  2116         ^ self reportLastMatch
       
  2117     ].
       
  2118     (currentCharacter == $:) ifTrue:[
       
  2119         self recordMatch:#( 99 ).
       
  2120         self step.
       
  2121         (currentCharacter == $:) ifTrue:[
       
  2122             ^ self recordAndReportMatch:#( 85 ).
       
  2123         ].
       
  2124         (currentCharacter == $=) ifTrue:[
       
  2125             ^ self recordAndReportMatch:#( 53 ).
       
  2126         ].
       
  2127         ^ self reportLastMatch
       
  2128     ].
       
  2129     (currentCharacter == $;) ifTrue:[
       
  2130         ^ self recordAndReportMatch:#( 36 ).
       
  2131     ].
       
  2132     (currentCharacter == $<) ifTrue:[
       
  2133         self recordMatch:#( 19 ).
       
  2134         self step.
       
  2135         (currentCharacter == $/) ifTrue:[
       
  2136             ^ self recordAndReportMatch:#( 66 ).
       
  2137         ].
       
  2138         (currentCharacter == $<) ifTrue:[
       
  2139             ^ self recordAndReportMatch:#( 94 ).
       
  2140         ].
       
  2141         (currentCharacter == $=) ifTrue:[
       
  2142             ^ self recordAndReportMatch:#( 20 ).
       
  2143         ].
       
  2144         ^ self reportLastMatch
       
  2145     ].
       
  2146     (currentCharacter == $=) ifTrue:[
       
  2147         ^ self recordAndReportMatch:#( 34 ).
       
  2148     ].
       
  2149     (currentCharacter == $>) ifTrue:[
       
  2150         self recordMatch:#( 15 ).
       
  2151         self step.
       
  2152         (currentCharacter == $=) ifTrue:[
       
  2153             ^ self recordAndReportMatch:#( 16 ).
       
  2154         ].
       
  2155         (currentCharacter == $>) ifTrue:[
       
  2156             ^ self recordAndReportMatch:#( 95 ).
       
  2157         ].
       
  2158         ^ self reportLastMatch
       
  2159     ].
       
  2160     (currentCharacter == $@) ifTrue:[
       
  2161         ^ self recordAndReportMatch:#( 106 ).
       
  2162     ].
       
  2163     (currentCharacter == $[) ifTrue:[
       
  2164         ^ self recordAndReportMatch:#( 100 ).
       
  2165     ].
       
  2166     (currentCharacter == $]) ifTrue:[
       
  2167         ^ self recordAndReportMatch:#( 101 ).
       
  2168     ].
       
  2169     (currentCharacter == $a) ifTrue:[
       
  2170         self recordMatch:#( 112 113 ).
       
  2171         self step.
       
  2172         ((currentCharacter between:$- and:$.) 
       
  2173             or:[
       
  2174                 (currentCharacter between:$0 and:$9) 
       
  2175                     or:[
       
  2176                         (currentCharacter between:$A and:$Z) 
       
  2177                             or:[
       
  2178                                 currentCharacter == $_ 
       
  2179                                     or:[
       
  2180                                         (currentCharacter between:$a and:$m) 
       
  2181                                             or:[ (currentCharacter between:$o and:$z) ]
       
  2182                                     ]
       
  2183                             ]
       
  2184                     ]
       
  2185             ]) 
       
  2186                 ifTrue:[ ^ self scan11 ].
       
  2187         (currentCharacter == $:) ifTrue:[
       
  2188             ^ self scan1
       
  2189         ].
       
  2190         (currentCharacter == $n) ifTrue:[
       
  2191             self recordMatch:#( 112 113 ).
       
  2192             self step.
       
  2193             ((currentCharacter between:$- and:$.) 
       
  2194                 or:[
       
  2195                     (currentCharacter between:$0 and:$9) 
       
  2196                         or:[
       
  2197                             (currentCharacter between:$A and:$Z) 
       
  2198                                 or:[
       
  2199                                     currentCharacter == $_ 
       
  2200                                         or:[
       
  2201                                             (currentCharacter between:$a and:$b) 
       
  2202                                                 or:[ (currentCharacter between:$d and:$z) ]
       
  2203                                         ]
       
  2204                                 ]
       
  2205                         ]
       
  2206                 ]) 
       
  2207                     ifTrue:[ ^ self scan11 ].
       
  2208             (currentCharacter == $:) ifTrue:[
       
  2209                 ^ self scan1
       
  2210             ].
       
  2211             (currentCharacter == $c) ifTrue:[
       
  2212                 self recordMatch:#( 112 113 ).
       
  2213                 self step.
       
  2214                 (currentCharacter isXMLDigit 
       
  2215                     or:[
       
  2216                         (currentCharacter between:$- and:$.) 
       
  2217                             or:[
       
  2218                                 (currentCharacter between:$A and:$Z) 
       
  2219                                     or:[
       
  2220                                         currentCharacter == $_ 
       
  2221                                             or:[
       
  2222                                                 (currentCharacter between:$a and:$d) 
       
  2223                                                     or:[ (currentCharacter between:$f and:$z) ]
       
  2224                                             ]
       
  2225                                     ]
       
  2226                             ]
       
  2227                     ]) 
       
  2228                         ifTrue:[ ^ self scan11 ].
       
  2229                 (currentCharacter == $:) ifTrue:[
       
  2230                     ^ self scan1
       
  2231                 ].
       
  2232                 (currentCharacter == $e) ifTrue:[
       
  2233                     self recordMatch:#( 112 113 ).
       
  2234                     self step.
       
  2235                     ((currentCharacter between:$- and:$.) 
       
  2236                         or:[
       
  2237                             (currentCharacter between:$0 and:$9) 
       
  2238                                 or:[
       
  2239                                     (currentCharacter between:$A and:$Z) 
       
  2240                                         or:[
       
  2241                                             currentCharacter == $_ 
       
  2242                                                 or:[
       
  2243                                                     (currentCharacter between:$a and:$r) 
       
  2244                                                         or:[ (currentCharacter between:$t and:$z) ]
       
  2245                                                 ]
       
  2246                                         ]
       
  2247                                 ]
       
  2248                         ]) 
       
  2249                             ifTrue:[ ^ self scan11 ].
       
  2250                     (currentCharacter == $:) ifTrue:[
       
  2251                         ^ self scan1
       
  2252                     ].
       
  2253                     (currentCharacter == $s) ifTrue:[
       
  2254                         self recordMatch:#( 112 113 ).
       
  2255                         self step.
       
  2256                         ((currentCharacter between:$- and:$.) 
       
  2257                             or:[
       
  2258                                 (currentCharacter between:$0 and:$9) 
       
  2259                                     or:[
       
  2260                                         (currentCharacter between:$A and:$Z) 
       
  2261                                             or:[
       
  2262                                                 currentCharacter == $_ 
       
  2263                                                     or:[
       
  2264                                                         (currentCharacter between:$a and:$s) 
       
  2265                                                             or:[ (currentCharacter between:$u and:$z) ]
       
  2266                                                     ]
       
  2267                                             ]
       
  2268                                     ]
       
  2269                             ]) 
       
  2270                                 ifTrue:[ ^ self scan11 ].
       
  2271                         (currentCharacter == $:) ifTrue:[
       
  2272                             ^ self scan1
       
  2273                         ].
       
  2274                         (currentCharacter == $t) ifTrue:[
       
  2275                             self recordMatch:#( 112 113 ).
       
  2276                             self step.
       
  2277                             (currentCharacter isXMLDigit 
       
  2278                                 or:[
       
  2279                                     (currentCharacter between:$- and:$.) 
       
  2280                                         or:[
       
  2281                                             (currentCharacter between:$A and:$Z) 
       
  2282                                                 or:[
       
  2283                                                     currentCharacter == $_ 
       
  2284                                                         or:[
       
  2285                                                             (currentCharacter between:$a and:$n) 
       
  2286                                                                 or:[ (currentCharacter between:$p and:$z) ]
       
  2287                                                         ]
       
  2288                                                 ]
       
  2289                                         ]
       
  2290                                 ]) 
       
  2291                                     ifTrue:[ ^ self scan11 ].
       
  2292                             (currentCharacter == $:) ifTrue:[
       
  2293                                 ^ self scan1
       
  2294                             ].
       
  2295                             (currentCharacter == $o) ifTrue:[
       
  2296                                 self recordMatch:#( 112 113 ).
       
  2297                                 self step.
       
  2298                                 ((currentCharacter between:$- and:$.) 
       
  2299                                     or:[
       
  2300                                         (currentCharacter between:$0 and:$9) 
       
  2301                                             or:[
       
  2302                                                 (currentCharacter between:$A and:$Z) 
       
  2303                                                     or:[
       
  2304                                                         currentCharacter == $_ 
       
  2305                                                             or:[
       
  2306                                                                 (currentCharacter between:$a and:$q) 
       
  2307                                                                     or:[ (currentCharacter between:$s and:$z) ]
       
  2308                                                             ]
       
  2309                                                     ]
       
  2310                                             ]
       
  2311                                     ]) 
       
  2312                                         ifTrue:[ ^ self scan11 ].
       
  2313                                 (currentCharacter == $:) ifTrue:[
       
  2314                                     ^ self scan1
       
  2315                                 ].
       
  2316                                 (currentCharacter == $r) ifTrue:[
       
  2317                                     self recordMatch:#( 112 113 ).
       
  2318                                     self step.
       
  2319                                     (currentCharacter isLetterOrDigit 
       
  2320                                         or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
  2321                                             ifTrue:[ ^ self scan11 ].
       
  2322                                     (currentCharacter == $-) ifTrue:[
       
  2323                                         self recordMatch:#( 112 113 ).
       
  2324                                         self step.
       
  2325                                         (currentCharacter isXMLDigit 
       
  2326                                             or:[
       
  2327                                                 (currentCharacter between:$- and:$.) 
       
  2328                                                     or:[
       
  2329                                                         (currentCharacter between:$A and:$Z) 
       
  2330                                                             or:[
       
  2331                                                                 currentCharacter == $_ 
       
  2332                                                                     or:[
       
  2333                                                                         (currentCharacter between:$a and:$n) 
       
  2334                                                                             or:[ (currentCharacter between:$p and:$z) ]
       
  2335                                                                     ]
       
  2336                                                             ]
       
  2337                                                     ]
       
  2338                                             ]) 
       
  2339                                                 ifTrue:[ ^ self scan11 ].
       
  2340                                         (currentCharacter == $:) ifTrue:[
       
  2341                                             ^ self scan1
       
  2342                                         ].
       
  2343                                         (currentCharacter == $o) ifTrue:[
       
  2344                                             self recordMatch:#( 112 113 ).
       
  2345                                             self step.
       
  2346                                             ((currentCharacter between:$- and:$.) 
       
  2347                                                 or:[
       
  2348                                                     (currentCharacter between:$0 and:$9) 
       
  2349                                                         or:[
       
  2350                                                             (currentCharacter between:$A and:$Z) 
       
  2351                                                                 or:[
       
  2352                                                                     currentCharacter == $_ 
       
  2353                                                                         or:[
       
  2354                                                                             (currentCharacter between:$a and:$q) 
       
  2355                                                                                 or:[ (currentCharacter between:$s and:$z) ]
       
  2356                                                                         ]
       
  2357                                                                 ]
       
  2358                                                         ]
       
  2359                                                 ]) 
       
  2360                                                     ifTrue:[ ^ self scan11 ].
       
  2361                                             (currentCharacter == $:) ifTrue:[
       
  2362                                                 ^ self scan1
       
  2363                                             ].
       
  2364                                             (currentCharacter == $r) ifTrue:[
       
  2365                                                 self recordMatch:#( 112 113 ).
       
  2366                                                 self step.
       
  2367                                                 (currentCharacter isLetterOrDigit 
       
  2368                                                     or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
  2369                                                         ifTrue:[ ^ self scan11 ].
       
  2370                                                 (currentCharacter == $-) ifTrue:[
       
  2371                                                     self recordMatch:#( 112 113 ).
       
  2372                                                     self step.
       
  2373                                                     ((currentCharacter between:$- and:$.) 
       
  2374                                                         or:[
       
  2375                                                             (currentCharacter between:$0 and:$9) 
       
  2376                                                                 or:[
       
  2377                                                                     (currentCharacter between:$A and:$Z) 
       
  2378                                                                         or:[
       
  2379                                                                             currentCharacter == $_ 
       
  2380                                                                                 or:[
       
  2381                                                                                     (currentCharacter between:$a and:$r) 
       
  2382                                                                                         or:[ (currentCharacter between:$t and:$z) ]
       
  2383                                                                                 ]
       
  2384                                                                         ]
       
  2385                                                                 ]
       
  2386                                                         ]) 
       
  2387                                                             ifTrue:[ ^ self scan11 ].
       
  2388                                                     (currentCharacter == $:) ifTrue:[
       
  2389                                                         ^ self scan1
       
  2390                                                     ].
       
  2391                                                     (currentCharacter == $s) ifTrue:[
       
  2392                                                         self recordMatch:#( 112 113 ).
       
  2393                                                         self step.
       
  2394                                                         (currentCharacter isXMLDigit 
       
  2395                                                             or:[
       
  2396                                                                 (currentCharacter between:$- and:$.) 
       
  2397                                                                     or:[
       
  2398                                                                         (currentCharacter between:$A and:$Z) 
       
  2399                                                                             or:[
       
  2400                                                                                 currentCharacter == $_ 
       
  2401                                                                                     or:[
       
  2402                                                                                         (currentCharacter between:$a and:$d) 
       
  2403                                                                                             or:[ (currentCharacter between:$f and:$z) ]
       
  2404                                                                                     ]
       
  2405                                                                             ]
       
  2406                                                                     ]
       
  2407                                                             ]) 
       
  2408                                                                 ifTrue:[ ^ self scan11 ].
       
  2409                                                         (currentCharacter == $:) ifTrue:[
       
  2410                                                             ^ self scan1
       
  2411                                                         ].
       
  2412                                                         (currentCharacter == $e) ifTrue:[
       
  2413                                                             self recordMatch:#( 112 113 ).
       
  2414                                                             self step.
       
  2415                                                             ((currentCharacter between:$- and:$.) 
       
  2416                                                                 or:[
       
  2417                                                                     (currentCharacter between:$0 and:$9) 
       
  2418                                                                         or:[
       
  2419                                                                             (currentCharacter between:$A and:$Z) 
       
  2420                                                                                 or:[
       
  2421                                                                                     currentCharacter == $_ 
       
  2422                                                                                         or:[
       
  2423                                                                                             (currentCharacter between:$a and:$k) 
       
  2424                                                                                                 or:[ (currentCharacter between:$m and:$z) ]
       
  2425                                                                                         ]
       
  2426                                                                                 ]
       
  2427                                                                         ]
       
  2428                                                                 ]) 
       
  2429                                                                     ifTrue:[ ^ self scan11 ].
       
  2430                                                             (currentCharacter == $:) ifTrue:[
       
  2431                                                                 ^ self scan1
       
  2432                                                             ].
       
  2433                                                             (currentCharacter == $l) ifTrue:[
       
  2434                                                                 self recordMatch:#( 112 113 ).
       
  2435                                                                 self step.
       
  2436                                                                 ((currentCharacter between:$- and:$.) 
       
  2437                                                                     or:[
       
  2438                                                                         (currentCharacter between:$0 and:$9) 
       
  2439                                                                             or:[
       
  2440                                                                                 (currentCharacter between:$A and:$Z) 
       
  2441                                                                                     or:[
       
  2442                                                                                         currentCharacter == $_ 
       
  2443                                                                                             or:[
       
  2444                                                                                                 (currentCharacter between:$a and:$e) 
       
  2445                                                                                                     or:[ (currentCharacter between:$g and:$z) ]
       
  2446                                                                                             ]
       
  2447                                                                                     ]
       
  2448                                                                             ]
       
  2449                                                                     ]) 
       
  2450                                                                         ifTrue:[ ^ self scan11 ].
       
  2451                                                                 (currentCharacter == $:) ifTrue:[
       
  2452                                                                     ^ self scan1
       
  2453                                                                 ].
       
  2454                                                                 (currentCharacter == $f) ifTrue:[
       
  2455                                                                     self recordMatch:#( 109 112 113 ).
       
  2456                                                                     self step.
       
  2457                                                                     (currentCharacter isLetterOrDigit 
       
  2458                                                                         or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ]) 
       
  2459                                                                             ifTrue:[ ^ self scan11 ].
       
  2460                                                                     (currentCharacter == $:) ifTrue:[
       
  2461                                                                         ^ self scan1
       
  2462                                                                     ].
       
  2463                                                                     ^ self reportLastMatch
       
  2464                                                                 ].
       
  2465                                                                 ^ self reportLastMatch
       
  2466                                                             ].
       
  2467                                                             ^ self reportLastMatch
       
  2468                                                         ].
       
  2469                                                         ^ self reportLastMatch
       
  2470                                                     ].
       
  2471                                                     ^ self reportLastMatch
       
  2472                                                 ].
       
  2473                                                 (currentCharacter == $:) ifTrue:[
       
  2474                                                     ^ self scan1
       
  2475                                                 ].
       
  2476                                                 ^ self reportLastMatch
       
  2477                                             ].
       
  2478                                             ^ self reportLastMatch
       
  2479                                         ].
       
  2480                                         ^ self reportLastMatch
       
  2481                                     ].
       
  2482                                     (currentCharacter == $:) ifTrue:[
       
  2483                                         ^ self scan1
       
  2484                                     ].
       
  2485                                     ^ self reportLastMatch
       
  2486                                 ].
       
  2487                                 ^ self reportLastMatch
       
  2488                             ].
       
  2489                             ^ self reportLastMatch
       
  2490                         ].
       
  2491                         ^ self reportLastMatch
       
  2492                     ].
       
  2493                     ^ self reportLastMatch
       
  2494                 ].
       
  2495                 ^ self reportLastMatch
       
  2496             ].
       
  2497             ^ self reportLastMatch
       
  2498         ].
       
  2499         ^ self reportLastMatch
       
  2500     ].
       
  2501     (currentCharacter == $d) ifTrue:[
       
  2502         ^ self scan13
       
  2503     ].
       
  2504     (currentCharacter == $f) ifTrue:[
       
  2505         self recordMatch:#( 112 113 ).
       
  2506         self step.
       
  2507         (currentCharacter isXMLDigit 
       
  2508             or:[
       
  2509                 (currentCharacter between:$- and:$.) 
       
  2510                     or:[
       
  2511                         (currentCharacter between:$A and:$Z) 
       
  2512                             or:[
       
  2513                                 currentCharacter == $_ 
       
  2514                                     or:[
       
  2515                                         (currentCharacter between:$a and:$n) 
       
  2516                                             or:[ (currentCharacter between:$p and:$z) ]
       
  2517                                     ]
       
  2518                             ]
       
  2519                     ]
       
  2520             ]) 
       
  2521                 ifTrue:[ ^ self scan11 ].
       
  2522         (currentCharacter == $:) ifTrue:[
       
  2523             ^ self scan1
       
  2524         ].
       
  2525         (currentCharacter == $o) ifTrue:[
       
  2526             self recordMatch:#( 112 113 ).
       
  2527             self step.
       
  2528             ((currentCharacter between:$- and:$.) 
       
  2529                 or:[
       
  2530                     (currentCharacter between:$0 and:$9) 
       
  2531                         or:[
       
  2532                             (currentCharacter between:$A and:$Z) 
       
  2533                                 or:[
       
  2534                                     currentCharacter == $_ 
       
  2535                                         or:[
       
  2536                                             (currentCharacter between:$a and:$k) 
       
  2537                                                 or:[ (currentCharacter between:$m and:$z) ]
       
  2538                                         ]
       
  2539                                 ]
       
  2540                         ]
       
  2541                 ]) 
       
  2542                     ifTrue:[ ^ self scan11 ].
       
  2543             (currentCharacter == $:) ifTrue:[
       
  2544                 ^ self scan1
       
  2545             ].
       
  2546             (currentCharacter == $l) ifTrue:[
       
  2547                 self recordMatch:#( 112 113 ).
       
  2548                 self step.
       
  2549                 ((currentCharacter between:$- and:$.) 
       
  2550                     or:[
       
  2551                         (currentCharacter between:$0 and:$9) 
       
  2552                             or:[
       
  2553                                 (currentCharacter between:$A and:$Z) 
       
  2554                                     or:[
       
  2555                                         currentCharacter == $_ 
       
  2556                                             or:[
       
  2557                                                 (currentCharacter between:$a and:$k) 
       
  2558                                                     or:[ (currentCharacter between:$m and:$z) ]
       
  2559                                             ]
       
  2560                                     ]
       
  2561                             ]
       
  2562                     ]) 
       
  2563                         ifTrue:[ ^ self scan11 ].
       
  2564                 (currentCharacter == $:) ifTrue:[
       
  2565                     ^ self scan1
       
  2566                 ].
       
  2567                 (currentCharacter == $l) ifTrue:[
       
  2568                     self recordMatch:#( 112 113 ).
       
  2569                     self step.
       
  2570                     (currentCharacter isXMLDigit 
       
  2571                         or:[
       
  2572                             (currentCharacter between:$- and:$.) 
       
  2573                                 or:[
       
  2574                                     (currentCharacter between:$A and:$Z) 
       
  2575                                         or:[
       
  2576                                             currentCharacter == $_ 
       
  2577                                                 or:[
       
  2578                                                     (currentCharacter between:$a and:$n) 
       
  2579                                                         or:[ (currentCharacter between:$p and:$z) ]
       
  2580                                                 ]
       
  2581                                         ]
       
  2582                                 ]
       
  2583                         ]) 
       
  2584                             ifTrue:[ ^ self scan11 ].
       
  2585                     (currentCharacter == $:) ifTrue:[
       
  2586                         ^ self scan1
       
  2587                     ].
       
  2588                     (currentCharacter == $o) ifTrue:[
       
  2589                         self recordMatch:#( 112 113 ).
       
  2590                         self step.
       
  2591                         ((currentCharacter between:$- and:$.) 
       
  2592                             or:[
       
  2593                                 (currentCharacter between:$0 and:$9) 
       
  2594                                     or:[
       
  2595                                         (currentCharacter between:$A and:$Z) 
       
  2596                                             or:[
       
  2597                                                 currentCharacter == $_ 
       
  2598                                                     or:[
       
  2599                                                         (currentCharacter between:$a and:$v) 
       
  2600                                                             or:[ (currentCharacter between:$x and:$z) ]
       
  2601                                                     ]
       
  2602                                             ]
       
  2603                                     ]
       
  2604                             ]) 
       
  2605                                 ifTrue:[ ^ self scan11 ].
       
  2606                         (currentCharacter == $:) ifTrue:[
       
  2607                             ^ self scan1
       
  2608                         ].
       
  2609                         (currentCharacter == $w) ifTrue:[
       
  2610                             self recordMatch:#( 112 113 ).
       
  2611                             self step.
       
  2612                             (currentCharacter isXMLDigit 
       
  2613                                 or:[
       
  2614                                     (currentCharacter between:$- and:$.) 
       
  2615                                         or:[
       
  2616                                             (currentCharacter between:$A and:$Z) 
       
  2617                                                 or:[
       
  2618                                                     currentCharacter == $_ 
       
  2619                                                         or:[
       
  2620                                                             (currentCharacter between:$a and:$h) 
       
  2621                                                                 or:[ (currentCharacter between:$j and:$z) ]
       
  2622                                                         ]
       
  2623                                                 ]
       
  2624                                         ]
       
  2625                                 ]) 
       
  2626                                     ifTrue:[ ^ self scan11 ].
       
  2627                             (currentCharacter == $:) ifTrue:[
       
  2628                                 ^ self scan1
       
  2629                             ].
       
  2630                             (currentCharacter == $i) ifTrue:[
       
  2631                                 self recordMatch:#( 112 113 ).
       
  2632                                 self step.
       
  2633                                 ((currentCharacter between:$- and:$.) 
       
  2634                                     or:[
       
  2635                                         (currentCharacter between:$0 and:$9) 
       
  2636                                             or:[
       
  2637                                                 (currentCharacter between:$A and:$Z) 
       
  2638                                                     or:[
       
  2639                                                         currentCharacter == $_ 
       
  2640                                                             or:[
       
  2641                                                                 (currentCharacter between:$a and:$m) 
       
  2642                                                                     or:[ (currentCharacter between:$o and:$z) ]
       
  2643                                                             ]
       
  2644                                                     ]
       
  2645                                             ]
       
  2646                                     ]) 
       
  2647                                         ifTrue:[ ^ self scan11 ].
       
  2648                                 (currentCharacter == $:) ifTrue:[
       
  2649                                     ^ self scan1
       
  2650                                 ].
       
  2651                                 (currentCharacter == $n) ifTrue:[
       
  2652                                     self recordMatch:#( 112 113 ).
       
  2653                                     self step.
       
  2654                                     ((currentCharacter between:$- and:$.) 
       
  2655                                         or:[
       
  2656                                             (currentCharacter between:$0 and:$9) 
       
  2657                                                 or:[
       
  2658                                                     (currentCharacter between:$A and:$Z) 
       
  2659                                                         or:[
       
  2660                                                             currentCharacter == $_ 
       
  2661                                                                 or:[
       
  2662                                                                     (currentCharacter between:$a and:$f) 
       
  2663                                                                         or:[ (currentCharacter between:$h and:$z) ]
       
  2664                                                                 ]
       
  2665                                                         ]
       
  2666                                                 ]
       
  2667                                         ]) 
       
  2668                                             ifTrue:[ ^ self scan11 ].
       
  2669                                     (currentCharacter == $:) ifTrue:[
       
  2670                                         ^ self scan1
       
  2671                                     ].
       
  2672                                     (currentCharacter == $g) ifTrue:[
       
  2673                                         self recordMatch:#( 112 113 ).
       
  2674                                         self step.
       
  2675                                         (currentCharacter isLetterOrDigit 
       
  2676                                             or:[ currentCharacter == $. or:[ currentCharacter == $_ ] ]) 
       
  2677                                                 ifTrue:[ ^ self scan11 ].
       
  2678                                         (currentCharacter == $-) ifTrue:[
       
  2679                                             self recordMatch:#( 112 113 ).
       
  2680                                             self step.
       
  2681                                             ((currentCharacter between:$- and:$.) 
       
  2682                                                 or:[
       
  2683                                                     (currentCharacter between:$0 and:$9) 
       
  2684                                                         or:[
       
  2685                                                             (currentCharacter between:$A and:$Z) 
       
  2686                                                                 or:[
       
  2687                                                                     currentCharacter == $_ 
       
  2688                                                                         or:[
       
  2689                                                                             (currentCharacter between:$a and:$r) 
       
  2690                                                                                 or:[ (currentCharacter between:$t and:$z) ]
       
  2691                                                                         ]
       
  2692                                                                 ]
       
  2693                                                         ]
       
  2694                                                 ]) 
       
  2695                                                     ifTrue:[ ^ self scan11 ].
       
  2696                                             (currentCharacter == $:) ifTrue:[
       
  2697                                                 ^ self scan1
       
  2698                                             ].
       
  2699                                             (currentCharacter == $s) ifTrue:[
       
  2700                                                 self recordMatch:#( 112 113 ).
       
  2701                                                 self step.
       
  2702                                                 (currentCharacter isXMLDigit 
       
  2703                                                     or:[
       
  2704                                                         (currentCharacter between:$- and:$.) 
       
  2705                                                             or:[
       
  2706                                                                 (currentCharacter between:$A and:$Z) 
       
  2707                                                                     or:[
       
  2708                                                                         currentCharacter == $_ 
       
  2709                                                                             or:[
       
  2710                                                                                 (currentCharacter between:$a and:$h) 
       
  2711                                                                                     or:[ (currentCharacter between:$j and:$z) ]
       
  2712                                                                             ]
       
  2713                                                                     ]
       
  2714                                                             ]
       
  2715                                                     ]) 
       
  2716                                                         ifTrue:[ ^ self scan11 ].
       
  2717                                                 (currentCharacter == $:) ifTrue:[
       
  2718                                                     ^ self scan1
       
  2719                                                 ].
       
  2720                                                 (currentCharacter == $i) ifTrue:[
       
  2721                                                     self recordMatch:#( 112 113 ).
       
  2722                                                     self step.
       
  2723                                                     ((currentCharacter between:$- and:$.) 
       
  2724                                                         or:[
       
  2725                                                             (currentCharacter between:$0 and:$9) 
       
  2726                                                                 or:[
       
  2727                                                                     (currentCharacter between:$A and:$Z) 
       
  2728                                                                         or:[
       
  2729                                                                             currentCharacter == $_ 
       
  2730                                                                                 or:[ currentCharacter == $a or:[ (currentCharacter between:$c and:$z) ] ]
       
  2731                                                                         ]
       
  2732                                                                 ]
       
  2733                                                         ]) 
       
  2734                                                             ifTrue:[ ^ self scan11 ].
       
  2735                                                     (currentCharacter == $:) ifTrue:[
       
  2736                                                         ^ self scan1
       
  2737                                                     ].
       
  2738                                                     (currentCharacter == $b) ifTrue:[
       
  2739                                                         self recordMatch:#( 112 113 ).
       
  2740                                                         self step.
       
  2741                                                         ((currentCharacter between:$- and:$.) 
       
  2742                                                             or:[
       
  2743                                                                 (currentCharacter between:$0 and:$9) 
       
  2744                                                                     or:[
       
  2745                                                                         (currentCharacter between:$A and:$Z) 
       
  2746                                                                             or:[
       
  2747                                                                                 currentCharacter == $_ 
       
  2748                                                                                     or:[
       
  2749                                                                                         (currentCharacter between:$a and:$k) 
       
  2750                                                                                             or:[ (currentCharacter between:$m and:$z) ]
       
  2751                                                                                     ]
       
  2752                                                                             ]
       
  2753                                                                     ]
       
  2754                                                             ]) 
       
  2755                                                                 ifTrue:[ ^ self scan11 ].
       
  2756                                                         (currentCharacter == $:) ifTrue:[
       
  2757                                                             ^ self scan1
       
  2758                                                         ].
       
  2759                                                         (currentCharacter == $l) ifTrue:[
       
  2760                                                             self recordMatch:#( 112 113 ).
       
  2761                                                             self step.
       
  2762                                                             (currentCharacter isXMLDigit 
       
  2763                                                                 or:[
       
  2764                                                                     (currentCharacter between:$- and:$.) 
       
  2765                                                                         or:[
       
  2766                                                                             (currentCharacter between:$A and:$Z) 
       
  2767                                                                                 or:[
       
  2768                                                                                     currentCharacter == $_ 
       
  2769                                                                                         or:[
       
  2770                                                                                             (currentCharacter between:$a and:$h) 
       
  2771                                                                                                 or:[ (currentCharacter between:$j and:$z) ]
       
  2772                                                                                         ]
       
  2773                                                                                 ]
       
  2774                                                                         ]
       
  2775                                                                 ]) 
       
  2776                                                                     ifTrue:[ ^ self scan11 ].
       
  2777                                                             (currentCharacter == $:) ifTrue:[
       
  2778                                                                 ^ self scan1
       
  2779                                                             ].
       
  2780                                                             (currentCharacter == $i) ifTrue:[
       
  2781                                                                 self recordMatch:#( 112 113 ).
       
  2782                                                                 self step.
       
  2783                                                                 ((currentCharacter between:$- and:$.) 
       
  2784                                                                     or:[
       
  2785                                                                         (currentCharacter between:$0 and:$9) 
       
  2786                                                                             or:[
       
  2787                                                                                 (currentCharacter between:$A and:$Z) 
       
  2788                                                                                     or:[
       
  2789                                                                                         currentCharacter == $_ 
       
  2790                                                                                             or:[
       
  2791                                                                                                 (currentCharacter between:$a and:$m) 
       
  2792                                                                                                     or:[ (currentCharacter between:$o and:$z) ]
       
  2793                                                                                             ]
       
  2794                                                                                     ]
       
  2795                                                                             ]
       
  2796                                                                     ]) 
       
  2797                                                                         ifTrue:[ ^ self scan11 ].
       
  2798                                                                 (currentCharacter == $:) ifTrue:[
       
  2799                                                                     ^ self scan1
       
  2800                                                                 ].
       
  2801                                                                 (currentCharacter == $n) ifTrue:[
       
  2802                                                                     self recordMatch:#( 112 113 ).
       
  2803                                                                     self step.
       
  2804                                                                     ((currentCharacter between:$- and:$.) 
       
  2805                                                                         or:[
       
  2806                                                                             (currentCharacter between:$0 and:$9) 
       
  2807                                                                                 or:[
       
  2808                                                                                     (currentCharacter between:$A and:$Z) 
       
  2809                                                                                         or:[
       
  2810                                                                                             currentCharacter == $_ 
       
  2811                                                                                                 or:[
       
  2812                                                                                                     (currentCharacter between:$a and:$f) 
       
  2813                                                                                                         or:[ (currentCharacter between:$h and:$z) ]
       
  2814                                                                                                 ]
       
  2815                                                                                         ]
       
  2816                                                                                 ]
       
  2817                                                                         ]) 
       
  2818                                                                             ifTrue:[ ^ self scan11 ].
       
  2819                                                                     (currentCharacter == $:) ifTrue:[
       
  2820                                                                         ^ self scan1
       
  2821                                                                     ].
       
  2822                                                                     (currentCharacter == $g) ifTrue:[
       
  2823                                                                         self recordMatch:#( 97 112 113 ).
       
  2824                                                                         self step.
       
  2825                                                                         (currentCharacter isLetterOrDigit 
       
  2826                                                                             or:[ (currentCharacter between:$- and:$.) or:[ currentCharacter == $_ ] ]) 
       
  2827                                                                                 ifTrue:[ ^ self scan11 ].
       
  2828                                                                         (currentCharacter == $:) ifTrue:[
       
  2829                                                                             ^ self scan1
       
  2830                                                                         ].
       
  2831                                                                         ^ self reportLastMatch
       
  2832                                                                     ].
       
  2833                                                                     ^ self reportLastMatch
       
  2834                                                                 ].
       
  2835                                                                 ^ self reportLastMatch
       
  2836                                                             ].
       
  2837                                                             ^ self reportLastMatch
       
  2838                                                         ].
       
  2839                                                         ^ self reportLastMatch
       
  2840                                                     ].
       
  2841                                                     ^ self reportLastMatch
       
  2842                                                 ].
       
  2843                                                 ^ self reportLastMatch
       
  2844                                             ].
       
  2845                                             ^ self reportLastMatch
       
  2846                                         ].
       
  2847                                         (currentCharacter == $:) ifTrue:[
       
  2848                                             ^ self scan1
       
  2849                                         ].
       
  2850                                         ^ self reportLastMatch
       
  2851                                     ].
       
  2852                                     ^ self reportLastMatch
       
  2853                                 ].
       
  2854                                 ^ self reportLastMatch
       
  2855                             ].
       
  2856                             ^ self reportLastMatch
       
  2857                         ].
       
  2858                         ^ self reportLastMatch
       
  2859                     ].
       
  2860                     ^ self reportLastMatch
       
  2861                 ].
       
  2862                 ^ self reportLastMatch
       
  2863             ].
       
  2864             ^ self reportLastMatch
       
  2865         ].
       
  2866         ^ self reportLastMatch
       
  2867     ].
       
  2868     (currentCharacter == $p) ifTrue:[
       
  2869         ^ self scan12
       
  2870     ].
       
  2871     (currentCharacter == ${) ifTrue:[
       
  2872         ^ self recordAndReportMatch:#( 77 ).
       
  2873     ].
       
  2874     (currentCharacter == $|) ifTrue:[
       
  2875         ^ self recordAndReportMatch:#( 23 ).
       
  2876     ].
       
  2877     (currentCharacter == $}) ifTrue:[
       
  2878         ^ self recordAndReportMatch:#( 70 ).
       
  2879     ].
       
  2880     ^ self reportLastMatch
       
  2881 ! !
       
  2882 
       
  2883 !XQueryScanner methodsFor:'generated-tokens'!
       
  2884 
       
  2885 emptySymbolTokenId
       
  2886 	^235
       
  2887 !
       
  2888 
       
  2889 errorTokenId
       
  2890 	^236
       
  2891 ! !
       
  2892 
       
  2893 !XQueryScanner class methodsFor:'documentation'!
       
  2894 
       
  2895 version
       
  2896     ^ '$Header: /opt/data/cvs/stx/goodies/xmlsuite/xquery/XQuery__XQueryScanner.st,v 1.11 2008-01-02 14:07:19 wrobll1 Exp $'
       
  2897 ! !