/[suikacvs]/markup/html/whatpm/Whatpm/HTML/Tokenizer.pm
Suika

Diff of /markup/html/whatpm/Whatpm/HTML/Tokenizer.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.18 by wakaba, Sun Oct 19 06:14:57 2008 UTC revision 1.24 by wakaba, Sun Oct 19 14:05:20 2008 UTC
# Line 182  sub NDATA_STATE () { 86 } Line 182  sub NDATA_STATE () { 86 }
182  sub AFTER_NDATA_STATE () { 87 }  sub AFTER_NDATA_STATE () { 87 }
183  sub BEFORE_NOTATION_NAME_STATE () { 88 }  sub BEFORE_NOTATION_NAME_STATE () { 88 }
184  sub NOTATION_NAME_STATE () { 89 }  sub NOTATION_NAME_STATE () { 89 }
185  sub AFTER_NOTATION_NAME_STATE () { 90 }  sub DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE () { 90 }
186  sub BOGUS_MD_STATE () { 91 }  sub DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE () { 91 }
187    sub ENTITY_VALUE_ENTITY_STATE () { 92 }
188    sub AFTER_ELEMENT_NAME_STATE () { 93 }
189    sub BEFORE_ELEMENT_CONTENT_STATE () { 94 }
190    sub CONTENT_KEYWORD_STATE () { 95 }
191    sub AFTER_CM_GROUP_OPEN_STATE () { 96 }
192    sub CM_ELEMENT_NAME_STATE () { 97 }
193    sub AFTER_CM_ELEMENT_NAME_STATE () { 98 }
194    sub AFTER_CM_GROUP_CLOSE_STATE () { 99 }
195    sub AFTER_MD_DEF_STATE () { 100 }
196    sub BOGUS_MD_STATE () { 101 }
197    
198  ## Tree constructor state constants (see Whatpm::HTML for the full  ## Tree constructor state constants (see Whatpm::HTML for the full
199  ## list and descriptions)  ## list and descriptions)
# Line 3262  sub _get_next_token ($) { Line 3272  sub _get_next_token ($) {
3272      }      }
3273        
3274          redo A;          redo A;
3275  ## TODO: " and ' for ENTITY        } elsif ($self->{nc} == 0x0022 and # "
3276                   ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
3277                    $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
3278            
3279            $self->{state} = DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE;
3280            $self->{ct}->{value} = ''; # ENTITY
3281            
3282        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
3283          $self->{line_prev} = $self->{line};
3284          $self->{column_prev} = $self->{column};
3285          $self->{column}++;
3286          $self->{nc}
3287              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
3288        } else {
3289          $self->{set_nc}->($self);
3290        }
3291      
3292            redo A;
3293          } elsif ($self->{nc} == 0x0027 and # '
3294                   ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
3295                    $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
3296            
3297            $self->{state} = DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE;
3298            $self->{ct}->{value} = ''; # ENTITY
3299            
3300        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
3301          $self->{line_prev} = $self->{line};
3302          $self->{column_prev} = $self->{column};
3303          $self->{column}++;
3304          $self->{nc}
3305              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
3306        } else {
3307          $self->{set_nc}->($self);
3308        }
3309      
3310            redo A;
3311        } elsif ($self->{is_xml} and        } elsif ($self->{is_xml} and
3312                 $self->{ct}->{type} == DOCTYPE_TOKEN and                 $self->{ct}->{type} == DOCTYPE_TOKEN and
3313                 $self->{nc} == 0x005B) { # [                 $self->{nc} == 0x005B) { # [
# Line 4583  sub _get_next_token ($) { Line 4628  sub _get_next_token ($) {
4628              0x003C => 1, 0x0026 => 1, -1 => 1, # <, &              0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
4629              $self->{entity_add} => 1,              $self->{entity_add} => 1,
4630            }->{$self->{nc}}) {            }->{$self->{nc}}) {
4631                    if ($self->{is_xml}) {
4632              
4633              $self->{parse_error}->(level => $self->{level}->{must}, type => 'bare ero',
4634                              line => $self->{line_prev},
4635                              column => $self->{column_prev}
4636                                  + ($self->{nc} == -1 ? 1 : 0));
4637            } else {
4638              
4639              ## No error
4640            }
4641          ## Don't consume          ## Don't consume
         ## No error  
4642          ## Return nothing.          ## Return nothing.
4643          #          #
4644        } elsif ($self->{nc} == 0x0023) { # #        } elsif ($self->{nc} == 0x0023) { # #
# Line 4604  sub _get_next_token ($) { Line 4657  sub _get_next_token ($) {
4657      }      }
4658        
4659          redo A;          redo A;
4660        } elsif ((0x0041 <= $self->{nc} and        } elsif ($self->{is_xml} or
4661                   (0x0041 <= $self->{nc} and
4662                  $self->{nc} <= 0x005A) or # A..Z                  $self->{nc} <= 0x005A) or # A..Z
4663                 (0x0061 <= $self->{nc} and                 (0x0061 <= $self->{nc} and
4664                  $self->{nc} <= 0x007A)) { # a..z                  $self->{nc} <= 0x007A)) { # a..z
# Line 4658  sub _get_next_token ($) { Line 4712  sub _get_next_token ($) {
4712          redo A;          redo A;
4713        }        }
4714      } elsif ($self->{state} == ENTITY_HASH_STATE) {      } elsif ($self->{state} == ENTITY_HASH_STATE) {
4715        if ($self->{nc} == 0x0078 or # x        if ($self->{nc} == 0x0078) { # x
           $self->{nc} == 0x0058) { # X  
4716                    
4717          $self->{state} = HEXREF_X_STATE;          $self->{state} = HEXREF_X_STATE;
4718          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
# Line 4675  sub _get_next_token ($) { Line 4728  sub _get_next_token ($) {
4728      }      }
4729        
4730          redo A;          redo A;
4731          } elsif ($self->{nc} == 0x0058) { # X
4732            
4733            if ($self->{is_xml}) {
4734              $self->{parse_error}->(level => $self->{level}->{must}, type => 'uppercase hcro'); ## TODO: type
4735            }
4736            $self->{state} = HEXREF_X_STATE;
4737            $self->{kwd} .= chr $self->{nc};
4738            
4739        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
4740          $self->{line_prev} = $self->{line};
4741          $self->{column_prev} = $self->{column};
4742          $self->{column}++;
4743          $self->{nc}
4744              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
4745        } else {
4746          $self->{set_nc}->($self);
4747        }
4748      
4749            redo A;
4750        } elsif (0x0030 <= $self->{nc} and        } elsif (0x0030 <= $self->{nc} and
4751                 $self->{nc} <= 0x0039) { # 0..9                 $self->{nc} <= 0x0039) { # 0..9
4752                    
# Line 4952  sub _get_next_token ($) { Line 5024  sub _get_next_token ($) {
5024          redo A;          redo A;
5025        }        }
5026      } elsif ($self->{state} == ENTITY_NAME_STATE) {      } elsif ($self->{state} == ENTITY_NAME_STATE) {
5027        if (length $self->{kwd} < 30 and        if ((0x0041 <= $self->{nc} and # a
5028            ## NOTE: Some number greater than the maximum length of entity name             $self->{nc} <= 0x005A) or # x
5029            ((0x0041 <= $self->{nc} and # a            (0x0061 <= $self->{nc} and # a
5030              $self->{nc} <= 0x005A) or # x             $self->{nc} <= 0x007A) or # z
5031             (0x0061 <= $self->{nc} and # a            (0x0030 <= $self->{nc} and # 0
5032              $self->{nc} <= 0x007A) or # z             $self->{nc} <= 0x0039) or # 9
5033             (0x0030 <= $self->{nc} and # 0            $self->{nc} == 0x003B or # ;
5034              $self->{nc} <= 0x0039) or # 9            ($self->{is_xml} and
5035             $self->{nc} == 0x003B)) { # ;             not ($is_space->{$self->{nc}} or
5036                    {
5037                      0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
5038                      $self->{entity_add} => 1,
5039                    }->{$self->{nc}}))) {
5040          our $EntityChar;          our $EntityChar;
5041          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
5042          if (defined $EntityChar->{$self->{kwd}}) {          if (defined $EntityChar->{$self->{kwd}} or
5043                $self->{ge}->{$self->{kwd}}) {
5044            if ($self->{nc} == 0x003B) { # ;            if ($self->{nc} == 0x003B) { # ;
5045                            if (defined $self->{ge}->{$self->{kwd}}) {
5046              $self->{entity__value} = $EntityChar->{$self->{kwd}};                if ($self->{ge}->{$self->{kwd}}->{only_text}) {
5047                    
5048                    $self->{entity__value} = $self->{ge}->{$self->{kwd}}->{value};
5049                  } else {
5050                    if (defined $self->{ge}->{$self->{kwd}}->{notation}) {
5051                      
5052                      $self->{parse_error}->(level => $self->{level}->{must}, type => 'unparsed entity', ## TODO: type
5053                                      value => $self->{kwd});
5054                    } else {
5055                      
5056                    }
5057                    $self->{entity__value} = '&' . $self->{kwd}; ## TODO: expand
5058                  }
5059                } else {
5060                  if ($self->{is_xml}) {
5061                    
5062                    $self->{parse_error}->(level => $self->{level}->{must}, type => 'entity not declared', ## TODO: type
5063                                    value => $self->{kwd},
5064                                    level => {
5065                                              'amp;' => $self->{level}->{warn},
5066                                              'quot;' => $self->{level}->{warn},
5067                                              'lt;' => $self->{level}->{warn},
5068                                              'gt;' => $self->{level}->{warn},
5069                                              'apos;' => $self->{level}->{warn},
5070                                             }->{$self->{kwd}} ||
5071                                             $self->{level}->{must});
5072                  } else {
5073                    
5074                  }
5075                  $self->{entity__value} = $EntityChar->{$self->{kwd}};
5076                }
5077              $self->{entity__match} = 1;              $self->{entity__match} = 1;
5078                            
5079      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 5362  sub _get_next_token ($) { Line 5469  sub _get_next_token ($) {
5469          ## XML5: Not defined yet.          ## XML5: Not defined yet.
5470    
5471          ## TODO:          ## TODO:
5472    
5473            if (not $self->{stop_processing} and
5474                not $self->{document}->xml_standalone) {
5475              $self->{parse_error}->(level => $self->{level}->{must}, type => 'stop processing', ## TODO: type
5476                              level => $self->{level}->{info});
5477              $self->{stop_processing} = 1;
5478            }
5479    
5480                    
5481      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
5482        $self->{line_prev} = $self->{line};        $self->{line_prev} = $self->{line};
# Line 5796  sub _get_next_token ($) { Line 5911  sub _get_next_token ($) {
5911          }          }
5912          $self->{ct} = {type => ELEMENT_TOKEN, name => '',          $self->{ct} = {type => ELEMENT_TOKEN, name => '',
5913                         line => $self->{line_prev},                         line => $self->{line_prev},
5914                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 7};
5915          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
5916                    
5917      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 5864  sub _get_next_token ($) { Line 5979  sub _get_next_token ($) {
5979          $self->{ct} = {type => ATTLIST_TOKEN, name => '',          $self->{ct} = {type => ATTLIST_TOKEN, name => '',
5980                         attrdefs => [],                         attrdefs => [],
5981                         line => $self->{line_prev},                         line => $self->{line_prev},
5982                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 7};
5983          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
5984                    
5985      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 5933  sub _get_next_token ($) { Line 6048  sub _get_next_token ($) {
6048          }          }
6049          $self->{ct} = {type => NOTATION_TOKEN, name => '',          $self->{ct} = {type => NOTATION_TOKEN, name => '',
6050                         line => $self->{line_prev},                         line => $self->{line_prev},
6051                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 8};
6052          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
6053                    
6054      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 6145  sub _get_next_token ($) { Line 6260  sub _get_next_token ($) {
6260          if ($self->{ct}->{type} == ATTLIST_TOKEN) {          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
6261            $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;            $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
6262          } elsif ($self->{ct}->{type} == ELEMENT_TOKEN) {          } elsif ($self->{ct}->{type} == ELEMENT_TOKEN) {
6263            ## TODO: ...            $self->{state} = AFTER_ELEMENT_NAME_STATE;
           $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;  
6264          } else { # ENTITY/NOTATION          } else { # ENTITY/NOTATION
6265            $self->{state} = AFTER_DOCTYPE_NAME_STATE;            $self->{state} = AFTER_DOCTYPE_NAME_STATE;
6266          }          }
# Line 7629  sub _get_next_token ($) { Line 7743  sub _get_next_token ($) {
7743        }        }
7744      } elsif ($self->{state} == NOTATION_NAME_STATE) {      } elsif ($self->{state} == NOTATION_NAME_STATE) {
7745        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
7746          $self->{state} = AFTER_NOTATION_NAME_STATE;          $self->{state} = AFTER_MD_DEF_STATE;
7747                    
7748      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7749        $self->{line_prev} = $self->{line};        $self->{line_prev} = $self->{line};
# Line 7689  sub _get_next_token ($) { Line 7803  sub _get_next_token ($) {
7803        
7804          redo A;          redo A;
7805        }        }
7806      } elsif ($self->{state} == AFTER_NOTATION_NAME_STATE) {      } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE) {
7807          if ($self->{nc} == 0x0022) { # "
7808            $self->{state} = AFTER_MD_DEF_STATE;
7809            
7810        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7811          $self->{line_prev} = $self->{line};
7812          $self->{column_prev} = $self->{column};
7813          $self->{column}++;
7814          $self->{nc}
7815              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7816        } else {
7817          $self->{set_nc}->($self);
7818        }
7819      
7820            redo A;
7821          } elsif ($self->{nc} == 0x0026) { # &
7822            $self->{prev_state} = $self->{state};
7823            $self->{state} = ENTITY_VALUE_ENTITY_STATE;
7824            $self->{entity_add} = 0x0022; # "
7825            
7826        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7827          $self->{line_prev} = $self->{line};
7828          $self->{column_prev} = $self->{column};
7829          $self->{column}++;
7830          $self->{nc}
7831              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7832        } else {
7833          $self->{set_nc}->($self);
7834        }
7835      
7836            redo A;
7837    ## TODO: %
7838          } elsif ($self->{nc} == -1) {
7839            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed entity value'); ## TODO: type
7840            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
7841            ## Reconsume.
7842            return  ($self->{ct}); # ENTITY
7843            redo A;
7844          } else {
7845            $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
7846            
7847        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7848          $self->{line_prev} = $self->{line};
7849          $self->{column_prev} = $self->{column};
7850          $self->{column}++;
7851          $self->{nc}
7852              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7853        } else {
7854          $self->{set_nc}->($self);
7855        }
7856      
7857            redo A;
7858          }
7859        } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE) {
7860          if ($self->{nc} == 0x0027) { # '
7861            $self->{state} = AFTER_MD_DEF_STATE;
7862            
7863        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7864          $self->{line_prev} = $self->{line};
7865          $self->{column_prev} = $self->{column};
7866          $self->{column}++;
7867          $self->{nc}
7868              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7869        } else {
7870          $self->{set_nc}->($self);
7871        }
7872      
7873            redo A;
7874          } elsif ($self->{nc} == 0x0026) { # &
7875            $self->{prev_state} = $self->{state};
7876            $self->{state} = ENTITY_VALUE_ENTITY_STATE;
7877            $self->{entity_add} = 0x0027; # '
7878            
7879        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7880          $self->{line_prev} = $self->{line};
7881          $self->{column_prev} = $self->{column};
7882          $self->{column}++;
7883          $self->{nc}
7884              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7885        } else {
7886          $self->{set_nc}->($self);
7887        }
7888      
7889            redo A;
7890    ## TODO: %
7891          } elsif ($self->{nc} == -1) {
7892            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed entity value'); ## TODO: type
7893            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
7894            ## Reconsume.
7895            return  ($self->{ct}); # ENTITY
7896            redo A;
7897          } else {
7898            $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
7899            
7900        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7901          $self->{line_prev} = $self->{line};
7902          $self->{column_prev} = $self->{column};
7903          $self->{column}++;
7904          $self->{nc}
7905              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7906        } else {
7907          $self->{set_nc}->($self);
7908        }
7909      
7910            redo A;
7911          }
7912        } elsif ($self->{state} == ENTITY_VALUE_ENTITY_STATE) {
7913          if ($is_space->{$self->{nc}} or
7914              {
7915                0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
7916                $self->{entity_add} => 1,
7917              }->{$self->{nc}}) {
7918            $self->{parse_error}->(level => $self->{level}->{must}, type => 'bare ero',
7919                            line => $self->{line_prev},
7920                            column => $self->{column_prev}
7921                                + ($self->{nc} == -1 ? 1 : 0));
7922            ## Don't consume
7923            ## Return nothing.
7924            #
7925          } elsif ($self->{nc} == 0x0023) { # #
7926            $self->{ca} = $self->{ct};
7927            $self->{state} = ENTITY_HASH_STATE;
7928            $self->{kwd} = '#';
7929            
7930        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7931          $self->{line_prev} = $self->{line};
7932          $self->{column_prev} = $self->{column};
7933          $self->{column}++;
7934          $self->{nc}
7935              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7936        } else {
7937          $self->{set_nc}->($self);
7938        }
7939      
7940            redo A;
7941          } else {
7942            #
7943          }
7944    
7945          $self->{ct}->{value} .= '&';
7946          $self->{state} = $self->{prev_state};
7947          ## Reconsume.
7948          redo A;
7949        } elsif ($self->{state} == AFTER_ELEMENT_NAME_STATE) {
7950        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
7951            $self->{state} = BEFORE_ELEMENT_CONTENT_STATE;
7952            
7953        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7954          $self->{line_prev} = $self->{line};
7955          $self->{column_prev} = $self->{column};
7956          $self->{column}++;
7957          $self->{nc}
7958              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7959        } else {
7960          $self->{set_nc}->($self);
7961        }
7962      
7963            redo A;
7964          } elsif ($self->{nc} == 0x0028) { # (
7965            $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
7966            $self->{ct}->{content} = ['('];
7967            $self->{group_depth} = 1;
7968            
7969        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7970          $self->{line_prev} = $self->{line};
7971          $self->{column_prev} = $self->{column};
7972          $self->{column}++;
7973          $self->{nc}
7974              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7975        } else {
7976          $self->{set_nc}->($self);
7977        }
7978      
7979            redo A;
7980          } elsif ($self->{nc} == 0x003E) { # >
7981            $self->{parse_error}->(level => $self->{level}->{must}, type => 'no md def'); ## TODO: type
7982            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
7983            
7984        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
7985          $self->{line_prev} = $self->{line};
7986          $self->{column_prev} = $self->{column};
7987          $self->{column}++;
7988          $self->{nc}
7989              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
7990        } else {
7991          $self->{set_nc}->($self);
7992        }
7993      
7994            return  ($self->{ct}); # ELEMENT
7995            redo A;
7996          } elsif ($self->{nc} == -1) {
7997            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
7998            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
7999            
8000        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8001          $self->{line_prev} = $self->{line};
8002          $self->{column_prev} = $self->{column};
8003          $self->{column}++;
8004          $self->{nc}
8005              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8006        } else {
8007          $self->{set_nc}->($self);
8008        }
8009      
8010            return  ($self->{ct}); # ELEMENT
8011            redo A;
8012          } else {
8013            $self->{ct}->{content} = [chr $self->{nc}];
8014            $self->{state} = CONTENT_KEYWORD_STATE;
8015            
8016        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8017          $self->{line_prev} = $self->{line};
8018          $self->{column_prev} = $self->{column};
8019          $self->{column}++;
8020          $self->{nc}
8021              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8022        } else {
8023          $self->{set_nc}->($self);
8024        }
8025      
8026            redo A;
8027          }
8028        } elsif ($self->{state} == CONTENT_KEYWORD_STATE) {
8029          if ($is_space->{$self->{nc}}) {
8030            $self->{state} = AFTER_MD_DEF_STATE;
8031            
8032        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8033          $self->{line_prev} = $self->{line};
8034          $self->{column_prev} = $self->{column};
8035          $self->{column}++;
8036          $self->{nc}
8037              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8038        } else {
8039          $self->{set_nc}->($self);
8040        }
8041      
8042            redo A;
8043          } elsif ($self->{nc} == 0x003E) { # >
8044            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8045            
8046        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8047          $self->{line_prev} = $self->{line};
8048          $self->{column_prev} = $self->{column};
8049          $self->{column}++;
8050          $self->{nc}
8051              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8052        } else {
8053          $self->{set_nc}->($self);
8054        }
8055      
8056            return  ($self->{ct}); # ELEMENT
8057            redo A;
8058          } elsif ($self->{nc} == -1) {
8059            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
8060            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8061            
8062        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8063          $self->{line_prev} = $self->{line};
8064          $self->{column_prev} = $self->{column};
8065          $self->{column}++;
8066          $self->{nc}
8067              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8068        } else {
8069          $self->{set_nc}->($self);
8070        }
8071      
8072            return  ($self->{ct}); # ELEMENT
8073            redo A;
8074          } else {
8075            $self->{ct}->{content}->[-1] .= chr $self->{nc}; # ELEMENT
8076            ## Stay in the state.
8077            
8078        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8079          $self->{line_prev} = $self->{line};
8080          $self->{column_prev} = $self->{column};
8081          $self->{column}++;
8082          $self->{nc}
8083              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8084        } else {
8085          $self->{set_nc}->($self);
8086        }
8087      
8088            redo A;
8089          }
8090        } elsif ($self->{state} == AFTER_CM_GROUP_OPEN_STATE) {
8091          if ($is_space->{$self->{nc}}) {
8092            ## Stay in the state.
8093            
8094        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8095          $self->{line_prev} = $self->{line};
8096          $self->{column_prev} = $self->{column};
8097          $self->{column}++;
8098          $self->{nc}
8099              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8100        } else {
8101          $self->{set_nc}->($self);
8102        }
8103      
8104            redo A;
8105          } elsif ($self->{nc} == 0x0028) { # (
8106            $self->{group_depth}++;
8107            push @{$self->{ct}->{content}}, chr $self->{nc};
8108          ## Stay in the state.          ## Stay in the state.
8109                    
8110      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 7704  sub _get_next_token ($) { Line 8118  sub _get_next_token ($) {
8118      }      }
8119        
8120          redo A;          redo A;
8121          } elsif ($self->{nc} == 0x007C or # |
8122                   $self->{nc} == 0x002C) { # ,
8123            $self->{parse_error}->(level => $self->{level}->{must}, type => 'empty element name'); ## TODO: type
8124            ## Stay in the state.
8125            
8126        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8127          $self->{line_prev} = $self->{line};
8128          $self->{column_prev} = $self->{column};
8129          $self->{column}++;
8130          $self->{nc}
8131              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8132        } else {
8133          $self->{set_nc}->($self);
8134        }
8135      
8136            redo A;
8137          } elsif ($self->{nc} == 0x0029) { # )
8138            $self->{parse_error}->(level => $self->{level}->{must}, type => 'empty element name'); ## TODO: type
8139            push @{$self->{ct}->{content}}, chr $self->{nc};
8140            $self->{group_depth}--;
8141            $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
8142            
8143        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8144          $self->{line_prev} = $self->{line};
8145          $self->{column_prev} = $self->{column};
8146          $self->{column}++;
8147          $self->{nc}
8148              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8149        } else {
8150          $self->{set_nc}->($self);
8151        }
8152      
8153            redo A;
8154        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
8155            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
8156            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8157          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8158                    
8159      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 7717  sub _get_next_token ($) { Line 8166  sub _get_next_token ($) {
8166        $self->{set_nc}->($self);        $self->{set_nc}->($self);
8167      }      }
8168        
8169          return  ($self->{ct}); # ENTITY          return  ($self->{ct}); # ELEMENT
8170          redo A;          redo A;
8171        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
8172          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
8173            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8174          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8175                    
8176      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
# Line 7733  sub _get_next_token ($) { Line 8183  sub _get_next_token ($) {
8183        $self->{set_nc}->($self);        $self->{set_nc}->($self);
8184      }      }
8185        
8186          return  ($self->{ct}); # ENTITY          return  ($self->{ct}); # ELEMENT
8187            redo A;
8188          } else {
8189            push @{$self->{ct}->{content}}, chr $self->{nc};
8190            $self->{state} = CM_ELEMENT_NAME_STATE;
8191            
8192        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8193          $self->{line_prev} = $self->{line};
8194          $self->{column_prev} = $self->{column};
8195          $self->{column}++;
8196          $self->{nc}
8197              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8198        } else {
8199          $self->{set_nc}->($self);
8200        }
8201      
8202            redo A;
8203          }
8204        } elsif ($self->{state} == CM_ELEMENT_NAME_STATE) {
8205          if ($is_space->{$self->{nc}}) {
8206            $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
8207            
8208        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8209          $self->{line_prev} = $self->{line};
8210          $self->{column_prev} = $self->{column};
8211          $self->{column}++;
8212          $self->{nc}
8213              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8214        } else {
8215          $self->{set_nc}->($self);
8216        }
8217      
8218            redo A;
8219          } elsif ($self->{nc} == 0x002A or # *
8220                   $self->{nc} == 0x002B or # +
8221                   $self->{nc} == 0x003F) { # ?
8222            push @{$self->{ct}->{content}}, chr $self->{nc};
8223            $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
8224            
8225        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8226          $self->{line_prev} = $self->{line};
8227          $self->{column_prev} = $self->{column};
8228          $self->{column}++;
8229          $self->{nc}
8230              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8231        } else {
8232          $self->{set_nc}->($self);
8233        }
8234      
8235            redo A;
8236          } elsif ($self->{nc} == 0x007C or # |
8237                   $self->{nc} == 0x002C) { # ,
8238            push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
8239            $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
8240            
8241        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8242          $self->{line_prev} = $self->{line};
8243          $self->{column_prev} = $self->{column};
8244          $self->{column}++;
8245          $self->{nc}
8246              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8247        } else {
8248          $self->{set_nc}->($self);
8249        }
8250      
8251            redo A;
8252          } elsif ($self->{nc} == 0x0029) { # )
8253            $self->{group_depth}--;
8254            push @{$self->{ct}->{content}}, chr $self->{nc};
8255            $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
8256            
8257        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8258          $self->{line_prev} = $self->{line};
8259          $self->{column_prev} = $self->{column};
8260          $self->{column}++;
8261          $self->{nc}
8262              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8263        } else {
8264          $self->{set_nc}->($self);
8265        }
8266      
8267            redo A;
8268          } elsif ($self->{nc} == 0x003E) { # >
8269            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
8270            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8271            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8272            
8273        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8274          $self->{line_prev} = $self->{line};
8275          $self->{column_prev} = $self->{column};
8276          $self->{column}++;
8277          $self->{nc}
8278              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8279        } else {
8280          $self->{set_nc}->($self);
8281        }
8282      
8283            return  ($self->{ct}); # ELEMENT
8284            redo A;
8285          } elsif ($self->{nc} == -1) {
8286            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
8287            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8288            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8289            
8290        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8291          $self->{line_prev} = $self->{line};
8292          $self->{column_prev} = $self->{column};
8293          $self->{column}++;
8294          $self->{nc}
8295              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8296        } else {
8297          $self->{set_nc}->($self);
8298        }
8299      
8300            return  ($self->{ct}); # ELEMENT
8301            redo A;
8302          } else {
8303            $self->{ct}->{content}->[-1] .= chr $self->{nc};
8304            ## Stay in the state.
8305            
8306        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8307          $self->{line_prev} = $self->{line};
8308          $self->{column_prev} = $self->{column};
8309          $self->{column}++;
8310          $self->{nc}
8311              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8312        } else {
8313          $self->{set_nc}->($self);
8314        }
8315      
8316            redo A;
8317          }
8318        } elsif ($self->{state} == AFTER_CM_ELEMENT_NAME_STATE) {
8319          if ($is_space->{$self->{nc}}) {
8320            ## Stay in the state.
8321            
8322        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8323          $self->{line_prev} = $self->{line};
8324          $self->{column_prev} = $self->{column};
8325          $self->{column}++;
8326          $self->{nc}
8327              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8328        } else {
8329          $self->{set_nc}->($self);
8330        }
8331      
8332            redo A;
8333          } elsif ($self->{nc} == 0x007C or # |
8334                   $self->{nc} == 0x002C) { # ,
8335            push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
8336            $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
8337            
8338        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8339          $self->{line_prev} = $self->{line};
8340          $self->{column_prev} = $self->{column};
8341          $self->{column}++;
8342          $self->{nc}
8343              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8344        } else {
8345          $self->{set_nc}->($self);
8346        }
8347      
8348            redo A;
8349          } elsif ($self->{nc} == 0x0029) { # )
8350            $self->{group_depth}--;
8351            push @{$self->{ct}->{content}}, chr $self->{nc};
8352            $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
8353            
8354        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8355          $self->{line_prev} = $self->{line};
8356          $self->{column_prev} = $self->{column};
8357          $self->{column}++;
8358          $self->{nc}
8359              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8360        } else {
8361          $self->{set_nc}->($self);
8362        }
8363      
8364            redo A;
8365          } elsif ($self->{nc} == 0x003E) { # >
8366            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
8367            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8368            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8369            
8370        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8371          $self->{line_prev} = $self->{line};
8372          $self->{column_prev} = $self->{column};
8373          $self->{column}++;
8374          $self->{nc}
8375              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8376        } else {
8377          $self->{set_nc}->($self);
8378        }
8379      
8380            return  ($self->{ct}); # ELEMENT
8381            redo A;
8382          } elsif ($self->{nc} == -1) {
8383            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
8384            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8385            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8386            
8387        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8388          $self->{line_prev} = $self->{line};
8389          $self->{column_prev} = $self->{column};
8390          $self->{column}++;
8391          $self->{nc}
8392              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8393        } else {
8394          $self->{set_nc}->($self);
8395        }
8396      
8397            return  ($self->{ct}); # ELEMENT
8398          redo A;          redo A;
8399        } else {        } else {
8400          $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after notation name'); ## TODO: type          $self->{parse_error}->(level => $self->{level}->{must}, type => 'after element name'); ## TODO: type
8401            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8402            $self->{state} = BOGUS_MD_STATE;
8403            
8404        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8405          $self->{line_prev} = $self->{line};
8406          $self->{column_prev} = $self->{column};
8407          $self->{column}++;
8408          $self->{nc}
8409              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8410        } else {
8411          $self->{set_nc}->($self);
8412        }
8413      
8414            redo A;
8415          }
8416        } elsif ($self->{state} == AFTER_CM_GROUP_CLOSE_STATE) {
8417          if ($is_space->{$self->{nc}}) {
8418            if ($self->{group_depth}) {
8419              $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
8420            } else {
8421              $self->{state} = AFTER_MD_DEF_STATE;
8422            }
8423            
8424        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8425          $self->{line_prev} = $self->{line};
8426          $self->{column_prev} = $self->{column};
8427          $self->{column}++;
8428          $self->{nc}
8429              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8430        } else {
8431          $self->{set_nc}->($self);
8432        }
8433      
8434            redo A;
8435          } elsif ($self->{nc} == 0x002A or # *
8436                   $self->{nc} == 0x002B or # +
8437                   $self->{nc} == 0x003F) { # ?
8438            push @{$self->{ct}->{content}}, chr $self->{nc};
8439            if ($self->{group_depth}) {
8440              $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
8441            } else {
8442              $self->{state} = AFTER_MD_DEF_STATE;
8443            }
8444            
8445        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8446          $self->{line_prev} = $self->{line};
8447          $self->{column_prev} = $self->{column};
8448          $self->{column}++;
8449          $self->{nc}
8450              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8451        } else {
8452          $self->{set_nc}->($self);
8453        }
8454      
8455            redo A;
8456          } elsif ($self->{nc} == 0x0029) { # )
8457            if ($self->{group_depth}) {
8458              $self->{group_depth}--;
8459              push @{$self->{ct}->{content}}, chr $self->{nc};
8460              ## Stay in the state.
8461              
8462        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8463          $self->{line_prev} = $self->{line};
8464          $self->{column_prev} = $self->{column};
8465          $self->{column}++;
8466          $self->{nc}
8467              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8468        } else {
8469          $self->{set_nc}->($self);
8470        }
8471      
8472              redo A;
8473            } else {
8474              $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after md def'); ## TODO: type
8475              $self->{state} = BOGUS_MD_STATE;
8476              ## Reconsume.
8477              redo A;
8478            }
8479          } elsif ($self->{nc} == 0x003E) { # >
8480            if ($self->{group_depth}) {
8481              $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
8482              push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8483            }
8484            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8485            
8486        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8487          $self->{line_prev} = $self->{line};
8488          $self->{column_prev} = $self->{column};
8489          $self->{column}++;
8490          $self->{nc}
8491              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8492        } else {
8493          $self->{set_nc}->($self);
8494        }
8495      
8496            return  ($self->{ct}); # ELEMENT
8497            redo A;
8498          } elsif ($self->{nc} == -1) {
8499            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
8500            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
8501            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8502            
8503        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8504          $self->{line_prev} = $self->{line};
8505          $self->{column_prev} = $self->{column};
8506          $self->{column}++;
8507          $self->{nc}
8508              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8509        } else {
8510          $self->{set_nc}->($self);
8511        }
8512      
8513            return  ($self->{ct}); # ELEMENT
8514            redo A;
8515          } else {
8516            if ($self->{group_depth}) {
8517              $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
8518            } else {
8519              $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after md def'); ## TODO: type
8520              $self->{state} = BOGUS_MD_STATE;
8521            }
8522            ## Reconsume.
8523            redo A;
8524          }
8525        } elsif ($self->{state} == AFTER_MD_DEF_STATE) {
8526          if ($is_space->{$self->{nc}}) {
8527            ## Stay in the state.
8528            
8529        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8530          $self->{line_prev} = $self->{line};
8531          $self->{column_prev} = $self->{column};
8532          $self->{column}++;
8533          $self->{nc}
8534              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8535        } else {
8536          $self->{set_nc}->($self);
8537        }
8538      
8539            redo A;
8540          } elsif ($self->{nc} == 0x003E) { # >
8541            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8542            
8543        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8544          $self->{line_prev} = $self->{line};
8545          $self->{column_prev} = $self->{column};
8546          $self->{column}++;
8547          $self->{nc}
8548              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8549        } else {
8550          $self->{set_nc}->($self);
8551        }
8552      
8553            return  ($self->{ct}); # ENTITY/ELEMENT
8554            redo A;
8555          } elsif ($self->{nc} == -1) {
8556            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
8557            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
8558            
8559        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
8560          $self->{line_prev} = $self->{line};
8561          $self->{column_prev} = $self->{column};
8562          $self->{column}++;
8563          $self->{nc}
8564              = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
8565        } else {
8566          $self->{set_nc}->($self);
8567        }
8568      
8569            return  ($self->{ct}); # ENTITY/ELEMENT
8570            redo A;
8571          } else {
8572            $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after md def'); ## TODO: type
8573          $self->{state} = BOGUS_MD_STATE;          $self->{state} = BOGUS_MD_STATE;
8574          ## Reconsume.          ## Reconsume.
8575          redo A;          redo A;
8576        }        }
   
   
8577      } elsif ($self->{state} == BOGUS_MD_STATE) {      } elsif ($self->{state} == BOGUS_MD_STATE) {
8578        if ($self->{nc} == 0x003E) { # >        if ($self->{nc} == 0x003E) { # >
8579          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
Legend:
Removed from v.1.18  
changed lines
  Added in v.1.24
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24