Changeset 3673


Ignore:
Timestamp:
Mar 12, 2014, 2:55:08 AM (5 years ago)
Author:
ksherdy
Message:

Cleaned up grep demo for Pablo and s2k compilation.

Location:
proto/RE/demo
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/demo/Makefile

    r3419 r3673  
     1
    12OUTFILE=src/grep.cpp
    23PABLO_SRCFILE=grep.py
     
    78INFILE=test/fruitlist1.txt
    89
     10PABLO_DEBUG=-d
     11
    912all: grep
    1013
     
    1316
    1417grep_demo:      $(PABLO_DEMO)
    15         python $(PABLO_DEMO) $(INFILE)
     18        python $(PABLO_DEMO) $(INFILE) $(PABLO_DEBUG)
     19
     20grep_invert_match_demo: $(PABLO_DEMO)
     21        python $(PABLO_DEMO) $(INFILE) -v $(PABLO_DEBUG)
    1622
    1723grep_count_demo:        $(PABLO_DEMO)
    18         python $(PABLO_DEMO) $(INFILE) -c
     24        python $(PABLO_DEMO) $(INFILE) -c $(PABLO_DEBUG)
    1925
    20 pablo_help:
    21         python  $(PABLO_COMPILER) -h
     26grep_count_invert_match_demo:   $(PABLO_DEMO)
     27        python $(PABLO_DEMO) $(INFILE) -c -v $(PABLO_DEBUG)
     28
     29grep_help:
     30        python  $(PABLO_DEMO) -h
    2231
    2332clean: 
  • proto/RE/demo/grep_demo.py

    r3429 r3673  
    7575        LF = 0
    7676       
    77 class Matches():
    78         all_matched = 0
    79 
    80 class Lines():
    81         all_matched = 0
    82 
    8377class Output():
    84         lines = 0
     78        matches                 = 0
     79        lines                   = 0
     80        line_starts     = 0
     81        line_ends               = 0
     82        byte_data               = 0
    8583
    8684def ClassifyBytes(basis_bits, lex): 
     
    111109        lex.LF = (temp20 &~ temp17)
    112110       
    113 def Match(lex, matches):
     111def Match(lex, output):
    114112        m0 = lex.a
    115113        m1 = pablo.Advance(m0) & lex.p
     
    117115        m3 = pablo.Advance(m2) & lex.l
    118116        m4 = pablo.Advance(m3) & lex.e
    119         matches.all_matched = m4
    120 
    121 # not compilable - requires pablo.First()
    122 def MatchLines1(lex, matches, lines):
    123         global lgth
    124 
    125         last_start = pablo.First()
    126         LF_or_match = lex.LF | matches.all_matched
    127         cursor = pablo.ScanToFirst(LF_or_match)
     117        output.matches = m4
     118
     119# Spans
     120#
     121# compilable - w.t.e. line splicing - (i) break at an arbitrary point with fixed lookahead
     122def MatchLines(lex, output):
     123        line_start      = 0
     124        line_start      = pablo.Advance(~line_start) ^ ~line_start # line_start = pablo.First()
     125        LF_or_match = lex.LF | output.matches
     126        cursor                  = pablo.ScanToFirst(LF_or_match)
    128127
    129128        while(pablo.inFile(cursor)):
    130                 if(cursor & matches.all_matched):
    131                         next_end = pablo.AdvanceThenScanTo(cursor, lex.LF)
    132                         lines.all_matched |= pablo.InclusiveSpan(last_start, next_end) | next_end
    133                         cursor = next_end
    134129                if(cursor & lex.LF):
    135                         last_start = pablo.Advance(cursor)
    136                 cursor = pablo.AdvanceThenScanTo(cursor, LF_or_match)
    137 
    138 # compilable
    139 def MatchLines2(lex, matches, lines):
    140         global lgth
    141 
    142         last_start = 0
    143         last_start = pablo.Advance(~last_start) ^ ~last_start
    144         LF_or_match = lex.LF | matches.all_matched
    145         cursor = pablo.ScanToFirst(LF_or_match)
    146 
    147         while(pablo.inFile(cursor)):
    148                 if(cursor & matches.all_matched):
    149                         next_end = pablo.AdvanceThenScanTo(cursor, lex.LF)
    150                         lines.all_matched |= pablo.InclusiveSpan(last_start, next_end) | next_end
    151                         cursor = next_end
    152                 if(cursor & lex.LF):
    153                         last_start = pablo.Advance(cursor)
     130                        line_start = pablo.Advance(cursor)
     131                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
     140                        # cursor = next_end
    154141                cursor = pablo.AdvanceThenScanTo(cursor, LF_or_match)
    155142                               
    156143def FilterMatchLines(data, output):
    157         output.lines = pablo.filter_bytes(data, ~lines.all_matched)
    158 
    159 def CountLines(lex, lines):
    160         return pablo.PopCount(pablo.MatchStar(lines, ~lex.LF) & lex.LF)
     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
     147
     148def 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
    161154
    162155basis_bits      = Basis()
    163156lex           = Lex()
    164 matches     = Matches()
    165 lines       = Lines()
    166157output      = Output()
    167158
     
    187178        pablo.EOF_mask = pablo.transpose_streams(data, basis_bits)
    188179        ClassifyBytes(basis_bits, lex)
    189         Match(lex, matches)
    190 
    191         MatchLines1(lex, matches, lines)
     180        Match(lex, output)
     181        MatchLines(lex, output)
     182
    192183        FilterMatchLines(data, output)
    193184
    194185  # WriteStreamOutput(Output)
     186
     187        if(options.debug):
     188                print ""
     189                print "data.replace('LF','$')   " + data.replace("\n","$")
     190                print "lex.a                    " + pablo.bitstream2string(lex.a, lgth)
     191                print "lex.p                    " + pablo.bitstream2string(lex.p, lgth)
     192                print "lex.l                    " + pablo.bitstream2string(lex.l, lgth)
     193                print "lex.e                    " + pablo.bitstream2string(lex.e, lgth)
     194                print "lex.LF                   " + pablo.bitstream2string(lex.LF, lgth)
     195                print "output.matches           " + pablo.bitstream2string(output.matches, lgth)
     196                print "output.lines             " + pablo.bitstream2string(output.lines, lgth)
     197                print ""
    195198 
    196199        if(options.invertMatch):
    197           lines.all_matched =~ lines.all_matched
    198 
     200          output.lines =~ output.lines
    199201        if(options.count):
    200           print str(CountLines(lex, lines.all_matched))
     202          print str(CountLines(lex, output))
    201203        else:
    202204          lgth = len(data)
    203           print "Raw Input:\n" + data
    204           print "---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------"
    205           print "data.replace('LF','$')   " + data.replace("\n","$")
    206           print "lex.a                    " + pablo.bitstream2string(lex.a, lgth)
    207           print "lex.p                    " + pablo.bitstream2string(lex.p, lgth)
    208           print "lex.l                    " + pablo.bitstream2string(lex.l, lgth)
    209           print "lex.e                    " + pablo.bitstream2string(lex.e, lgth)
    210           print "lex.LF                   " + pablo.bitstream2string(lex.LF, lgth)
    211           print "matches.all_matched      " + pablo.bitstream2string(matches.all_matched, lgth)
    212           print "lines.all_matched        " + pablo.bitstream2string(lines.all_matched, lgth)
    213           print "---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------"
    214           print "Raw Output:" + output.lines
     205          print output.byte_data
    215206               
    216207       
  • proto/RE/demo/grep_demo_config.py

    r3429 r3673  
    99       
    1010        # Option definitions
     11
     12        parser.add_option('-d', '--debug',
     13                          dest='debug',
     14                          action='store_true',
     15                          default=False,
     16                          help='Debug.',
     17                          )
     18
    1119        parser.add_option('-v', '--invert-match',
    1220                          dest='invertMatch',
Note: See TracChangeset for help on using the changeset viewer.