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

    r1684 r1721  
    1 #include "../symtab_global.h"
     1#include "../common_definitions.h"
    22#include <hash_symbol_table.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;
     
    2929HashSymbolTable 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));
    49 
    5034static inline void do_symbol_table_lookup();
    5135
    52 void do_process(FILE *infile, FILE *outfile);
    53 
    5436int main(int argc, char * argv[]) {
    55         char * infilename, * outfilename;
    56         FILE *infile, *outfile;
    57         struct stat fileinfo;
    58 
    59         if (argc < 2) {
    60                 printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
    61                 exit(-1);
    62         }
    63 
    64         infilename = argv[1];
    65         stat(infilename, &fileinfo);
    66         infile = fopen(infilename, "rb");
    67         if (!infile) {
    68                 fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
    69                 exit(-1);
    70         }
    71 
    72         if (argc < 3) outfile = stdout;
    73         else {
    74                 outfilename = argv[2];
    75                 outfile = fopen(outfilename, "wb");
    76                 if (!outfile) {
    77                         fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
    78                         exit(-1);
    79                 }
    80         }
     37    char * infilename, * outfilename;
     38    FILE *infile, *outfile;
     39
     40    getFilenames(argc, argv, infilename, outfilename);
     41    openInputOutputFiles(infilename, outfilename,
     42                         infile, outfile);
    8143
    8244//      PERF_SEC_BIND(1);
    8345
    84         PERF_SEC_INIT(parser_timer);
    85 
    86         do_process(infile, outfile);
    87 
    88         PERF_SEC_DUMP(parser_timer);
    89 
    90         PERF_SEC_DESTROY(parser_timer);
    91 
    92         fclose(infile);
    93         fclose(outfile);
    94 
    95         return(0);
    96 }
    97 
    98 /* s2p Definitions */
    99 static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
    100   s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
    101         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);
    102 }
    103 
    104 static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
    105   s2p_do_block(U8, basis_bits);
    106   basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
    107   basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
    108   basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
    109   basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
    110   basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
    111   basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
    112   basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
    113   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(gids);
     60#endif
     61    return(0);
    11462}
    11563
     
    12270        elem_ends_buf.push(buffer_base + pos);
    12371        return 0;
    124 }
    125 
    126 static inline int NameStrt_check(int pos) {
    127         if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[pos]) == 0){
    128               return XMLTestSuiteError::NAME_START;
    129         }
    130         return 0;
    131 }
    132 
    133 static inline int Name_check(int pos) {
    134         if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[pos]) == 0){
    135                   return XMLTestSuiteError::NAME;
    136         }
    137         return 0;
    138 }
    139 
    140 static inline int PIName_check(int pos, int file_pos) {
    141         if (at_XxMmLll<ASCII>((unsigned char*)&source[pos]) && (source[pos+3]=='?' || source[pos+3]<= ' ')) {
    142               // "<?xml" legal at start of file.
    143               if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
    144                   return XMLTestSuiteError::XMLPINAME;
    145               }
    146         }
    147         return 0;
    148 }
    149 
    150 static inline int CD_check(int pos) {
    151         if (!at_CDATA1<ASCII>((unsigned char*)&source[pos])){
    152                   return XMLTestSuiteError::CDATA;
    153         }
    154         return 0;
    155 }
    156 
    157 static inline int GenRef_check(int pos) {
    158         unsigned char* s = (unsigned char*)&source[pos];
    159         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))){
    160               return XMLTestSuiteError::UNDEFREF;
    161         }
    162         return 0;
    163 }
    164 
    165 static inline int HexRef_check(int pos) {
    166         unsigned char* s = (unsigned char*)&source[pos];
    167         int ch_val = 0;
    168         while(at_HexDigit<ASCII>(s)){
    169           ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    170           if (ch_val> 0x10FFFF ){
    171                 return XMLTestSuiteError::CHARREF;
    172           }
    173           s++;
    174         }
    175         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    176           return XMLTestSuiteError::CHARREF;
    177         }
    178         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    179           return XMLTestSuiteError::XML10CHARREF;
    180         }
    181         return 0;
    182 }
    183 
    184 static inline int DecRef_check(int pos) {
    185         unsigned char* s = (unsigned char*)&source[pos];
    186         int ch_val = 0;
    187         while(at_HexDigit<ASCII>(s)){
    188           ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    189           if (ch_val> 0x10FFFF ){
    190                         return XMLTestSuiteError::CHARREF;
    191           }
    192           s++;
    193         }
    194         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    195                   return XMLTestSuiteError::CHARREF;
    196         }
    197         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    198                   return XMLTestSuiteError::XML10CHARREF;
    199         }
    200         return 0;
    201 }
    202 
    203 static inline int AttRef_check(int pos) {
    204         unsigned char* s = (unsigned char*)&source[pos];
    205         int ch_val = 0;
    206         if(s[0]=='#'){
    207           s++;
    208           if(s[0]=='x' || s[0]=='X'){
    209             s++;
    210             while(at_HexDigit<ASCII>(s)){
    211               ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    212               s++;
    213             }
    214           }
    215           else{
    216             while(at_HexDigit<ASCII>(s)){
    217               ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    218               s++;
    219             }
    220           }
    221           if (ch_val==60){
    222             return XMLTestSuiteError::ATTREF;
    223           }
    224         }
    225         else if(at_Ref_lt<ASCII>(s)){
    226           return XMLTestSuiteError::ATTREF;
    227         }
    228         return 0;
    229 }
    230 
    231 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int is_valid(int)) {
    232 
    233         BitBlockForwardIterator end;
    234         int pos, block_pos;
    235 
    236         while(start != end) {
    237 
    238                 block_pos = block_base + *start;
    239                 int rv = is_valid(block_pos);
    240 
    241                 if (rv) {
    242                         int error_line, error_column;
    243                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    244                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    245                         exit(-1);
    246                 }
    247                 start++;
    248         }
    249 }
    250 
    251 static inline void validate_block(BitBlockForwardIterator & start, int block_base, int buffer_base, int is_valid(int,int)) {
    252 
    253         BitBlockForwardIterator end;
    254         int pos, block_pos, file_pos;
    255 
    256         while(start != end) {
    257 
    258                 block_pos = block_base + *start;
    259                 file_pos = block_pos+buffer_base;
    260 
    261 
    262                 int rv = is_valid(block_pos, file_pos);
    263 
    264                 if (rv) {
    265                         int error_line, error_column;
    266                         tracker.get_Line_and_Column(block_pos, error_line, error_column);
    267                         ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
    268                         exit(-1);
    269                 }
    270                 start++;
    271         }
    27272}
    27373
     
    486286      exit(-1);
    487287    }
    488 #if DEBUG
    489     print_GIDS();
    490 #endif
    491 }
     288}
Note: See TracChangeset for help on using the changeset viewer.