Changeset 205

Show
Ignore:
Timestamp:
04/04/07 19:01:26 (2 years ago)
Author:
ingy
Message:
 r3748@skinny-2:  ingy | 2007-04-04 17:56:56 +0900
 Refactored matching
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/core/Spork/lib/Spork/Parser.pm

    r204 r205  
    2323    $self->{grammar} =  
    2424    { 
    25         top => $all_blocks, 
    26         center => $all_blocks, 
    27         indent => $all_blocks, 
    28         p => $all_phrases, 
    29         ul => [qw(ul li)], 
    30         li => $all_phrases, 
    31         h2 => $all_phrases, 
    32         b => $all_phrases, 
     25        top => { 
     26            contains => $all_blocks, 
     27        }, 
     28        center => { 
     29            contains => $all_blocks, 
     30            match => qr/^\.center\n(.*?\n)(?:.center\n|\z)\n?/s, 
     31        }, 
     32        indent => { 
     33            contains => $all_blocks, 
     34            match => qr/^((?m:^>+.*\n)+\n?)/, 
     35        }, 
     36        pre => { 
     37            match => qr/^(( +.*\S.*\n)+)(?m:^ *\n)*/, 
     38        }, 
     39        p => { 
     40            contains => $all_phrases, 
     41            match => qr/^(((?!>).*\S.*\n)+)(?m:^\s*\n)*/, 
     42        }, 
     43        ul => { 
     44            contains => [qw(ul li)], 
     45            match => qr/^((?m:^\*+ .*\n)+)\n*/, 
     46        }, 
     47        li => { 
     48            contains => $all_phrases, 
     49            match => qr/(.*)\n/, 
     50        }, 
     51        h2 => { 
     52            contains => $all_phrases, 
     53            match => qr/^={2}\s+(.*?)\s*\n+/, 
     54        }, 
     55        b => { 
     56            contains => $all_phrases, 
     57            match => [ 
     58        qr/((?:^|(?<=[^${ALPHANUM}\*]))\*\S[^\*]*\*(?=[^{$ALPHANUM}\*]|\z))/, 
     59                qr/(\{\*.*?\*\})/, 
     60            ], 
     61        }, 
     62        i => { 
     63            match => [ 
     64        qr/((?:^|(?<=[^${ALPHANUM}\/]))\/\S[^\/]*\/(?=[^{$ALPHANUM}\/]|\z))/, 
     65                qr/(\{\/.*?\/\})/, 
     66            ], 
     67        }, 
     68        tt => { 
     69            match => [ 
     70        qr/((?:^|(?<=[^${ALPHANUM}`]))`\S[^`]*`(?=[^{$ALPHANUM}`]|\z))/, 
     71                qr/(\{`.*?`\})/, 
     72            ], 
     73        }, 
     74        hilite => { 
     75            match => [ 
     76        qr/((?:^|(?<=[^${ALPHANUM}\|]))\|\S[^\|]*\|(?=[^{$ALPHANUM}\|]|\z))/, 
     77                qr/(\{\|.*?\|\})/, 
     78            ], 
     79        }, 
    3380    }; 
    3481} 
    …… 
    3784    my $self = shift; 
    3885    $self->{ast} = Spork::AST->new; 
    39 } 
    40  
    41 #------------------------------------------------------------------------------- 
    42 # Match functions 
    43 # 
    44 # Each element type has a match subroutine. It returns a match-object if there 
    45 # is a match and undef otherwise. The matched_block and matched_phrase methods 
    46 # generate the match-objects. 
    47 #------------------------------------------------------------------------------- 
    48 sub match_indent { 
    49     my $self = shift; 
    50     $self->{input} =~ /^((?m:^>+.*\n)+\n?)/ 
    51       or return; 
    52     return $self->matched_block; 
    53 } 
    54  
    55 sub match_center { 
    56     my $self = shift; 
    57     $self->{input} =~ /^\.center\n(.*?\n)(?:.center\n|\z)\n?/s 
    58       or return; 
    59     return $self->matched_block; 
    60 } 
    61  
    62 sub match_ul { 
    63     my $self = shift; 
    64     $self->{input} =~ /^((?m:^\*+ .*\n)+)\n*/ 
    65       or return; 
    66     return $self->matched_block; 
    67 } 
    68  
    69 sub match_li { 
    70     my $self = shift; 
    71     $self->{input} =~ /(.*)\n/ 
    72       or return; 
    73     return $self->matched_block; 
    74 } 
    75  
    76 sub match_h2 { 
    77     my $self = shift; 
    78     $self->{input} =~ /^={2}\s+(.*?)\s*\n+/ 
    79       or return; 
    80     $self->matched_block; 
    81 } 
    82  
    83 sub match_p { 
    84     my $self = shift; 
    85     $self->{input} =~ 
    86       qr/^(((?!>).*\S.*\n)+)(?m:^\s*\n)*/ 
    87         or return; 
    88     return $self->matched_block; 
    89 } 
    90  
    91 sub match_tt { 
    92     my $self = shift; 
    93     return $self->matched_phrase 
    94       if $self->{input} =~ 
    95         qr/((?:^|(?<=[^${ALPHANUM}`]))`\S[^`]*`(?=[^{$ALPHANUM}`]|\z))/; 
    96     return $self->matched_phrase 
    97       if $self->{input} =~ 
    98         qr/(\{`.*?`\})/; 
    99     return; 
    100 } 
    101  
    102 sub match_b { 
    103     my $self = shift; 
    104     return $self->matched_phrase 
    105       if $self->{input} =~ 
    106         qr/((?:^|(?<=[^${ALPHANUM}\*]))\*\S[^\*]*\*(?=[^{$ALPHANUM}\*]|\z))/; 
    107     return $self->matched_phrase 
    108       if $self->{input} =~ 
    109         qr/(\{\*.*?\*\})/; 
    110     return; 
    111 } 
    112  
    113 sub match_hilite { 
    114     my $self = shift; 
    115     return $self->matched_phrase 
    116       if $self->{input} =~ 
    117         qr/((?:^|(?<=[^${ALPHANUM}\|]))\|\S[^\|]*\|(?=[^{$ALPHANUM}\|]|\z))/; 
    118     return $self->matched_phrase 
    119       if $self->{input} =~ 
    120         qr/(\{\|.*?\|\})/; 
    121     return; 
    122 } 
    123  
    124 sub match_i { 
    125     my $self = shift; 
    126     return $self->matched_phrase 
    127       if $self->{input} =~ 
    128         qr/((?:^|(?<=[^${ALPHANUM}\/]))\/\S[^\/]*\/(?=[^{$ALPHANUM}\/]|\z))/; 
    129     return $self->matched_phrase 
    130       if $self->{input} =~ 
    131         qr/(\{\/.*?\/\})/; 
    132     return; 
    133 } 
    134  
    135 sub match_pre { 
    136     my $self = shift; 
    137     $self->{input} =~ 
    138       qr/^(( +.*\S.*\n)+)(?m:^ *\n)*/ 
    139         or return; 
    140     return $self->matched_block; 
    14186} 
    14287 

  • trunk/src/plugins/ingy/Document-Parser/lib/Document/Parser.pm

    r202 r205  
    22use strict; 
    33use warnings; 
     4use XXX; 
    45 
    56#------------------------------------------------------------------------------- 
    …… 
    2930    my $self = shift; 
    3031    my $container_type = shift; 
    31     my $types = $self->{grammar}->{$container_type}; 
     32    my $types = $self->{grammar}{$container_type}{contains}; 
    3233    while (my $length = length $self->{input}) { 
    3334        for my $type (@$types) { 
    34             my $func = "match_$type"; 
    35             next unless $self->can($func); 
    36             my $matched = $self->$func; 
    37             if (defined $matched) { 
    38                 substr($self->{input}, 0, $matched->{end}, ''); 
    39                 my $func = "handle_$type"; 
    40                 $self->$func($matched); 
    41                 last; 
    42             } 
     35            my $matched = $self->find_match(matched_block => $type) or next; 
     36            substr($self->{input}, 0, $matched->{end}, ''); 
     37            my $func = "handle_$type"; 
     38            $self->$func($matched); 
     39            last; 
    4340        } 
    4441        die $self->reduction_error 
    …… 
    5855    my $self = shift; 
    5956    my $container_type = shift; 
    60     my $types = $self->{grammar}->{$container_type}; 
     57    my $types = $self->{grammar}{$container_type}{contains}; 
    6158    while (length $self->{input}) { 
    6259        my $match; 
    6360        for my $type (@$types) { 
    64             my $func = "match_$type"; 
    65             next unless $self->can($func); 
    66             my $matched; 
    67             next unless $matched = $self->$func; 
     61            my $matched = $self->find_match(matched_phrase => $type) or next; 
    6862            if (not defined $match or $matched->{begin} < $match->{begin}) { 
    6963                $match = $matched; 
    …… 
    8579    } 
    8680    return; 
     81} 
     82 
     83sub find_match { 
     84    my ($self, $matched_func, $type) = @_; 
     85    my $matched; 
     86    if (my $regexp = $self->{grammar}{$type}{match}) { 
     87        if (ref($regexp) eq 'ARRAY') { 
     88            for my $re (@$regexp) { 
     89                if ($self->{input} =~ $re) { 
     90                    $matched = $self->$matched_func; 
     91                    last; 
     92                } 
     93            } 
     94            return unless $matched; 
     95        } 
     96        else { 
     97            return unless $self->{input} =~ $regexp; 
     98            $matched = $self->$matched_func; 
     99        } 
     100    } 
     101    else { 
     102        my $func = "match_$type"; 
     103        next unless $self->can($func); 
     104        $matched = $self->$func or return; 
     105    } 
     106    return $matched; 
    87107} 
    88108