Ignore:
Timestamp:
Nov 21, 2011, 4:09:54 PM (8 years ago)
Author:
vla24
Message:

SymbolTable?: completed dictionary implementation and refactored templates

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/SymbolTable/symtab_stl_template.cpp

    r1684 r1721  
    1 #include "../symtab_global.h"
     1#include "../common_definitions.h"
    22#include <symtab.h>
     3
     4#include "../symtab_common_functions.h"
     5#include "../xmlwf_common_functions.h"
    36
    47#ifdef BUFFER_PROFILING
     
    1821int block_base=0;
    1922int buffer_base=0;
    20 char * source;
    21 LineColTracker tracker;
     23
    2224TagMatcher matcher;
    23 ErrorTracker error_tracker;
    24 BitBlock EOF_mask = simd<1>::constant<1>();
    2525
    2626queue <size_t> elem_starts_buf;
     
    2929SymbolTable symbol_table;
    3030
    31 /* StreamScan & Post Process Declarations */
    32 //      static inline int StreamScanToFirst(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block)
    33 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block);
    34 
    35 static inline int NameStrt_check(int pos);
    36 static inline int Name_check(int pos);
    37 static inline int PIName_check(int pos);
    38 static inline int CD_check(int pos);
    39 static inline int GenRef_check(int pos);
    40 static inline int HexRef_check(int pos);
    41 static inline int DecRef_check(int pos);
    42 static inline int AttRef_check(int pos);
    43 
    44 @global
    45 
    46 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
    47 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
    4831static 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);
    4932void do_process(FILE *infile, FILE *outfile);
    5033
    51 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int));
    52 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int,int));
    53 
    5434static inline void do_symbol_table_lookup();
    5535
    5636
    5737int main(int argc, char * argv[]) {
    58         char * infilename, * outfilename;
    59         FILE *infile, *outfile;
    60         struct stat fileinfo;
    61 
    62         if (argc < 2) {
    63                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    64                 exit(-1);
    65         }
    66 
    67         infilename = argv[1];
    68         stat(infilename, &fileinfo);
    69         infile = fopen(infilename, "rb");
    70         if (!infile) {
    71                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    72                 exit(-1);
    73         }
    74 
    75         if (argc < 3) outfile = stdout;
    76         else {
    77                 outfilename = argv[2];
    78                 outfile = fopen(outfilename, "wb");
    79                 if (!outfile) {
    80                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    81                         exit(-1);
    82                 }
    83         }
     38    char * infilename, * outfilename;
     39    FILE *infile, *outfile;
     40
     41    getFilenames(argc, argv, infilename, outfilename);
     42    openInputOutputFiles(infilename, outfilename,
     43                         infile, outfile);
    8444
    8545//      PERF_SEC_BIND(1);
    8646
    87         PERF_SEC_INIT(parser_timer);
    88 
    89         do_process(infile, outfile);
    90 
    91         PERF_SEC_DUMP(parser_timer);
    92 
    93         PERF_SEC_DESTROY(parser_timer);
    94 
    95         fclose(infile);
    96         fclose(outfile);
    97 
    98         return(0);
    99 }
    100 
    101 /* s2p Definitions */
    102 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    103   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    104         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);
    105 }
    106 
    107 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    108   s2p_do_block(U8, basis_bits);
    109   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    110   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    111   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    112   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    113   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    114   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    115   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    116   basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     47    PERF_SEC_INIT(parser_timer);
     48
     49    // store symbols form text to Symbol Table
     50    do_process(infile, outfile);
     51
     52    PERF_SEC_DUMP(parser_timer);
     53
     54    PERF_SEC_DESTROY(parser_timer);
     55
     56    fclose(infile);
     57    fclose(outfile);
     58
     59#if PRINT_SYMBOL_DISTRIBUTION
     60    print_GIDS(gids);
     61#endif
     62
     63    return(0);
    11764}
    11865
     
    12572        elem_ends_buf.push(buffer_base + pos);
    12673        return 0;
    127 }
    128 
    129 static inline int NameStrt_check(int pos) {
    130         if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
    131               return XMLTestSuiteError::NAME_START;
    132         }
    133         return 0;
    134 }
    135 
    136 static inline int Name_check(int pos) {
    137         if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
    138                   return XMLTestSuiteError::NAME;
    139         }
    140         return 0;
    141 }
    142 
    143 static inline int PIName_check(int pos, int file_pos) {
    144         if (at_XxMmLll<ASCII>((unsigned char*)&source[pos]) && (source[pos+3]=='?' || source[pos+3]<= ' ')) {
    145               // "<?xml" legal at start of file.
    146               if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
    147                   return XMLTestSuiteError::XMLPINAME;
    148               }
    149         }
    150         return 0;
    151 }
    152 
    153 static inline int CD_check(int pos) {
    154         if (!at_CDATA1<ASCII>((unsigned char*)&source[pos])){
    155                   return XMLTestSuiteError::CDATA;
    156         }
    157         return 0;
    158 }
    159 
    160 static inline int GenRef_check(int pos) {
    161         unsigned char* s = (unsigned char*)&source[pos];
    162         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))){
    163               return XMLTestSuiteError::UNDEFREF;
    164         }
    165         return 0;
    166 }
    167 
    168 static inline int HexRef_check(int pos) {
    169         unsigned char* s = (unsigned char*)&source[pos];
    170         int ch_val = 0;
    171         while(at_HexDigit<ASCII>(s)){
    172           ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    173           if (ch_val> 0x10FFFF ){
    174                 return XMLTestSuiteError::CHARREF;
    175           }
    176           s++;
    177         }
    178         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    179           return XMLTestSuiteError::CHARREF;
    180         }
    181         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    182           return XMLTestSuiteError::XML10CHARREF;
    183         }
    184         return 0;
    185 }
    186 
    187 static inline int DecRef_check(int pos) {
    188         unsigned char* s = (unsigned char*)&source[pos];
    189         int ch_val = 0;
    190         while(at_HexDigit<ASCII>(s)){
    191           ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    192           if (ch_val> 0x10FFFF ){
    193                         return XMLTestSuiteError::CHARREF;
    194           }
    195           s++;
    196         }
    197         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    198                   return XMLTestSuiteError::CHARREF;
    199         }
    200         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    201                   return XMLTestSuiteError::XML10CHARREF;
    202         }
    203         return 0;
    204 }
    205 
    206 static inline int AttRef_check(int pos) {
    207         unsigned char* s = (unsigned char*)&source[pos];
    208         int ch_val = 0;
    209         if(s[0]=='#'){
    210           s++;
    211           if(s[0]=='x' || s[0]=='X'){
    212             s++;
    213             while(at_HexDigit<ASCII>(s)){
    214               ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    215               s++;
    216             }
    217           }
    218           else{
    219             while(at_HexDigit<ASCII>(s)){
    220               ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    221               s++;
    222             }
    223           }
    224           if (ch_val==60){
    225             return XMLTestSuiteError::ATTREF;
    226           }
    227         }
    228         else if(at_Ref_lt<ASCII>(s)){
    229           return XMLTestSuiteError::ATTREF;
    230         }
    231         return 0;
    232 }
    233 
    234 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
    235 
    236         BitBlockForwardIterator end;
    237         int pos, block_pos;
    238 
    239         while(start != end) {
    240 
    241                 block_pos = block_base + *start;
    242                 int rv = is_valid(block_pos);
    243 
    244                 if (rv) {
    245                         int error_line, error_column;
    246                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    247                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    248                         exit(-1);
    249                 }
    250                 start++;
    251         }
    252 }
    253 
    254 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
    255 
    256         BitBlockForwardIterator end;
    257         int pos, block_pos, file_pos;
    258 
    259         while(start != end) {
    260 
    261                 block_pos = block_base + *start;
    262                 file_pos = block_pos+buffer_base;
    263 
    264 
    265                 int rv = is_valid(block_pos, file_pos);
    266 
    267                 if (rv) {
    268                         int error_line, error_column;
    269                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    270                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    271                         exit(-1);
    272                 }
    273                 start++;
    274         }
    27574}
    27675
     
    358157    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    359158    tracker.AdvanceBlock();
    360 }
    361 
    362 static inline void print_GIDS()
    363 {
    364     int span_count = gids.size();
    365     for(int i=0;i<span_count;i++) {
    366              cout << gids[i] << " ";
    367     }
    368     cout << endl;
    369159}
    370160
     
    490280    }
    491281
    492 #if DEBUG
    493     print_GIDS();
    494 #endif
    495 }
     282}
Note: See TracChangeset for help on using the changeset viewer.