Ignore:
Timestamp:
Mar 20, 2014, 2:21:12 AM (6 years ago)
Author:
ksherdy
Message:

Added compilable grep demo. Single segment. Basis for follow/leader s2k iterator.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/demo/grep_demo.py

    r3734 r3736  
    66#        In addition, this examples draws attention to missing features in the Pablo
    77#        language which prevent the elimination of hand-written templates.
     8#
     9#  LF    -> trailing line feeds as part of a matched line
     10#  NO LF -> GNU grep - trailing line feeds are not part of a matched line
     11#
    812#
    913# Ken Herdy
     
    7882        matches                 = 0
    7983        lines                   = 0
    80         line_starts     = 0
     84        line_starts             = 0
    8185        line_ends               = 0
    8286        byte_data               = 0
     
    117121        output.matches = m4
    118122
    119 # Spans
    120 #
    121 # compilable - w.t.e. line splicing - (i) break at an arbitrary point with fixed lookahead
    122123def MatchLines(lex, output):
     124        crt_line_start  = pablo.Advance(~0) ^ ~0 # line_start == pablo.First()
     125        cursor                  = crt_line_start
     126
     127        LF_or_match     = lex.LF | output.matches
     128
     129        while(pablo.inFile(cursor)):
     130                cursor = pablo.ScanTo(cursor, LF_or_match)
     131                if(cursor & lex.LF):
     132                        crt_line_start = pablo.Advance(cursor)
     133                        cursor = crt_line_start
     134                if(cursor & output.matches):
     135
     136                        output.line_starts  |= crt_line_start
     137                        output.line_ends    |= pablo.AdvanceThenScanTo(cursor, lex.LF)
     138
     139                        output.lines |= pablo.InclusiveSpan(output.line_starts, output.line_ends) # LF
     140                        # output.lines |= pablo.SpanUpTo(line_start, cursor) &~ lex.LF                          # no LF
     141                        cursor = pablo.Advance(cursor)
     142
     143def MatchLines2(lex, output): # verbose with temporary streams
    123144        line_start      = 0
    124         line_start      = pablo.Advance(~line_start) ^ ~line_start # line_start = pablo.First()
    125         LF_or_match = lex.LF | output.matches
     145        line_end                = 0
     146        line_start      = pablo.Advance(~line_start) ^ ~line_start # line_start == pablo.First()
     147        output.line_starts = line_start
     148
     149        LF_or_match     = lex.LF | output.matches
    126150        cursor                  = pablo.ScanToFirst(LF_or_match)
    127151
     
    129153                if(cursor & lex.LF):
    130154                        line_start = pablo.Advance(cursor)
     155                        cursor = line_start
    131156                if(cursor & output.matches):
    132                         cursor = pablo.AdvanceThenScanTo(cursor, lex.LF)
    133                
    134                         # output.line_starts  |= line_start
    135                         # output.line_follows |= pablo.Advance(cursor)
    136 
    137                         output.lines |= pablo.SpanUpTo(line_start, cursor)
    138                        
    139                         # output.lines |= pablo.InclusiveSpan(line_start, cursor) | cursor # a line has a LF
     157                        line_end = pablo.AdvanceThenScanTo(cursor, lex.LF)
     158                        output.line_starts  |= line_start
     159                        output.line_ends    |= line_end
     160
     161                        output.lines |= pablo.InclusiveSpan(line_start, line_end) | line_end    # LF
     162                        # output.lines |= pablo.SpanUpTo(line_start, cursor) &~ lex.LF                  # no LF
     163                        cursor = line_end
     164                  cursor = pablo.ScanTo(cursor, LF_or_match)
    140165                        # cursor = next_end
    141                 cursor = pablo.AdvanceThenScanTo(cursor, LF_or_match)
    142166                               
    143167def FilterMatchLines(data, output):
    144         output.byte_data = pablo.filter_bytes(data, ~(pablo.Advance(output.lines) | output.lines))
    145         # output.byte_data = pablo.filter_bytes(data, ~output.lines) # a line has a LF
    146 
     168        output.byte_data = pablo.filter_bytes(data, ~output.lines)
     169        # output.byte_data = pablo.filter_bytes(data, ~output.lines)                                                            # LF
    147170
    148171def CountLines(lex, output):
    149         # return pablo.PopCount(pablo.MatchStar(output.lines, ~lex.LF) & lex.LF)
    150         return pablo.PopCount(pablo.Advance(output.lines) & lex.LF)     
    151         # return pablo.PopCount(output.lines & lex.LF) # a line has a LF
    152 
    153 # write out template considers end positions
     172        ### return pablo.PopCount(pablo.MatchStar(output.lines, ~lex.LF) & lex.LF)  # LF
     173        return pablo.PopCount(output.lines & lex.LF)                                                                                                                            # LF
     174        # return pablo.PopCount(pablo.Advance(output.lines) & lex.LF)                                           # no LF
    154175
    155176basis_bits      = Basis()
    156 lex           = Lex()
    157 output      = Output()
     177lex             = Lex()
     178output          = Output()
    158179
    159180if __name__ == "__main__":
     
    182203
    183204  # WriteStreamOutput(Output)
    184  
    185         if(options.invertMatch):
    186           output.lines = (~output.lines) &~ lex.LF
    187205        if(options.count):
    188206          print str(CountLines(lex, output))
     207
     208        elif(options.invertMatch):
     209            output.lines = ~output.lines                                                                        # LF
     210            # output.lines = (~output.lines) &~ lex.LF          # no LF
     211            FilterMatchLines(data, output)
     212            print output.byte_data
     213        else:
     214            FilterMatchLines(data, output)
     215            print output.byte_data
     216
    189217        if(options.debug):
    190218                print ""
     
    196224                print "lex.LF                   " + pablo.bitstream2string(lex.LF, lgth)
    197225                print "output.matches           " + pablo.bitstream2string(output.matches, lgth)
     226                print "output.line_starts       " + pablo.bitstream2string(output.line_starts, lgth)
     227                print "output.line_ends         " + pablo.bitstream2string(output.line_ends, lgth)
    198228                print "output.lines             " + pablo.bitstream2string(output.lines, lgth)
    199229                print ""
    200230
    201         FilterMatchLines(data, output)
    202 
    203         lgth = len(data)
    204         print output.byte_data
     231        #lgth = len(data)
     232
    205233
    206234               
Note: See TracChangeset for help on using the changeset viewer.