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

    r1684 r1721  
    1 #include "../symtab_global.h"
     1#include "../common_definitions.h"
    22#include <ls_symbol_table.h>
     3
     4#include "../symtab_common_functions.h"
     5#include "../xmlwf_common_functions.h"
    36
    47#ifdef BUFFER_PROFILING
     
    1922int buffer_base=0;
    2023int buffer_last;
    21 char * source;
    22 LineColTracker tracker;
     24
    2325TagMatcher matcher;
    24 ErrorTracker error_tracker;
    25 BitBlock EOF_mask = simd<1>::constant<1>();
    2626
    2727queue <size_t> elem_starts_buf;
     
    2929LSSymbolTable ls_symbol_table;
    3030
    31 static inline int NameStrt_check(int pos);
    32 static inline int Name_check(int pos);
    33 static inline int PIName_check(int pos);
    34 static inline int CD_check(int pos);
    35 static inline int GenRef_check(int pos);
    36 static inline int HexRef_check(int pos);
    37 static inline int DecRef_check(int pos);
    38 static inline int AttRef_check(int pos);
    39 
    40 @global
    41 
    42 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
    43 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
    4431static 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);
    4532void do_process(FILE *infile, FILE *outfile);
    4633
    47 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int));
    48 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int,int));
    4934static inline void do_symbol_table_lookup();
    5035
    5136int main(int argc, char * argv[]) {
    52         char * infilename, * outfilename;
    53         FILE *infile, *outfile;
    54         struct stat fileinfo;
    55 
    56         if (argc < 2) {
    57                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    58                 exit(-1);
    59         }
    60 
    61         infilename = argv[1];
    62         stat(infilename, &fileinfo);
    63         infile = fopen(infilename, "rb");
    64         if (!infile) {
    65                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    66                 exit(-1);
    67         }
    68 
    69         if (argc < 3) outfile = stdout;
    70         else {
    71                 outfilename = argv[2];
    72                 outfile = fopen(outfilename, "wb");
    73                 if (!outfile) {
    74                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    75                         exit(-1);
    76                 }
    77         }
     37    char * infilename, * outfilename;
     38    FILE *infile, *outfile;
     39
     40    getFilenames(argc, argv, infilename, outfilename);
     41    openInputOutputFiles(infilename, outfilename,
     42                         infile, outfile);
    7843
    7944//      PERF_SEC_BIND(1);
    8045
    81         PERF_SEC_INIT(parser_timer);
    82 
    83         do_process(infile, outfile);
    84 
    85         PERF_SEC_DUMP(parser_timer);
    86 
    87         PERF_SEC_DESTROY(parser_timer);
    88 
    89         fclose(infile);
    90         fclose(outfile);
    91 
    92         return(0);
    93 }
    94 
    95 /* s2p Definitions */
    96 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    97   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    98         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);
    99 }
    100 
    101 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    102   s2p_do_block(U8, basis_bits);
    103   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    104   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    105   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    106   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    107   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    108   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    109   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    110   basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
     46    PERF_SEC_INIT(parser_timer);
     47
     48    // store symbols form text to Symbol Table
     49    do_process(infile, outfile);
     50
     51    PERF_SEC_DUMP(parser_timer);
     52
     53    PERF_SEC_DESTROY(parser_timer);
     54
     55    fclose(infile);
     56    fclose(outfile);
     57
     58#if PRINT_SYMBOL_DISTRIBUTION
     59    print_GIDS(ls_symbol_table);
     60#endif
     61    ls_symbol_table.clear();
     62    return(0);
    11163}
    11264
     
    12072        return 0;
    12173}
    122 
    123 static inline int NameStrt_check(int pos) {
    124         if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
    125               return XMLTestSuiteError::NAME_START;
    126         }
    127         return 0;
    128 }
    129 
    130 static inline int Name_check(int pos) {
    131         if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
    132                   return XMLTestSuiteError::NAME;
    133         }
    134         return 0;
    135 }
    136 
    137 static inline int PIName_check(int pos, int file_pos) {
    138         if (at_XxMmLll<ASCII>((unsigned char*)&source[pos]) && (source[pos+3]=='?' || source[pos+3]<= ' ')) {
    139               // "<?xml" legal at start of file.
    140               if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
    141                   return XMLTestSuiteError::XMLPINAME;
    142               }
    143         }
    144         return 0;
    145 }
    146 
    147 static inline int CD_check(int pos) {
    148         if (!at_CDATA1<ASCII>((unsigned char*)&source[pos])){
    149                   return XMLTestSuiteError::CDATA;
    150         }
    151         return 0;
    152 }
    153 
    154 static inline int GenRef_check(int pos) {
    155         unsigned char* s = (unsigned char*)&source[pos];
    156         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))){
    157               return XMLTestSuiteError::UNDEFREF;
    158         }
    159         return 0;
    160 }
    161 
    162 static inline int HexRef_check(int pos) {
    163         unsigned char* s = (unsigned char*)&source[pos];
    164         int ch_val = 0;
    165         while(at_HexDigit<ASCII>(s)){
    166           ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    167           if (ch_val> 0x10FFFF ){
    168                 return XMLTestSuiteError::CHARREF;
    169           }
    170           s++;
    171         }
    172         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    173           return XMLTestSuiteError::CHARREF;
    174         }
    175         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    176           return XMLTestSuiteError::XML10CHARREF;
    177         }
    178         return 0;
    179 }
    180 
    181 static inline int DecRef_check(int pos) {
    182         unsigned char* s = (unsigned char*)&source[pos];
    183         int ch_val = 0;
    184         while(at_HexDigit<ASCII>(s)){
    185           ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    186           if (ch_val> 0x10FFFF ){
    187                         return XMLTestSuiteError::CHARREF;
    188           }
    189           s++;
    190         }
    191         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    192                   return XMLTestSuiteError::CHARREF;
    193         }
    194         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    195                   return XMLTestSuiteError::XML10CHARREF;
    196         }
    197         return 0;
    198 }
    199 
    200 static inline int AttRef_check(int pos) {
    201         unsigned char* s = (unsigned char*)&source[pos];
    202         int ch_val = 0;
    203         if(s[0]=='#'){
    204           s++;
    205           if(s[0]=='x' || s[0]=='X'){
    206             s++;
    207             while(at_HexDigit<ASCII>(s)){
    208               ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    209               s++;
    210             }
    211           }
    212           else{
    213             while(at_HexDigit<ASCII>(s)){
    214               ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    215               s++;
    216             }
    217           }
    218           if (ch_val==60){
    219             return XMLTestSuiteError::ATTREF;
    220           }
    221         }
    222         else if(at_Ref_lt<ASCII>(s)){
    223           return XMLTestSuiteError::ATTREF;
    224         }
    225         return 0;
    226 }
    227 
    228 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
    229 
    230         BitBlockForwardIterator end;
    231         int pos, block_pos;
    232 
    233         while(start != end) {
    234 
    235                 block_pos = block_base + *start;
    236                 int rv = is_valid(block_pos);
    237 
    238                 if (rv) {
    239                         int error_line, error_column;
    240                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    241                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    242                         exit(-1);
    243                 }
    244                 start++;
    245         }
    246 }
    247 
    248 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
    249 
    250         BitBlockForwardIterator end;
    251         int pos, block_pos, file_pos;
    252 
    253         while(start != end) {
    254 
    255                 block_pos = block_base + *start;
    256                 file_pos = block_pos+buffer_base;
    257 
    258 
    259                 int rv = is_valid(block_pos, file_pos);
    260 
    261                 if (rv) {
    262                         int error_line, error_column;
    263                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    264                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    265                         exit(-1);
    266                 }
    267                 start++;
    268         }
    269 }
    270 
    27174
    27275static inline void do_symbol_table_lookup()
     
    354157    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    355158    tracker.AdvanceBlock();
    356 }
    357 
    358 static inline void print_GIDS()
    359 {
    360     ls_symbol_table.display_flattened_symbol_values();
    361     ls_symbol_table.display_flattened_gids();
    362159}
    363160
     
    483280      exit(-1);
    484281    }
    485 
    486 #if DEBUG
    487     print_GIDS();
    488 #endif
    489     ls_symbol_table.clear();
    490 }
     282}
Note: See TracChangeset for help on using the changeset viewer.