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_hash_template.cpp

    r1428 r1457  
     1#define TEMPLATED_SIMD_LIB
     2
    13#include <stdio.h>
    24#include <stdlib.h>
     
    68#include <../lib_simd.h>
    79#include <hash_symbol_table.h>
    8 
    910#include <queue>
    1011#include <string>
     12
     13typedef long ScanBlock;
     14typedef SIMD_type BytePack;
     15typedef SIMD_type BitBlock;
     16
     17using namespace std;
    1118
    1219#define DEBUG 0
     
    1623#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
    1724
    18 typedef long ScanBlock;
    19 typedef SIMD_type BytePack;
    20 typedef SIMD_type BitBlock;
    21 
    22 using namespace std;
    23 
    2425#include <../carryQ.h>
    2526#include <xmldecl.h>
    26 #include <xml_error.c>
    27 #include <xmldecl.c>
    2827#include <namechars.h>
    29 
    3028#include <../perflib/perfsec.h>
    3129#include <../s2p.h>
     
    3331#include <TagMatcher.h>
    3432#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>
    3541
    3642#ifdef BUFFER_PROFILING
     
    5359char * source;
    5460LineColTracker tracker;
    55 
    56 static inline void ReportError(const char * error_msg, int error_pos_in_block) {
    57   int error_line, error_column;
    58   tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
    59   fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
    60 }
    61 
    62 class ErrorTracker {
    63 public:
    64     ErrorTracker() { noted_pos_in_block = -1;}
    65 
    66     inline void NoteError(const char * error_msg, BitBlock err_strm) {
    67       int pos_in_block = count_forward_zeroes(err_strm);
    68       if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
    69         noted_pos_in_block = pos_in_block;
    70         noted_error = error_msg;
    71       }
    72     }
    73 
    74     inline void If_Error_Report_First() {
    75       if (noted_pos_in_block > -1) {
    76               int error_line, error_column;
    77               ReportError(noted_error, noted_pos_in_block);
    78               exit(-1);
    79       }
    80     }
    81 
    82 private:
    83   const char * noted_error;
    84   int noted_pos_in_block;
    85 };
    86 
    87 
    8861TagMatcher matcher;
     62ErrorTracker error_tracker;
    8963BitBlock EOF_mask = simd_const_1(1);
    90 
    91 ErrorTracker error_tracker;
    9264
    9365queue <size_t> elem_starts_buf;
     
    9668HashSymbolTable symbol_table;
    9769
    98 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
     70/* StreamScan & Post Process Declarations */
     71//      static inline int StreamScanToFirst(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block)
     72static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block);
     73
     74static inline int NameStrt_check(int pos);
     75static inline int Name_check(int pos);
     76static inline int PIName_check(int pos);
     77static inline int CD_check(int pos);
     78static inline int GenRef_check(int pos);
     79static inline int HexRef_check(int pos);
     80static inline int DecRef_check(int pos);
     81static inline int AttRef_check(int pos);
     82
     83@global
     84
     85static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
     86static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
     87static 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);
     88static inline void do_symbol_table_lookup();
     89
     90void do_process(FILE *infile, FILE *outfile);
     91
     92int main(int argc, char * argv[]) {
     93        char * infilename, * outfilename;
     94        FILE *infile, *outfile;
     95        struct stat fileinfo;
     96
     97        if (argc < 2) {
     98                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
     99                exit(-1);
     100        }
     101
     102        infilename = argv[1];
     103        stat(infilename, &fileinfo);
     104        infile = fopen(infilename, "rb");
     105        if (!infile) {
     106                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
     107                exit(-1);
     108        }
     109
     110        if (argc < 3) outfile = stdout;
     111        else {
     112                outfilename = argv[2];
     113                outfile = fopen(outfilename, "wb");
     114                if (!outfile) {
     115                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
     116                        exit(-1);
     117                }
     118        }
     119
     120//      PERF_SEC_BIND(1);
     121
     122        PERF_SEC_INIT(parser_timer);
     123
     124        do_process(infile, outfile);
     125
     126        PERF_SEC_DUMP(parser_timer);
     127
     128        PERF_SEC_DESTROY(parser_timer);
     129
     130        fclose(infile);
     131        fclose(outfile);
     132
     133        return(0);
     134}
     135
     136/* s2p Definitions */
     137static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
     138  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
     139        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);
     140}
     141
     142static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
     143  s2p_do_block(U8, basis_bits);
     144  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
     145  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
     146  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
     147  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
     148  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
     149  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
     150  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
     151  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     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
    99157        int blk;
    100         int block_pos = 0;
     158        int block_pos = 0;
     159        int pos;
     160
    101161        for (blk = 0; blk < blk_count; blk++) {
    102                 ScanBlock s = stream[blk];
    103                 while(s) {
    104                         int code = (ProcessPos(cfzl(s) + block_pos));
    105                         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                        }
    106170                        s = s & (s-1);  // clear rightmost bit.
    107171                }
     
    112176
    113177static inline int ElemStrt_check(int pos) {
    114         int block_pos = block_base + pos;
     178        int block_pos = block_base + pos;
    115179        elem_starts_buf.push(buffer_base + block_pos);
    116         return 0;
     180        return 0;
    117181}
    118182
    119183static inline int ElemEnd_check(int pos) {
    120         int block_pos = block_base + pos;
     184        int block_pos = block_base + pos;
    121185        elem_ends_buf.push(buffer_base + block_pos);
    122         return 0;
     186        return 0;
    123187}
    124188
    125189static inline int NameStrt_check(int pos) {
    126         int block_pos = block_base + pos;
     190        int block_pos = block_base + pos;
    127191        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
    128               ReportError("name start error", pos);
    129               exit(-1);
     192              return XMLTestSuiteError::NAME_START;
    130193        }
    131194        return 0;
     
    135198        int block_pos = block_base + pos;
    136199        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
    137               ReportError("name error", pos);
    138               exit(-1);
     200                  return XMLTestSuiteError::NAME;
    139201        }
    140202        return 0;
     
    144206        int block_pos = block_base + pos;
    145207        int file_pos = block_pos+buffer_base;
    146         printf ("%s:%i\n",__FUNCTION__,pos);
    147208        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
    148209              // "<?xml" legal at start of file.
    149               if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
    150               ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
    151               exit(-1);
     210              if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
     211                  return XMLTestSuiteError::XMLPINAME;
     212              }
    152213        }
    153214        return 0;
     
    157218        int block_pos = block_base + pos;
    158219        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
    159               ReportError("CDATA error", pos);
    160               exit(-1);
     220                  return XMLTestSuiteError::CDATA;
    161221        }
    162222        return 0;
     
    167227        unsigned char* s = (unsigned char*)&source[block_pos];
    168228        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))){
    169               ReportError("Undefined reference", pos);
    170               exit(-1);
     229              return XMLTestSuiteError::UNDEFREF;
    171230        }
    172231        return 0;
     
    180239          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    181240          if (ch_val> 0x10FFFF ){
    182             ReportError("Illegal character reference", pos);
    183             exit(-1);
     241                return XMLTestSuiteError::CHARREF;
    184242          }
    185243          s++;
    186244        }
    187245        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    188           ReportError("Illegal character reference", pos);
    189           exit(-1);
     246          return XMLTestSuiteError::CHARREF;
    190247        }
    191248        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    192           ReportError("Illegal XML 1.0 character reference", pos);
    193           exit(-1);
     249          return XMLTestSuiteError::XML10CHARREF;
    194250        }
    195251        return 0;
     
    203259          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    204260          if (ch_val> 0x10FFFF ){
    205             ReportError("Illegal character reference", pos);
    206             exit(-1);
     261                        return XMLTestSuiteError::CHARREF;
    207262          }
    208263          s++;
    209264        }
    210265        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    211           ReportError("Illegal character reference", pos);
    212           exit(-1);
     266                  return XMLTestSuiteError::CHARREF;
    213267        }
    214268        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    215           ReportError("Illegal XML 1.0 character reference", pos);
    216           exit(-1);
     269                  return XMLTestSuiteError::XML10CHARREF;
    217270        }
    218271        return 0;
     
    239292          }
    240293          if (ch_val==60){
    241             ReportError("Attribute values contain '<' characters after reference expansion", pos);
    242             exit(-1);
     294            return XMLTestSuiteError::ATTREF;
    243295          }
    244296        }
    245297        else if(at_Ref_lt<ASCII>(s)){
    246           ReportError("Attribute values contain '<' characters after reference expansion", pos);
    247           exit(-1);
    248         }
    249         return 0;
    250 }
    251 
    252 
    253 
    254 @global
    255 
    256 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    257   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    258         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);
    259 }
    260 
    261 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    262   s2p_do_block(U8, basis_bits);
    263   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    264   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    265   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    266   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    267   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    268   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    269   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    270   basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     298          return XMLTestSuiteError::ATTREF;
     299        }
     300        return 0;
    271301}
    272302
     
    281311        int length = end - start;
    282312
    283         int gid = -1;
    284 
    285 
    286313        //lookup or insert to symbol table
    287314#if DEBUG
     
    294321#endif
    295322
    296         gid = symbol_table.Lookup_or_Insert_Name(source + start - buffer_base, length);
     323        int gid = symbol_table.Lookup_or_Insert_Name(source + start - buffer_base, length);
    297324        gids.push_back(gid);
    298325    }
     
    301328static 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){
    302329
    303     //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
    304     //      TagMatcher will crash if we feed a long symbol name.
    305     //      Sample file: test/long_sym_name.xml
    306 
    307             tracker.StoreNewlines(lex.LF);
    308 
    309             if ( bitblock_has_bit(tag_Callouts.ElemName_starts))
    310             {
    311                 StreamScan((ScanBlock *) &tag_Callouts.ElemName_starts, sizeof(BitBlock)/sizeof(ScanBlock), ElemStrt_check);
    312             }
    313 
    314             if ( bitblock_has_bit(tag_Callouts.ElemName_ends) )
    315             {
    316                 StreamScan((ScanBlock *) &tag_Callouts.ElemName_ends, sizeof(BitBlock)/sizeof(ScanBlock), ElemEnd_check);
    317             }
    318 
    319             do_symbol_table_lookup();
    320 
    321                 if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
    322                   StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
    323                   StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
    324                 }
    325 
    326                 if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
    327                   StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
    328                 }
    329 
    330                 if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
    331                   StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
    332                 }
    333 
    334                 if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
    335                   StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
    336                 }
    337 
    338                 if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
    339                   StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
    340                 }
    341 
    342                 if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
    343                   StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
    344                 }
    345 
    346                 if (bitblock_has_bit(check_streams.att_refs)){
    347                   StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
    348                 }
    349 
    350                 error_tracker.If_Error_Report_First();
    351 
    352                 matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    353                 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
     346    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
     347      rv = StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check, &error_pos_in_block);
     348      if (rv) {
     349              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     350              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     351              exit(-1);
     352      }
     353
     354      rv = StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check, &error_pos_in_block);
     355      if (rv) {
     356              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     357              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     358              exit(-1);
     359      }
     360    }
     361
     362    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
     363      rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check, &error_pos_in_block);
     364      if (rv) {
     365              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     366              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     367              exit(-1);
     368      }
     369    }
     370
     371    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
     372      rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check, &error_pos_in_block);
     373      if (rv) {
     374              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     375              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     376              exit(-1);
     377      }
     378    }
     379
     380    if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
     381      rv = StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check, &error_pos_in_block);
     382      if (rv) {
     383              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     384              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     385              exit(-1);
     386      }
     387    }
     388
     389    if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
     390      rv = StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check, &error_pos_in_block);
     391      if (rv) {
     392              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     393              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     394              exit(-1);
     395      }
     396    }
     397
     398    if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
     399      rv = StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check, &error_pos_in_block);
     400      if (rv) {
     401              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     402              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     403              exit(-1);
     404      }
     405    }
     406
     407    if (bitblock_has_bit(check_streams.att_refs)){
     408      rv = StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check, &error_pos_in_block);
     409      if (rv) {
     410              tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     411              ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     412              exit(-1);
     413      }
     414    }
     415
     416    if(error_tracker.Has_Noted_Error()){
     417            tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
     418            ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
     419            exit(-1);
     420    }
     421
     422    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     423    tracker.AdvanceBlock();
    354424}
    355425
     
    427497
    428498/* Full Buffers */
    429     int block_segment_num = 0;
    430499    while (chars_avail == BUFFER_SIZE) {
    431500      PERF_SEC_START(parser_timer);
     
    449518      buf_pos += chars_avail;
    450519      buffer_base = buf_pos;
    451       block_segment_num++;
    452520    }
    453521/* Final Partial Buffer */
     
    488556#endif
    489557}
    490 
    491 
    492 
    493 int
    494 main(int argc, char * argv[]) {
    495         char * infilename, * outfilename;
    496         FILE *infile, *outfile;
    497         struct stat fileinfo;
    498 
    499         if (argc < 2) {
    500                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    501                 exit(-1);
    502         }
    503 
    504         infilename = argv[1];
    505         stat(infilename, &fileinfo);
    506         infile = fopen(infilename, "rb");
    507         if (!infile) {
    508                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    509                 exit(-1);
    510         }
    511 
    512         if (argc < 3) outfile = stdout;
    513         else {
    514                 outfilename = argv[2];
    515                 outfile = fopen(outfilename, "wb");
    516                 if (!outfile) {
    517                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    518                         exit(-1);
    519                 }
    520         }
    521 
    522 //      PERF_SEC_BIND(1);
    523 
    524         PERF_SEC_INIT(parser_timer);
    525 
    526         do_process(infile, outfile);
    527 
    528         PERF_SEC_DUMP(parser_timer);
    529 
    530         PERF_SEC_DESTROY(parser_timer);
    531 
    532         fclose(infile);
    533         fclose(outfile);
    534 
    535         printf ("Done procressing\n");
    536         return(0);
    537 }
Note: See TracChangeset for help on using the changeset viewer.