Changeset 4025


Ignore:
Timestamp:
Aug 16, 2014, 6:58:02 PM (5 years ago)
Author:
ksherdy
Message:

Reverted grep template.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/templates/cpplang/grep.template

    r3834 r4025  
    1 //
    2 // grep static string search C++ template.
    3 //
    4 // Author:  Ken Herdy
    5 //
    6 // Usage: ./grep <infile> [-o outfile]
    7 //
    8 // Description: Segment-at-a-time template.
    9 //
    10 // Implements a line-at-a-time or fixed length match copyback processing model.
    11 //
    12 // This solution is limited. It does not propagate information across
    13 // inter-segment of EOF boundaries. A more processing model must
    14 // address this limitation using any_carry() or correctly handling
    15 // maximum scanner line length.
    16 //
    17 // (c) 2014 Ken Herdy
    18 // All rights reserved.
    19 // Licensed to International Characters, Inc. under Academic Free License 3.0
    20 //
    21 // ###@warningComment ###
    22 //
    23 //////////////////////////////////////////////////////////////////////////////////////////
     1/**
     2 * grep static fixed string search C++ template.
     3 *
     4 * Author:   Ken Herdy
     5 *
     6 * Usage: ./grep <infile> [-o outfile]
     7 *
     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'.
     32 *
     33 **/
    2434
    2535#define DEBUG 0
    2636
    27 // runtime directives
     37#define DEBUG 0
     38
     39// Runtime directives
    2840#define BASIS_BITS
    2941
    30 // runtime libraries
     42// Runtime libraries
    3143#include <simd-lib/bitblock.hpp>
    3244#include <simd-lib/runtime.hpp>
     
    3547#include <simd-lib/transpose.hpp>
    3648
    37 // C/C++
     49// C/C++ libraries
    3850#include <stdio.h>
    3951#include <stdlib.h>
     
    4254using namespace std;
    4355
    44 // S2K Generated
    45 ###@global ###
     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;
    4665
    4766// Segment-at-a-time buffered stream processing parameters.
    4867const int SCANBLOCK_SIZE   = sizeof(ScanWord) * 8;
    4968const int SCANFIELD_SIZE   = sizeof(ScanWord) * 8;
     69// const int BLOCK_SIZE       =  sizeof(BitBlock) * 8;
    5070const int SEGMENT_BLOCKS   = SCANBLOCK_SIZE * SCANFIELD_SIZE / BLOCK_SIZE;
    5171const int SEGMENT_SIZE     = SEGMENT_BLOCKS * BLOCK_SIZE;
     72
    5273//const int CACHE_SIZE       = 32768;
    5374//const int BUFFER_SEGMENTS  = CACHE_SIZE / SEGMENT_SIZE;
    5475//const int BUFFER_SIZE      = BUFFER_SEGMENTS * SEGMENT_SIZE; // SEGMENT_SIZE; //
    5576
    56 const char * fixed_pattern  = "apple";
    57 const int pattern_size      = strlen(fixed_pattern);
     77// @ global - Parameter replaced with C++ translation of stream structs
     78//            and struct functions definitions
     79###@global ###
     80
     81// @ decl - Replaced with a set of C++ stream struct declarations.
     82###@struct_decls ###
     83
     84  // S2K Generated
     85###@filter_decls ###
     86
     87// @ stream_stmts - Replaced with C++ stream functions declarations.
     88//@ stream_stmts
     89
     90// Segment-at-a-time parameters.
     91int bytes_read              = 0;
     92int bytes_avail             = 0;  // wrt current segment
     93int bytes_remaining         = 0;
     94
     95int copy_back_size          = 0;
     96int copy_back_offset        = 0;
     97
     98int block_index             = 0;
     99int block_base              = 0;
     100
     101//int segment_index           = 0; // segment index wrt current buffer  // unused
     102//int segment_base            = 0; // segment offset wrt current buffer // unused
     103
     104int stream_base             = 0;
     105
     106int match_offset            = 0; // 0-based
     107int line_start_offset       = 0; 
     108int line_end_offset         = 0;
     109
     110int line_final_start_offset = 0;
     111int line_final_end_offset   = 0;
    58112
    59113int main(int argc, char * argv[]) {
    60 
     114   
    61115    char * infilename, * outfilename;
    62116    FILE * infile, * outfile;
    63 
     117       
    64118    int opt_code;
    65119    int byte_offset             = 0;
     
    67121    int only_matching           = 0;
    68122    int print_version_option    = 0;
    69 
     123   
    70124    while ((opt_code = getopt(argc, argv, "bcov?")) != -1) {
    71125        switch (opt_code) {
     
    79133        case 'o':
    80134            only_matching = 1;
    81             break;
     135            break;           
    82136        case 'v':
    83137            print_version_option = 1;
     
    93147        }
    94148    }
    95 
     149   
    96150  if (optind >= argc) {
    97151    printf ("Too few arguments\n");
     
    99153    exit(-1);
    100154  }
    101 
     155     
    102156  infilename = argv[optind++];
    103157  infile = fopen(infilename, "rb");
     
    127181  }
    128182
    129   // loop_preheader()
    130   // {
    131 
     183  ATTRIBUTE_SIMD_ALIGN char buffer[SEGMENT_SIZE];
    132184  // Pablo transpose.do_block(), transpose.do_final_block()
    133   // expect char * 'byte_data' and struct Basis_bits 'basis'
    134   // names as input and output arguments.
    135   ATTRIBUTE_SIMD_ALIGN char buffer[SEGMENT_SIZE];
     185  // expect 'byte_data' and 'basis' names as input and output arguments.
    136186  char * byte_data = buffer;
    137187
    138   // Input / Output Streams or Buffers // AST Decls SOURCE SINK
    139   //
    140   //
    141 
    142   // Stream struct declarations. // AST Decls
    143 
    144 // S2K Generated
    145 ###@struct_decls ###
    146 
    147 // S2K Generated
    148 ###@kernel_decls ###
    149 
    150   // Iterators. // AST Decls ?
     188  // Scanners
    151189  BitStreamScanner<BitBlock, ScanWord, ScanWord, SEGMENT_BLOCKS> matches_scanner;
    152190  BitStreamScanner<BitBlock, ScanWord, ScanWord, SEGMENT_BLOCKS> line_starts_scanner;
    153191  BitStreamScanner<BitBlock, ScanWord, ScanWord, SEGMENT_BLOCKS> line_ends_scanner;
    154192
    155   // Segment-at-a-time control
    156   int bytes_read              = 0;
    157   int bytes_avail             = 0;
    158   int bytes_remaining         = 0;
    159 
    160   int copy_back_size          = 0;
    161   int copy_back_offset        = 0;
    162 
    163   // Segment-at-a-time offset
    164   // int block_base_offset    = 0;
    165   int block_index             = 0;
    166   int segment_base            = 0;
    167 
    168   // Iterator offset
    169   int match_offset            = 0;
    170   int line_start_offset       = 0;
    171   int line_end_offset         = 0;
    172 
    173   int line_final_start_offset = 0;
    174   int line_final_end_offset   = 0;
    175 
    176   // } // end loop_preheader()
    177 
    178193  // Segment-at-a-time processing.
    179194  while(!feof(infile)) {
    180 
    181         // loop_header()
    182         // {
    183 
    184         block_index = 0;
    185 
    186         // scanners
     195    // Read Stream in SEGMENT_SIZE - strlen("needle") byte chunks.
     196    bytes_read      = fread(buffer + copy_back_size, 1, SEGMENT_SIZE - copy_back_size, infile);
     197    bytes_avail     = bytes_read + copy_back_size;
     198    bytes_remaining = bytes_avail;
     199   
     200//    if(feof(infile))
     201//        && (0 == bytes_remaining)) {
     202//        if(infile) { fclose(infile); infile=NULL;}
     203//        if(outfile) { fclose(outfile); outfile=NULL;}
     204//        break;
     205//    }
     206   
     207    if(ferror(infile)) { perror( "io error" ); exit(1); }
     208
     209    // Process full segment.
     210   
     211    //assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
     212   
     213    if (bytes_remaining == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
     214   
     215      block_base      = 0;     
     216       
     217      if(only_matching) { 
    187218        matches_scanner.init();
     219      }
     220     
     221      if(!only_matching) {
    188222        line_starts_scanner.init();
    189223        line_ends_scanner.init();
    190 
    191         // ReadStream(), BufferSource(), BufferSink(). Read input stream segment-at-a-time.
    192         bytes_read      = fread(buffer + copy_back_size, 1, SEGMENT_SIZE - copy_back_size, infile);
    193         bytes_avail     = bytes_read + copy_back_size;
    194         bytes_remaining = bytes_avail;
    195 
    196 
    197 
    198         if(ferror(infile)) { perror( "io error" ); exit(1); }
    199         assert(("fread exceeded segment size.", bytes_avail <= SEGMENT_SIZE));
    200 
    201         // } // end loop_header()
    202 
    203         // loop_body()
    204 
    205         // Process full segment.
    206         if (bytes_remaining == SEGMENT_SIZE) { // (bytes_remaining >= SEGMENT_SIZE)
    207 
    208           for(block_index = 0;
    209               block_index < SEGMENT_BLOCKS;
    210               block_index++) {
    211 
    212             byte_data = &buffer[block_index * BLOCK_SIZE];
    213 
    214 // S2K Generated 'do_block()' calls.
    215 ###@kernel_do_block ###
    216 
    217               if(only_matching) {
    218                 matches_scanner.load_block(output.match_follows, block_index);
    219               }
    220 
    221               if(!only_matching) {
    222                   line_starts_scanner.load_block(output.line_starts, block_index);
    223                   line_ends_scanner.load_block(output.line_ends, block_index);
    224               }
     224      }
     225
     226      for(block_index = 0;
     227          block_index < SEGMENT_BLOCKS;
     228          block_index++, block_base+=BLOCK_SIZE) {
     229
     230        byte_data = &buffer[block_base];
     231       
     232        //Compiled to 'do_block()' calls.
     233        ###@filter_do_block ###
     234
     235        if(only_matching) { 
     236          matches_scanner.load_block(output.match_follows, block_index);
     237        }
     238
     239        if(!only_matching) {
     240            line_starts_scanner.load_block(output.line_starts, block_index);
     241            line_ends_scanner.load_block(output.line_ends, block_index);
     242        }
     243      }
     244   
     245      if(only_matching) {
     246        while(matches_scanner.has_next()) {
     247          match_offset = matches_scanner.scan_to_next() - pattern_size;
     248          if(byte_offset) {
     249              int match_stream_offset = stream_base + match_offset;
     250              fprintf(outfile, "%d:", match_stream_offset);
     251          }
     252         
     253          // KH: Lookahead.
     254          fwrite(&buffer[match_offset], 1, pattern_size, outfile);
     255         
     256          //fprintf(outfile, "%s\n", fixed_pattern);
     257          fprintf(outfile, "\n");
     258        }
     259       
     260        copy_back_size      = pattern_size + 1;           
     261        copy_back_offset    = bytes_avail - copy_back_size;           
     262      }
     263 
     264      if(!only_matching) {
     265
     266        assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     267         
     268        //if(has_line_start) {
     269            line_final_start_offset = line_starts_scanner.get_final_pos();
     270        //}
     271        //if(has_line_end) {
     272            line_final_end_offset = line_ends_scanner.get_final_pos();
     273        //}
     274           
     275        // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
     276         
     277        while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
     278             
     279          line_start_offset  = line_starts_scanner.scan_to_next();
     280          line_end_offset    = line_ends_scanner.scan_to_next();
     281             
     282          if(byte_offset) {
     283            fprintf(outfile, "%d:", stream_base + line_start_offset);
     284          }
     285             
     286          fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     287        }
     288       
     289        copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
     290        copy_back_size     = bytes_avail - copy_back_offset;   
     291
     292        assert(("copy_back_offset", (copy_back_offset >= 0)));
     293        assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
     294        assert(("copy_back_size", (copy_back_size >= 0)));
     295        assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
     296       
     297      }
     298     
     299      bytes_remaining -= SEGMENT_SIZE;
     300    }
     301   
     302    // Process a partial segment.
     303    if(bytes_remaining > 0) {
     304               
     305        block_index = 0;   
     306        block_base  = 0;   
     307       
     308        if(only_matching) {
     309          matches_scanner.init();
     310        }
     311       
     312        if(!only_matching) {
     313          line_starts_scanner.init();
     314          line_ends_scanner.init();
     315        }
     316       
     317        // Process full blocks.
     318        while (bytes_remaining >= BLOCK_SIZE) {
     319          byte_data = &buffer[block_base];
     320         
     321          // Compiler 'do_block()' calls.
     322          ###@filter_do_block ###
     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);
    225331          }
    226 
    227           if(only_matching) {
    228             while(matches_scanner.has_next()) {
    229               match_offset = matches_scanner.scan_to_next() - pattern_size;
    230               if(byte_offset) {
    231                   int match_stream_offset = segment_base + match_offset;
    232                   fprintf(outfile, "%d:", match_stream_offset);
    233               }
    234 
    235               // KH: Lookahead.
    236               fwrite(&buffer[match_offset], 1, pattern_size, outfile);
    237               //fprintf(outfile, "%s\n", fixed_pattern);
    238               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       ###@filter_do_final_block ###
     344       
     345       if(only_matching) {
     346          matches_scanner.load_block(output.match_follows & EOF_mask, block_index);
     347       }
     348         
     349       if(!only_matching) {   
     350         line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
     351         line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);           
     352       }
     353
     354       if(only_matching) {
     355          while(matches_scanner.has_next()) {
     356            match_offset = matches_scanner.scan_to_next() - pattern_size;
     357            if(byte_offset) {
     358                int match_stream_offset = stream_base + match_offset;
     359                fprintf(outfile, "%d:", match_stream_offset);
    239360            }
    240 
    241             copy_back_size      = pattern_size + 1;
    242             copy_back_offset    = bytes_avail - copy_back_size;
     361           
     362            // KH: Lookahead.
     363            fwrite(&buffer[match_offset], 1, pattern_size, outfile);
     364            fprintf(outfile, "\n");
    243365          }
    244 
    245           if(!only_matching) {
    246 
    247             assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next()));
    248             line_final_start_offset = line_starts_scanner.get_final_pos();
    249             line_final_end_offset = line_ends_scanner.get_final_pos();
     366         
     367          copy_back_size      = pattern_size + 1;           
     368          copy_back_offset    = bytes_avail - copy_back_size;             
     369        }
     370     
     371        if(!only_matching) {
     372           
     373            assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next())); 
     374                       
     375            //if(has_line_start) {
     376                line_final_start_offset = line_starts_scanner.get_final_pos();
     377            //}
     378            //if(has_line_end) {
     379                line_final_end_offset = line_ends_scanner.get_final_pos();
     380            //}
     381               
    250382            // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    251 
     383   
    252384            while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    253 
    254               line_start_offset  = line_starts_scanner.scan_to_next();
    255               line_end_offset    = line_ends_scanner.scan_to_next();
    256 
    257               if(byte_offset) {
    258                 fprintf(outfile, "%d:", segment_base + line_start_offset);
    259               }
    260 
    261               fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
     385               
     386                line_start_offset  = line_starts_scanner.scan_to_next();
     387                line_end_offset    = line_ends_scanner.scan_to_next();
     388               
     389                if(byte_offset) {
     390                    fprintf(outfile, "%d:", stream_base + line_start_offset);
     391                }
     392               
     393                fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
    262394            }
    263395
    264396            copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
    265397            copy_back_size     = bytes_avail - copy_back_offset;
    266 
     398           
    267399            assert(("copy_back_offset", (copy_back_offset >= 0)));
    268             assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));
     400            assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));           
    269401            assert(("copy_back_size", (copy_back_size >= 0)));
    270402            assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
    271 
    272           }
    273 
    274           bytes_remaining -= SEGMENT_SIZE;
    275         }
    276 
    277         // if(bytes_remaining > 0) { // KH: @ any_carry
    278 
    279             // Process a partial segment.
    280             while (bytes_remaining >= BLOCK_SIZE) {
    281                   byte_data = &buffer[block_index * BLOCK_SIZE];
    282 
    283 // S2K Generated 'do_block()' calls.
    284 ###@kernel_do_block ###
    285 
    286                   if(only_matching) {
    287                     matches_scanner.load_block(output.match_follows, block_index);
    288                   }
    289 
    290                   if(!only_matching) {
    291                     line_starts_scanner.load_block(output.line_starts, block_index);
    292                     line_ends_scanner.load_block(output.line_ends, block_index);
    293                   }
    294 
    295                   bytes_remaining -= BLOCK_SIZE;
    296                   block_index++;
    297             }
    298 
    299 
    300         if(bytes_remaining > 0) { // KH: any_carry
    301 
    302             BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - bytes_remaining));
    303             byte_data = &buffer[block_index * BLOCK_SIZE];
    304 
    305 // S2K Generated 'do_final_block()' calls.
    306 ###@kernel_do_final_block ###
    307 
    308             if(only_matching) {
    309               matches_scanner.load_block(output.match_follows & EOF_mask, block_index);
    310             }
    311 
    312             if(!only_matching) {
    313               line_starts_scanner.load_block(output.line_starts & EOF_mask, block_index);
    314               line_ends_scanner.load_block(output.line_ends & EOF_mask, block_index);
    315             }
    316 
    317             if(only_matching) {
    318               while(matches_scanner.has_next()) {
    319                 match_offset = matches_scanner.scan_to_next() - pattern_size;
    320                 if(byte_offset) {
    321                     int match_stream_offset = segment_base + match_offset;
    322                     fprintf(outfile, "%d:", match_stream_offset);
    323                 }
    324 
    325                 // KH: Lookahead.
    326                 fwrite(&buffer[match_offset], 1, pattern_size, outfile);
    327                 fprintf(outfile, "\n");
    328               }
    329 
    330               copy_back_size      = pattern_size + 1;
    331               copy_back_offset    = bytes_avail - copy_back_size;
    332             }
    333 
    334             if(!only_matching) {
    335 
    336                 assert(("Line length exceeds segment size.", line_ends_scanner.has_next() && line_starts_scanner.has_next()));
    337 
    338                 line_final_start_offset = line_starts_scanner.get_final_pos();
    339                 line_final_end_offset = line_ends_scanner.get_final_pos();
    340                 // if(!has_line_start && !has_line_end) {/* Set flag to buffer entire segment. */;}
    341 
    342                 while(line_starts_scanner.has_next() && line_ends_scanner.has_next()) {
    343 
    344                     line_start_offset  = line_starts_scanner.scan_to_next();
    345                     line_end_offset    = line_ends_scanner.scan_to_next();
    346 
    347                     if(byte_offset) {
    348                         fprintf(outfile, "%d:", segment_base + line_start_offset);
    349                     }
    350 
    351                     fwrite(&buffer[line_start_offset], 1, line_end_offset - line_start_offset + 1, outfile);
    352                 }
    353 
    354                 copy_back_offset   = (line_final_start_offset > line_final_end_offset) ? line_final_start_offset : (line_final_end_offset + 1) ;
    355                 copy_back_size     = bytes_avail - copy_back_offset;
    356 
    357                 assert(("copy_back_offset", (copy_back_offset >= 0)));
    358                 assert(("copy_back_offset", (copy_back_offset <= bytes_avail)));
    359                 assert(("copy_back_size", (copy_back_size >= 0)));
    360                 assert(("copy_back_size", (copy_back_size < SEGMENT_SIZE)));
    361 
    362               }
    363         } // remaining > 0
    364 
    365         if(DEBUG) {
    366             printf("bytes_avail: %d\n", bytes_avail);
    367             printf("bytes_remaining: %d\n", bytes_remaining);
    368             printf("copy_back_offset: %d\n", copy_back_offset);
    369             printf("copy_back_size: %d\n", copy_back_size);
    370             printf("final_line_starts_offset: %d\n", line_final_start_offset);
    371             printf("final_line_ends_offset: %d\n", line_final_end_offset);
    372         }
    373         // end loop_body()
    374 
    375         // loop_tail()
    376 
    377 // S2K Generated 'clear()' calls.
    378 ###@kernel_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()
     403           
     404        }       
     405    }
     406   
     407    if(DEBUG) {
     408        printf("bytes_avail: %d\n", bytes_avail);
     409        printf("bytes_remaining: %d\n", bytes_remaining);
     410        printf("copy_back_offset: %d\n", copy_back_offset);
     411        printf("copy_back_size: %d\n", copy_back_size);       
     412        printf("final_line_starts_offset: %d\n", line_final_start_offset);
     413        printf("final_line_ends_offset: %d\n", line_final_end_offset);
     414    }
     415   
     416    memmove(&buffer[0], &buffer[copy_back_offset], copy_back_size);
     417   
     418    // pablo.ScanToFirst() must clear carry-in at the start of each segment
     419    classifyBytes.clear();
     420    match.clear();
     421    matchLines.clear();
     422   
     423    stream_base += bytes_avail;
     424    stream_base -= copy_back_size;
    391425
    392426  }
    393427
    394   // loop_exit()
    395   // {
    396428  if(infile) { fclose(infile); infile=NULL;}
    397429  if(outfile) { fclose(outfile); outfile=NULL;}
    398 
    399   // end loop_exit()
    400 
     430 
    401431  return 0;
    402432}
    403 
Note: See TracChangeset for help on using the changeset viewer.