Ignore:
Timestamp:
Sep 16, 2011, 5:42:17 PM (8 years ago)
Author:
vla24
Message:

SymbolTable?: updated implementation after Ken's refactoring

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/SymbolTable/symtab_stl_template.cpp

    r1442 r1457  
    88#include <../lib_simd.h>
    99#include <symtab.h>
    10 
    1110#include <queue>
    1211#include <string>
     12
     13typedef long ScanBlock;
     14typedef SIMD_type BytePack;
     15typedef SIMD_type BitBlock;
     16
     17using namespace std;
    1318
    1419#define DEBUG 0
     
    1823#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
    1924
    20 typedef long ScanBlock;
    21 typedef SIMD_type BytePack;
    22 typedef SIMD_type BitBlock;
    23 
    24 using namespace std;
    25 
    2625#include <../carryQ.h>
    2726#include <xmldecl.h>
    28 #include <xml_error.c>
    29 #include <xmldecl.c>
    3027#include <namechars.h>
    31 
    3228#include <../perflib/perfsec.h>
    3329#include <../s2p.h>
     
    3531#include <TagMatcher.h>
    3632#include <LineColTracker.h>
     33#include <ErrorUtil.h>
     34#include <ErrorTracker.h>
     35#include <XMLTestSuiteError.h>
     36
     37#include <xml_error.c>
     38#include <ErrorUtil.cpp>
     39#include <ErrorTracker.cpp>
     40#include <XMLTestSuiteError.cpp>
    3741
    3842#ifdef BUFFER_PROFILING
     
    5256int block_base=0;
    5357int buffer_base=0;
    54 int buffer_last;
    5558char * source;
    5659LineColTracker tracker;
    57 
    58 static inline void ReportError(const char * error_msg, int error_pos_in_block) {
    59   int error_line, error_column;
    60   tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
    61   fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
    62 }
    63 
    64 class ErrorTracker {
    65 public:
    66     ErrorTracker() { noted_pos_in_block = -1;}
    67 
    68     inline void NoteError(const char * error_msg, BitBlock err_strm) {
    69       int pos_in_block = count_forward_zeroes(err_strm);
    70       if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
    71         noted_pos_in_block = pos_in_block;
    72         noted_error = error_msg;
    73       }
    74     }
    75 
    76     inline void If_Error_Report_First() {
    77       if (noted_pos_in_block > -1) {
    78               int error_line, error_column;
    79               ReportError(noted_error, noted_pos_in_block);
    80               exit(-1);
    81       }
    82     }
    83 
    84 private:
    85   const char * noted_error;
    86   int noted_pos_in_block;
    87 };
    88 
    89 
    9060TagMatcher matcher;
     61ErrorTracker error_tracker;
    9162BitBlock EOF_mask = simd_const_1(1);
    92 
    93 ErrorTracker error_tracker;
    9463
    9564queue <size_t> elem_starts_buf;
     
    9867SymbolTable symbol_table;
    9968
    100 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
     69/* StreamScan & Post Process Declarations */
     70//      static inline int StreamScanToFirst(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block)
     71static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block);
     72
     73static inline int NameStrt_check(int pos);
     74static inline int Name_check(int pos);
     75static inline int PIName_check(int pos);
     76static inline int CD_check(int pos);
     77static inline int GenRef_check(int pos);
     78static inline int HexRef_check(int pos);
     79static inline int DecRef_check(int pos);
     80static inline int AttRef_check(int pos);
     81
     82@global
     83
     84static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
     85static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
     86static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail);
     87static inline void do_symbol_table_lookup();
     88
     89void do_process(FILE *infile, FILE *outfile);
     90
     91int main(int argc, char * argv[]) {
     92        char * infilename, * outfilename;
     93        FILE *infile, *outfile;
     94        struct stat fileinfo;
     95
     96        if (argc < 2) {
     97                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
     98                exit(-1);
     99        }
     100
     101        infilename = argv[1];
     102        stat(infilename, &fileinfo);
     103        infile = fopen(infilename, "rb");
     104        if (!infile) {
     105                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
     106                exit(-1);
     107        }
     108
     109        if (argc < 3) outfile = stdout;
     110        else {
     111                outfilename = argv[2];
     112                outfile = fopen(outfilename, "wb");
     113                if (!outfile) {
     114                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     115                        exit(-1);
     116                }
     117        }
     118
     119//      PERF_SEC_BIND(1);
     120
     121        PERF_SEC_INIT(parser_timer);
     122
     123        do_process(infile, outfile);
     124
     125        PERF_SEC_DUMP(parser_timer);
     126
     127        PERF_SEC_DESTROY(parser_timer);
     128
     129        fclose(infile);
     130        fclose(outfile);
     131
     132        return(0);
     133}
     134
     135/* s2p Definitions */
     136static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
     137  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     138        basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
     139}
     140
     141static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
     142  s2p_do_block(U8, basis_bits);
     143  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
     144  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
     145  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
     146  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
     147  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
     148  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
     149  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
     150  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     151}
     152
     153
     154/* StreamScan & Post Process Definitions */
     155static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block) {
     156
    101157        int blk;
    102         int block_pos = 0;
     158        int block_pos = 0;
     159        int pos;
     160
    103161        for (blk = 0; blk < blk_count; blk++) {
    104                 ScanBlock s = stream[blk];
    105                 while(s) {
    106                         int code = (ProcessPos(cfzl(s) + block_pos));
    107                         if (code) return code;
     162                ScanBlock s = stream[blk];
     163                while(s) {
     164                        pos = (cfzl(s) + block_pos);
     165                        int code = (ProcessPos(pos));
     166                        if (code) {
     167                                *error_pos_in_block = pos;
     168                                return code; // error code
     169                        }
    108170                        s = s & (s-1);  // clear rightmost bit.
    109171                }
     
    126188
    127189static inline int NameStrt_check(int pos) {
    128         int block_pos = block_base + pos;
     190        int block_pos = block_base + pos;
    129191        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
    130               ReportError("name start error", pos);
    131               exit(-1);
     192              return XMLTestSuiteError::NAME_START;
    132193        }
    133194        return 0;
     
    137198        int block_pos = block_base + pos;
    138199        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
    139               ReportError("name error", pos);
    140               exit(-1);
     200                  return XMLTestSuiteError::NAME;
    141201        }
    142202        return 0;
     
    146206        int block_pos = block_base + pos;
    147207        int file_pos = block_pos+buffer_base;
    148         printf ("%s:%i\n",__FUNCTION__,pos);
    149208        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
    150209              // "<?xml" legal at start of file.
    151               if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
    152               ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
    153               exit(-1);
     210              if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
     211                  return XMLTestSuiteError::XMLPINAME;
     212              }
    154213        }
    155214        return 0;
     
    159218        int block_pos = block_base + pos;
    160219        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
    161               ReportError("CDATA error", pos);
    162               exit(-1);
     220                  return XMLTestSuiteError::CDATA;
    163221        }
    164222        return 0;
     
    169227        unsigned char* s = (unsigned char*)&source[block_pos];
    170228        if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
    171               ReportError("Undefined reference", pos);
    172               exit(-1);
     229              return XMLTestSuiteError::UNDEFREF;
    173230        }
    174231        return 0;
     
    182239          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    183240          if (ch_val> 0x10FFFF ){
    184             ReportError("Illegal character reference", pos);
    185             exit(-1);
     241                return XMLTestSuiteError::CHARREF;
    186242          }
    187243          s++;
    188244        }
    189245        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    190           ReportError("Illegal character reference", pos);
    191           exit(-1);
     246          return XMLTestSuiteError::CHARREF;
    192247        }
    193248        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    194           ReportError("Illegal XML 1.0 character reference", pos);
    195           exit(-1);
     249          return XMLTestSuiteError::XML10CHARREF;
    196250        }
    197251        return 0;
     
    205259          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    206260          if (ch_val> 0x10FFFF ){
    207             ReportError("Illegal character reference", pos);
    208             exit(-1);
     261                        return XMLTestSuiteError::CHARREF;
    209262          }
    210263          s++;
    211264        }
    212265        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    213           ReportError("Illegal character reference", pos);
    214           exit(-1);
     266                  return XMLTestSuiteError::CHARREF;
    215267        }
    216268        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    217           ReportError("Illegal XML 1.0 character reference", pos);
    218           exit(-1);
     269                  return XMLTestSuiteError::XML10CHARREF;
    219270        }
    220271        return 0;
     
    241292          }
    242293          if (ch_val==60){
    243             ReportError("Attribute values contain '<' characters after reference expansion", pos);
    244             exit(-1);
     294            return XMLTestSuiteError::ATTREF;
    245295          }
    246296        }
    247297        else if(at_Ref_lt<ASCII>(s)){
    248           ReportError("Attribute values contain '<' characters after reference expansion", pos);
    249           exit(-1);
    250         }
    251         return 0;
    252 }
    253 
    254 
    255 
    256 @global
    257 
    258 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    259   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    260         basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
    261 }
    262 
    263 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    264   s2p_do_block(U8, basis_bits);
    265   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    266   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    267   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    268   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    269   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    270   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    271   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    272   basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     298          return XMLTestSuiteError::ATTREF;
     299        }
     300        return 0;
    273301}
    274302
     
    283311        int length = end - start;
    284312
    285         int gid = -1;
    286 
    287 
    288313        //lookup or insert to symbol table
    289314#if DEBUG
     
    296321#endif
    297322
    298         gid = symbol_table.Lookup_or_Insert_Name(source + start - buffer_base, length);
    299 
     323        int gid = symbol_table.Lookup_or_Insert_Name(source + start - buffer_base, length);
    300324        gids.push_back(gid);
    301325    }
     
    304328static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail){
    305329
    306     //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
    307     //      TagMatcher will crash if we feed a long symbol name.
    308     //      Sample file: test/long_sym_name.xml
    309 
    310             tracker.StoreNewlines(lex.LF);
    311 
    312             if ( bitblock_has_bit(tag_Callouts.ElemName_starts))
    313             {
    314                 StreamScan((ScanBlock *) &tag_Callouts.ElemName_starts, sizeof(BitBlock)/sizeof(ScanBlock), ElemStrt_check);
    315             }
    316 
    317             if ( bitblock_has_bit(tag_Callouts.ElemName_ends) )
    318             {
    319                 StreamScan((ScanBlock *) &tag_Callouts.ElemName_ends, sizeof(BitBlock)/sizeof(ScanBlock), ElemEnd_check);
    320             }
    321 
    322             do_symbol_table_lookup();
    323 
    324                 if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
    325                   StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
    326                   StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
    327                 }
    328 
    329                 if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
    330                   StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
    331                 }
    332 
    333                 if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
    334                   StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
    335                 }
    336 
    337                 if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
    338                   StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
    339                 }
    340 
    341                 if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
    342                   StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
    343                 }
    344 
    345                 if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
    346                   StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
    347                 }
    348 
    349                 if (bitblock_has_bit(check_streams.att_refs)){
    350                   StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
    351                 }
    352 
    353                 error_tracker.If_Error_Report_First();
    354 
    355                 matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    356                 tracker.AdvanceBlock();
     330    tracker.StoreNewlines(lex.LF);
     331    int rv, error_pos_in_block, error_line, error_column;
     332
     333    if ( bitblock_has_bit(tag_Callouts.ElemName_starts))
     334    {
     335        StreamScan((ScanBlock *) &tag_Callouts.ElemName_starts, sizeof(BitBlock)/sizeof(ScanBlock), ElemStrt_check, &error_pos_in_block);
     336    }
     337
     338    if ( bitblock_has_bit(tag_Callouts.ElemName_ends) )
     339    {
     340        StreamScan((ScanBlock *) &tag_Callouts.ElemName_ends, sizeof(BitBlock)/sizeof(ScanBlock), ElemEnd_check, &error_pos_in_block);
     341    }
     342
     343    do_symbol_table_lookup();
     344
     345    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
     346      rv = StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check, &error_pos_in_block);
     347      if (rv) {
     348              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     349              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     350              exit(-1);
     351      }
     352
     353      rv = StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check, &error_pos_in_block);
     354      if (rv) {
     355              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     356              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     357              exit(-1);
     358      }
     359    }
     360
     361    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
     362      rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check, &error_pos_in_block);
     363      if (rv) {
     364              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     365              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     366              exit(-1);
     367      }
     368    }
     369
     370    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
     371      rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check, &error_pos_in_block);
     372      if (rv) {
     373              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     374              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     375              exit(-1);
     376      }
     377    }
     378
     379    if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
     380      rv = StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check, &error_pos_in_block);
     381      if (rv) {
     382              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     383              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     384              exit(-1);
     385      }
     386    }
     387
     388    if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
     389      rv = StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check, &error_pos_in_block);
     390      if (rv) {
     391              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     392              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     393              exit(-1);
     394      }
     395    }
     396
     397    if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
     398      rv = StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check, &error_pos_in_block);
     399      if (rv) {
     400              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     401              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     402              exit(-1);
     403      }
     404    }
     405
     406    if (bitblock_has_bit(check_streams.att_refs)){
     407      rv = StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check, &error_pos_in_block);
     408      if (rv) {
     409              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     410              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     411              exit(-1);
     412      }
     413    }
     414
     415    if(error_tracker.Has_Noted_Error()){
     416            tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
     417            ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
     418            exit(-1);
     419    }
     420
     421    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     422    tracker.AdvanceBlock();
    357423}
    358424
     
    381447  buffer_base = buf_pos;
    382448  source = srcbuf;
     449
    383450  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
    384451  chars_avail = chars_read;
     
    430497
    431498/* Full Buffers */
    432     int block_segment_num = 0;
     499
    433500    while (chars_avail == BUFFER_SIZE) {
    434501      PERF_SEC_START(parser_timer);
     
    451518      buf_pos += chars_avail;
    452519      buffer_base = buf_pos;
    453       block_segment_num++;
    454520    }
    455521/* Final Partial Buffer */
     
    491557#endif
    492558}
    493 
    494 
    495 
    496 int
    497 main(int argc, char * argv[]) {
    498         char * infilename, * outfilename;
    499         FILE *infile, *outfile;
    500         struct stat fileinfo;
    501 
    502         if (argc < 2) {
    503                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    504                 exit(-1);
    505         }
    506 
    507         infilename = argv[1];
    508         stat(infilename, &fileinfo);
    509         infile = fopen(infilename, "rb");
    510         if (!infile) {
    511                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    512                 exit(-1);
    513         }
    514 
    515         if (argc < 3) outfile = stdout;
    516         else {
    517                 outfilename = argv[2];
    518                 outfile = fopen(outfilename, "wb");
    519                 if (!outfile) {
    520                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    521                         exit(-1);
    522                 }
    523         }
    524 
    525 //      PERF_SEC_BIND(1);
    526 
    527         PERF_SEC_INIT(parser_timer);
    528 
    529         do_process(infile, outfile);
    530 
    531         PERF_SEC_DUMP(parser_timer);
    532 
    533         PERF_SEC_DESTROY(parser_timer);
    534 
    535         fclose(infile);
    536         fclose(outfile);
    537 
    538         printf ("Done procressing\n");
    539         return(0);
    540 }
Note: See TracChangeset for help on using the changeset viewer.