Changeset 4019


Ignore:
Timestamp:
Aug 16, 2014, 6:38:43 PM (4 years ago)
Author:
ksherdy
Message:

Fix grep header test.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/demo/grep/src/grep_segment_at_a_time.cpp

    r3884 r4019  
    66 * Usage: ./grep <infile> [-o outfile]
    77 *
    8  * Description: Segment-at-a-time template.
    9  *
    10  * Implements a line-at-a-time copyback or fixed length match copyback.
    11  *
    12  * Does not propagate information across segment of EOF boundary. A general solution
    13  * must address this using any_carry() or correct scanner line length in this template.
     8 * Description: Segment-at-a-time template. Implements a line-at-a-time copyback processing model.
     9 *
     10 * '_offset' => 0-based byte offsets
     11 * '_pos'    => 1-based bytes offsets
     12 *
     13 * Future Work:
     14 *
     15 * a. Lookahead.
     16 * b. Support multiple segments a.k.a. buffer-at-a-time.
     17 * c. Compile in s2k. <--
     18 * d. s2k iterators for (start, follow) in (starts_stream, follows_stream) do { }
     19 *
     20 * Segment-at-a-time Processing Issues:
     21 *
     22 * 1. Start-of-stream or equivalently start-of-segment clear()...
     23 *    The ScanTo and EOF_mask processing ensure a 'fence post' at the
     24 *    end of each segment as well as at the end of file.
     25 *
     26 * 'grep.py' and 'grep_template.cpp' are tightly coupled on a number of variables:
     27 *
     28 * 1. Tranpose.do_block expects 'byte_data' and 'basis_bits'.
     29 * 2. All StreamFunction.do_final_block methods expect 'EOF_mask'.
     30 * 3. Sequential iterators (scanners) expect 'output.matches'.
     31 * 4. Sequential iterators (scanners) expect 'lex.LF'.
    1432 *
    1533 **/
     
    1937#include "/home/ken/workspace/s2k/output/cpplang/grep/grep.hpp"
    2038
    21 // C/C++
     39// Runtime directives
     40#define BASIS_BITS
     41
     42// Runtime libraries
     43#include <simd-lib/bitblock.hpp>
     44#include <simd-lib/runtime.hpp>
     45#include <simd-lib/pabloSupport.hpp>
     46#include <simd-lib/bitblock_iterator.hpp>
     47#include <simd-lib/transpose.hpp>
     48
     49// C/C++ libraries
    2250#include <stdio.h>
    2351#include <stdlib.h>
     
    2654using namespace std;
    2755
     56
     57// Fixed pattern.
     58const char * fixed_pattern  = "apple";
     59const int pattern_size      = strlen(fixed_pattern);
     60
     61// Platform dependent definitions. // Example only, defined in simd-lib/builtins.hpp.
     62typedef __m128i BitBlock;
     63typedef BitBlock BytePack;
     64typedef uint32_t ScanWord;
     65
    2866// Segment-at-a-time buffered stream processing parameters.
    2967const int SCANBLOCK_SIZE   = sizeof(ScanWord) * 8;
    3068const int SCANFIELD_SIZE   = sizeof(ScanWord) * 8;
     69// const int BLOCK_SIZE       =  sizeof(BitBlock) * 8;
    3170const int SEGMENT_BLOCKS   = SCANBLOCK_SIZE * SCANFIELD_SIZE / BLOCK_SIZE;
    3271const int SEGMENT_SIZE     = SEGMENT_BLOCKS * BLOCK_SIZE;
     72
    3373//const int CACHE_SIZE       = 32768;
    3474//const int BUFFER_SEGMENTS  = CACHE_SIZE / SEGMENT_SIZE;
    3575//const int BUFFER_SIZE      = BUFFER_SEGMENTS * SEGMENT_SIZE; // SEGMENT_SIZE; //
    3676
    37 const char * fixed_pattern  = "apple";
    38 const int pattern_size      = strlen(fixed_pattern);
     77struct Basis_bits basis_bits;
     78struct Lex lex;
     79struct Output output;
     80
     81struct Transpose transpose;
     82struct ClassifyBytes classifyBytes;
     83struct Match match;
     84struct MatchLines matchLines;
     85// Segment-at-a-time parameters.
     86int bytes_read              = 0;
     87int bytes_avail             = 0;  // wrt current segment
     88int bytes_remaining         = 0;
     89
     90int copy_back_size          = 0;
     91int copy_back_offset        = 0;
     92
     93int block_index             = 0;
     94int block_base              = 0;
     95
     96//int segment_index           = 0; // segment index wrt current buffer  // unused
     97//int segment_base            = 0; // segment offset wrt current buffer // unused
     98
     99int stream_base             = 0;
     100
     101int match_offset            = 0; // 0-based
     102int line_start_offset       = 0; 
     103int line_end_offset         = 0;
     104
     105int line_final_start_offset = 0;
     106int line_final_end_offset   = 0;
    39107
    40108int main(int argc, char * argv[]) {
     
    108176  }
    109177
    110   // loop_preheader()
    111   // {
    112 
     178  ATTRIBUTE_SIMD_ALIGN char buffer[SEGMENT_SIZE];
    113179  // Pablo transpose.do_block(), transpose.do_final_block()
    114   // expect char * 'byte_data' and struct Basis_bits 'basis'
    115   // names as input and output arguments. 
    116   ATTRIBUTE_SIMD_ALIGN char buffer[SEGMENT_SIZE];
     180  // expect 'byte_data' and 'basis' names as input and output arguments.
    117181  char * byte_data = buffer;
    118  
    119   // Input / Output Streams or Buffers // AST Decls SOURCE SINK
    120   //
    121   //
    122  
    123   // Stream struct declarations. // AST Decls
    124   struct Transpose transpose;
    125   struct Basis_bits basis_bits;
    126   struct Lex lex;
    127   struct Output output;
    128  
    129   // Stream functions declarations. // AST Decls
    130   MatchLines matchLines;
    131   ClassifyBytes classifyBytes;
    132   Match match;
    133  
    134   // Iterators. // AST Decls ?
     182
     183  // Scanners
    135184  BitStreamScanner<BitBlock, ScanWord, ScanWord, SEGMENT_BLOCKS> matches_scanner;
    136185  BitStreamScanner<BitBlock, ScanWord, ScanWord, SEGMENT_BLOCKS> line_starts_scanner;
    137186  BitStreamScanner<BitBlock, ScanWord, ScanWord, SEGMENT_BLOCKS> line_ends_scanner;
    138187
    139   // Segment-at-a-time control
    140   int bytes_read              = 0;
    141   int bytes_avail             = 0; 
    142   int bytes_remaining         = 0;
    143  
    144   int copy_back_size          = 0;
    145   int copy_back_offset        = 0; 
    146 
    147   // Segment-at-a-time offset
    148   // int block_base_offset    = 0;
    149   int block_index             = 0;
    150   int segment_base            = 0; 
    151  
    152   // Iterator offset
    153   int match_offset            = 0;
    154   int line_start_offset       = 0; 
    155   int line_end_offset         = 0;
    156  
    157   int line_final_start_offset = 0;
    158   int line_final_end_offset   = 0; 
    159  
    160   // } // end loop_preheader()
    161  
    162188  // Segment-at-a-time processing.
    163189  while(!feof(infile)) {
    164    
    165         // loop_header()
    166         // {
     190    // Read Stream in SEGMENT_SIZE - strlen("needle") byte chunks.
     191    bytes_read      = fread(buffer + copy_back_size, 1, SEGMENT_SIZE - copy_back_size, infile);
     192    bytes_avail     = bytes_read + copy_back_size;
     193    bytes_remaining = bytes_avail;
     194   
     195//    if(feof(infile))
     196//        && (0 == bytes_remaining)) {
     197//        if(infile) { fclose(infile); infile=NULL;}
     198//        if(outfile) { fclose(outfile); outfile=NULL;}
     199//        break;
     200//    }
     201   
     202    if(ferror(infile)) { perror( "io error" ); exit(1); }
     203
     204    // Process full segment.
     205   
     206    //assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
     207   
     208    if (bytes_remaining == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
     209   
     210      block_base      = 0;     
     211       
     212      if(only_matching) { 
     213        matches_scanner.init();
     214      }
    167215     
    168         block_index = 0;   
    169        
    170         // scanners
    171         matches_scanner.init();
     216      if(!only_matching) {
    172217        line_starts_scanner.init();
    173218        line_ends_scanner.init();
    174          
    175         // ReadStream(), BufferSource(), BufferSink(). Read input stream segment-at-a-time.
    176         bytes_read      = fread(buffer + copy_back_size, 1, SEGMENT_SIZE - copy_back_size, infile);
    177         bytes_avail     = bytes_read + copy_back_size;
    178         bytes_remaining = bytes_avail;
    179        
    180          
    181        
    182         if(ferror(infile)) { perror( "io error" ); exit(1); }
    183         assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
    184    
    185         // } // end loop_header()
    186        
    187         // loop_body()
    188        
    189         // Process full segment.
    190         if (bytes_remaining == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
    191        
    192           for(block_index = 0;
    193               block_index < SEGMENT_BLOCKS;
    194               block_index++) {
    195    
    196             byte_data = &buffer[block_index * BLOCK_SIZE];
     219      }
     220
     221      for(block_index = 0;
     222          block_index < SEGMENT_BLOCKS;
     223          block_index++, block_base+=BLOCK_SIZE) {
     224
     225        byte_data = &buffer[block_base];
     226       
     227        //Compiled to 'do_block()' calls.
     228        transpose.do_block(byte_data, basis_bits);
     229                                classifyBytes.do_block(basis_bits, lex);
     230                                match.do_block(lex, output);
     231                                matchLines.do_block(lex, output);
     232
     233        if(only_matching) { 
     234          matches_scanner.load_block(output.match_follows, block_index);
     235        }
     236
     237        if(!only_matching) {
     238            line_starts_scanner.load_block(output.line_starts, block_index);
     239            line_ends_scanner.load_block(output.line_ends, block_index);
     240        }
     241      }
     242   
     243      if(only_matching) {
     244        while(matches_scanner.has_next()) {
     245          match_offset = matches_scanner.scan_to_next() - pattern_size;
     246          if(byte_offset) {
     247              int match_stream_offset = stream_base + match_offset;
     248              fprintf(outfile, "%d:", match_stream_offset);
     249          }
     250         
     251          // KH: Lookahead.
     252          fwrite(&buffer[match_offset], 1, pattern_size, outfile);
     253         
     254          //fprintf(outfile, "%s\n", fixed_pattern);
     255          fprintf(outfile, "\n");
     256        }
     257       
     258        copy_back_size      = pattern_size + 1;           
     259        copy_back_offset    = bytes_avail - copy_back_size;           
     260      }
     261 
     262      if(!only_matching) {
     263
     264        assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     265         
     266        //if(has_line_start) {
     267            line_final_start_offset = line_starts_scanner.get_final_pos();
     268        //}
     269        //if(has_line_end) {
     270            line_final_end_offset = line_ends_scanner.get_final_pos();
     271        //}
    197272           
    198             //Compiled to 'do_block()' calls.
    199            
    200               transpose.do_block(byte_data, basis_bits);
    201               classifyBytes.do_block(basis_bits, lex);
    202               match.do_block(lex, output);
    203               matchLines.do_block(lex, output);
    204            
    205               if(only_matching) { 
    206                 matches_scanner.load_block(output.match_follows, block_index);
    207               }
    208            
    209               if(!only_matching) {
    210                   line_starts_scanner.load_block(output.line_starts, block_index);
    211                   line_ends_scanner.load_block(output.line_ends, block_index);
    212               }         
     273        // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
     274         
     275        while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
     276             
     277          line_start_offset  = line_starts_scanner.scan_to_next();
     278          line_end_offset    = line_ends_scanner.scan_to_next();
     279             
     280          if(byte_offset) {
     281            fprintf(outfile, "%d:", stream_base + line_start_offset);
     282          }
     283             
     284          fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     285        }
     286       
     287        copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
     288        copy_back_size     = bytes_avail - copy_back_offset;   
     289
     290        assert(("copy_back_offset", (copy_back_offset >= 0)));
     291        assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
     292        assert(("copy_back_size", (copy_back_size >= 0)));
     293        assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
     294       
     295      }
     296     
     297      bytes_remaining -= SEGMENT_SIZE;
     298    }
     299   
     300    // Process a partial segment.
     301    if(bytes_remaining > 0) {
     302               
     303        block_index = 0;   
     304        block_base  = 0;   
     305       
     306        if(only_matching) {
     307          matches_scanner.init();
     308        }
     309       
     310        if(!only_matching) {
     311          line_starts_scanner.init();
     312          line_ends_scanner.init();
     313        }
     314       
     315        // Process full blocks.
     316        while (bytes_remaining >= BLOCK_SIZE) {
     317          byte_data = &buffer[block_base];
     318         
     319                transpose.do_block(byte_data, basis_bits);
     320                                        classifyBytes.do_block(basis_bits, lex);
     321                                        match.do_block(lex, output);
     322                                        matchLines.do_block(lex, output);
     323   
     324          if(only_matching) {
     325            matches_scanner.load_block(output.match_follows, block_index);
     326          }       
     327         
     328          if(!only_matching) {
     329            line_starts_scanner.load_block(output.line_starts, block_index);
     330            line_ends_scanner.load_block(output.line_ends, block_index);
    213331          }
    214          
    215           if(only_matching) {
    216             while(matches_scanner.has_next()) {
    217               match_offset = matches_scanner.scan_to_next() - pattern_size;
    218               if(byte_offset) {
    219                   int match_stream_offset = segment_base + match_offset;
    220                   fprintf(outfile, "%d:", match_stream_offset);
    221               }
    222              
    223               // KH: Lookahead.
    224               fwrite(&buffer[match_offset], 1, pattern_size, outfile);         
    225               //fprintf(outfile, "%s\n", fixed_pattern);
    226               fprintf(outfile, "\n");
     332   
     333          block_base += BLOCK_SIZE;
     334          bytes_remaining -= BLOCK_SIZE;
     335          block_index++;
     336       }
     337
     338       // Process a partial final block. // KH: Not required.     
     339       BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - bytes_remaining));   
     340       byte_data = &buffer[block_base];
     341         
     342       // Compiler 'do_final_block()' calls.
     343       transpose.do_final_block(byte_data, basis_bits, EOF_mask);
     344                         classifyBytes.do_final_block(basis_bits, lex, EOF_mask);
     345                         match.do_final_block(lex, output, EOF_mask);
     346                         matchLines.do_final_block(lex, output, EOF_mask);
     347       
     348       if(only_matching) {
     349          matches_scanner.load_block(output.match_follows & EOF_mask, block_index);
     350       }
     351         
     352       if(!only_matching) {   
     353         line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
     354         line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);           
     355       }
     356
     357       if(only_matching) {
     358          while(matches_scanner.has_next()) {
     359            match_offset = matches_scanner.scan_to_next() - pattern_size;
     360            if(byte_offset) {
     361                int match_stream_offset = stream_base + match_offset;
     362                fprintf(outfile, "%d:", match_stream_offset);
    227363            }
    228364           
    229             copy_back_size      = pattern_size + 1;           
    230             copy_back_offset    = bytes_avail - copy_back_size;           
     365            // KH: Lookahead.
     366            fwrite(&buffer[match_offset], 1, pattern_size, outfile);
     367            fprintf(outfile, "\n");
    231368          }
    232      
    233           if(!only_matching) {
    234    
     369         
     370          copy_back_size      = pattern_size + 1;           
     371          copy_back_offset    = bytes_avail - copy_back_size;             
     372        }
     373     
     374        if(!only_matching) {
     375           
    235376            assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
    236             line_final_start_offset = line_starts_scanner.get_final_pos();
    237             line_final_end_offset = line_ends_scanner.get_final_pos();
     377                       
     378            //if(has_line_start) {
     379                line_final_start_offset = line_starts_scanner.get_final_pos();
     380            //}
     381            //if(has_line_end) {
     382                line_final_end_offset = line_ends_scanner.get_final_pos();
     383            //}
     384               
    238385            // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    239              
     386   
    240387            while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    241                  
    242               line_start_offset  = line_starts_scanner.scan_to_next();
    243               line_end_offset    = line_ends_scanner.scan_to_next();
    244                  
    245               if(byte_offset) {
    246                 fprintf(outfile, "%d:", segment_base + line_start_offset);
    247               }
    248                  
    249               fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     388               
     389                line_start_offset  = line_starts_scanner.scan_to_next();
     390                line_end_offset    = line_ends_scanner.scan_to_next();
     391               
     392                if(byte_offset) {
     393                    fprintf(outfile, "%d:", stream_base + line_start_offset);
     394                }
     395               
     396                fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
    250397            }
     398
     399            copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
     400            copy_back_size     = bytes_avail - copy_back_offset;
    251401           
    252             copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
    253             copy_back_size     = bytes_avail - copy_back_offset;   
    254    
    255402            assert(("copy_back_offset", (copy_back_offset >= 0)));
    256403            assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
     
    258405            assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
    259406           
    260           }
    261          
    262           bytes_remaining -= SEGMENT_SIZE;
    263         }
    264    
    265         // if(bytes_remaining > 0) { // KH: @ any_carry
    266        
    267             // Process a partial segment.   
    268             while (bytes_remaining >= BLOCK_SIZE) {
    269                   byte_data = &buffer[block_index * BLOCK_SIZE];
    270                  
    271                   // Compiler 'do_block()' calls.     
    272                   transpose.do_block(byte_data, basis_bits);
    273                   classifyBytes.do_block(basis_bits, lex);
    274                   match.do_block(lex, output);
    275                   matchLines.do_block(lex, output);
    276            
    277                   if(only_matching) {
    278                     matches_scanner.load_block(output.match_follows, block_index);
    279                   }       
    280                  
    281                   if(!only_matching) {
    282                     line_starts_scanner.load_block(output.line_starts, block_index);
    283                     line_ends_scanner.load_block(output.line_ends, block_index);
    284                   }
    285            
    286                   bytes_remaining -= BLOCK_SIZE;
    287                   block_index++;
    288             }
    289            
    290        
    291         if(bytes_remaining > 0) { // KH: any_carry   
    292 
    293             BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - bytes_remaining));   
    294             byte_data = &buffer[block_index * BLOCK_SIZE];
    295            
    296             // Compiler 'do_final_block()' calls.
    297            
    298             transpose.do_final_block(byte_data, basis_bits, EOF_mask);
    299             classifyBytes.do_final_block(basis_bits, lex, EOF_mask);
    300             match.do_final_block(lex, output, EOF_mask);
    301             matchLines.do_final_block(lex, output, EOF_mask);
    302                
    303             if(only_matching) {
    304               matches_scanner.load_block(output.match_follows & EOF_mask, block_index);
    305             }
    306              
    307             if(!only_matching) {   
    308               line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
    309               line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);           
    310             }
    311            
    312             if(only_matching) {
    313               while(matches_scanner.has_next()) {
    314                 match_offset = matches_scanner.scan_to_next() - pattern_size;
    315                 if(byte_offset) {
    316                     int match_stream_offset = segment_base + match_offset;
    317                     fprintf(outfile, "%d:", match_stream_offset);
    318                 }
    319                
    320                 // KH: Lookahead.
    321                 fwrite(&buffer[match_offset], 1, pattern_size, outfile);
    322                 fprintf(outfile, "\n");
    323               }
    324              
    325               copy_back_size      = pattern_size + 1;           
    326               copy_back_offset    = bytes_avail - copy_back_size;             
    327             }
    328              
    329             if(!only_matching) {
    330                
    331                 //assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
    332                            
    333                 line_final_start_offset = line_starts_scanner.get_final_pos();
    334                 line_final_end_offset = line_ends_scanner.get_final_pos();                 
    335                 // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    336            
    337                 while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    338                    
    339                     line_start_offset  = line_starts_scanner.scan_to_next();
    340                     line_end_offset    = line_ends_scanner.scan_to_next();
    341                    
    342                     if(byte_offset) {
    343                         fprintf(outfile, "%d:", segment_base + line_start_offset);
    344                     }
    345                    
    346                     fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
    347                 }
    348            
    349                 copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
    350                 copy_back_size     = bytes_avail - copy_back_offset;
    351                
    352                 assert(("copy_back_offset", (copy_back_offset >= 0)));
    353                 assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
    354                 assert(("copy_back_size", (copy_back_size >= 0)));
    355                 assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
    356                
    357               }       
    358         } // remaining > 0
    359        
    360        
    361        
    362         if(DEBUG) {
    363             printf("bytes_avail: %d\n", bytes_avail);
    364             printf("bytes_remaining: %d\n", bytes_remaining);
    365             printf("copy_back_offset: %d\n", copy_back_offset);
    366             printf("copy_back_size: %d\n", copy_back_size);       
    367             printf("final_line_starts_offset: %d\n", line_final_start_offset);
    368             printf("final_line_ends_offset: %d\n", line_final_end_offset);
    369         }
    370        
    371         // end loop_body()
    372        
    373         // loop_tail()
    374        
    375         // Compiler 'clear()' calls.
    376         classifyBytes.clear();
    377         match.clear();
    378         matchLines.clear();
    379        
    380         // copy_back
    381         // copy_back_offset = max ?
    382         // copy_back_size   = max ?
    383        
    384         memmove(&buffer[0], &buffer[copy_back_offset], copy_back_size);   
    385        
    386         // segment_base()
    387         segment_base += bytes_avail;
    388         segment_base -= copy_back_size;
    389        
    390         // end loop_tail()
     407        }       
     408    }
     409   
     410    if(DEBUG) {
     411        printf("bytes_avail: %d\n", bytes_avail);
     412        printf("bytes_remaining: %d\n", bytes_remaining);
     413        printf("copy_back_offset: %d\n", copy_back_offset);
     414        printf("copy_back_size: %d\n", copy_back_size);       
     415        printf("final_line_starts_offset: %d\n", line_final_start_offset);
     416        printf("final_line_ends_offset: %d\n", line_final_end_offset);
     417    }
     418   
     419    memmove(&buffer[0], &buffer[copy_back_offset], copy_back_size);
     420   
     421    // pablo.ScanToFirst() must clear carry-in at the start of each segment
     422    classifyBytes.clear();
     423    match.clear();
     424    matchLines.clear();
     425   
     426    stream_base += bytes_avail;
     427    stream_base -= copy_back_size;
    391428
    392429  }
    393430
    394   // loop_exit()
    395   // {
    396431  if(infile) { fclose(infile); infile=NULL;}
    397432  if(outfile) { fclose(outfile); outfile=NULL;}
    398433 
    399   // end loop_exit()
    400  
    401434  return 0;
    402435}
    403 
Note: See TracChangeset for help on using the changeset viewer.