Changeset 588 for proto


Ignore:
Timestamp:
Aug 20, 2010, 2:12:29 PM (9 years ago)
Author:
lindanl
Message:

check if attribute values contain '<' after reference expansion

Location:
proto/parabix2
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/parabix2/parabix2_compilable.py

    r586 r588  
    332332        # Not needed for xmlwf
    333333        callouts.AttNames = AttNameFollows - AttNameStarts
    334         #callouts.AttVals = AttValFollows - AttValStarts
     334        callouts.AttVals = AttValFollows - AttValStarts
    335335        STagEnds = AttListEnd & lex.RAngle
    336336        # Mark any "/" characters found as the ends of empty element tags.
     
    409409        tag_marks = callouts.EmptyTagMarks | LAngleFollow | AttNameStarts
    410410        NameFollows = ElemNameFollows | AttNameFollows
    411         return (CT_callouts, callouts, refs, error, lex, EOF_mask, name_check, name_start_check, control, tag_marks, NameFollows, CD_starts, GenRef2, DecRef3, HexRef4)
    412 
    413        
     411        AttRef = callouts.AttVals & Ref2
     412        return (CT_callouts, callouts, refs, error, lex, EOF_mask, name_check, name_start_check, control, tag_marks, NameFollows, CD_starts, GenRef2, DecRef3, HexRef4, AttRef)
     413
     414       
  • proto/parabix2/template.c

    r564 r588  
    77#include "../lib/block_carry.h"
    88
     9       
     10#define BUFFER_SIZE 12800   
     11#define BLOCK_SIZE 128
     12#define OVERLAP_BUFSIZE 16
     13
     14typedef long ScanBlock;
    915typedef SIMD_type BytePack;
    1016typedef SIMD_type BitBlock;
     
    1622
    1723#include "../lib/perflib/perfsec.h"
     24
     25#include "tag_matcher.cpp"
    1826
    1927#ifdef BUFFER_PROFILING
     
    3341int block_base=0;
    3442int buffer_base=0;
    35 int tag_depth=0;
    3643int buffer_last;
    3744char * source;
    3845
    39 typedef long ScanBlock;
    4046
    4147static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
     
    156162}
    157163
    158 static inline int Tag_match(int pos) {
    159         int block_pos = block_base + pos;
    160         if(source[block_pos]=='/' ){
    161           tag_depth--;
    162           if (tag_depth<0){
    163             fprintf(stderr, "tag matching error at position %i\n",block_pos+buffer_base);
     164static inline int PIName_check(int pos) {
     165        int block_pos = block_base + pos;         
     166        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
     167              fprintf(stderr, "[Xx][Mm][Ll] illegal as PI name at position %i\n",block_pos+buffer_base);
     168              exit(-1);
     169        }
     170        return 0;
     171}
     172
     173static inline int CD_check(int pos) {
     174        int block_pos = block_base + pos;
     175        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
     176              fprintf(stderr, "CDATA error found at position %i\n",block_pos+buffer_base);
     177              exit(-1);
     178        }
     179        return 0;
     180}
     181
     182static inline int GenRef_check(int pos) {
     183        int block_pos = block_base + pos;
     184        unsigned char* s = (unsigned char*)&source[block_pos];
     185        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))){
     186              fprintf(stderr, "Undefined Reference found at position %i\n",block_pos+buffer_base);
     187              exit(-1);
     188        }
     189        return 0;
     190}
     191
     192static inline int HexRef_check(int pos) {
     193        int block_pos = block_base + pos;
     194        unsigned char* s = (unsigned char*)&source[block_pos];
     195        int ch_val = 0;
     196        while(at_HexDigit<ASCII>(s)){
     197          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
     198          if (ch_val> 0x10FFFF ){
     199            fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
     200            exit(-1);
     201          }
     202          s++;
     203        }
     204        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
     205          fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
     206          exit(-1);
     207        }
     208        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
     209          fprintf(stderr, "Illegal XML 1.0 character reference found at position %i\n",block_pos+buffer_base);
     210          exit(-1);
     211        }
     212        return 0;
     213}
     214
     215static inline int DecRef_check(int pos) {
     216        int block_pos = block_base + pos;
     217        unsigned char* s = (unsigned char*)&source[block_pos];
     218        int ch_val = 0;
     219        while(at_HexDigit<ASCII>(s)){
     220          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
     221          if (ch_val> 0x10FFFF ){
     222            fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
     223            exit(-1);
     224          }
     225          s++;
     226        }
     227        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
     228          fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
     229          exit(-1);
     230        }
     231        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
     232          fprintf(stderr, "Illegal XML 1.0 character reference found at position %i\n",block_pos+buffer_base);
     233          exit(-1);
     234        }
     235        return 0;
     236}
     237
     238static inline int AttRef_check(int pos) {
     239        int block_pos = block_base + pos;
     240        unsigned char* s = (unsigned char*)&source[block_pos];
     241        int ch_val = 0;
     242        if(s[0]=='#'){
     243          s++;
     244          if(s[0]=='x' or s[0]=='X'){
     245            s++;
     246            while(at_HexDigit<ASCII>(s)){
     247              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
     248              s++;
     249            }
     250          }
     251          else{     
     252            while(at_HexDigit<ASCII>(s)){
     253              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
     254              s++;
     255            }
     256          }
     257          if (ch_val==60){
     258            fprintf(stderr, "Attribute values contain '<' characters after reference expansion at position %i\n",block_pos+buffer_base);
    164259            exit(-1);
    165260          }       
    166261        }
    167         else if(source[block_pos]=='>')
    168           tag_depth--;
    169         else
    170           tag_depth++;
    171         return 0;
    172 }
    173 
     262        else if(at_Ref_lt<ASCII>(s)){
     263          fprintf(stderr, "Attribute values contain '<' characters after reference expansion at position %i\n",block_pos+buffer_base);
     264          exit(-1);
     265        }         
     266        return 0;
     267}
    174268
    175269#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
     
    230324} \
    231325
    232        
    233 #define BUFFER_SIZE 12800   
    234 #define BLOCK_SIZE 128
    235326
    236327void do_process(FILE *infile, FILE *outfile) {
     
    244335  int chars_avail = 0;
    245336  int check_pos = 0;
    246   char srcbuf[BUFFER_SIZE+BLOCK_SIZE];
     337  int chars_read = 0;
     338  char buf[BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2];
    247339 
     340  char * srcbuf = buf + OVERLAP_BUFSIZE;
    248341  buffer_base = buf_pos;
    249342  source = srcbuf;
    250343 
    251344  EOF_mask = simd_const_1(1);
    252   chars_avail = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
     345  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
     346  chars_avail = min(chars_read,BUFFER_SIZE);
     347 
     348  tag_matcher t(srcbuf);
    253349
    254350  Entity_Info * e = new Entity_Info;
     
    259355
    260356  if (e->content_start != 0) {
    261         memmove(&srcbuf[0], &srcbuf[e->content_start], chars_avail - e->content_start);
     357        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
    262358        if (chars_avail == BUFFER_SIZE) {
    263                 chars_avail = BUFFER_SIZE - e->content_start +
    264                              fread(&srcbuf[BUFFER_SIZE-e->content_start], 1, e->content_start, infile);
    265         }
    266         else chars_avail -=e->content_start;
     359                chars_read = chars_read - e->content_start +
     360                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
     361                chars_avail = min(chars_read,BUFFER_SIZE);
     362        }
     363        else {
     364          chars_read -=e->content_start;
     365          chars_avail -=e->content_start;
     366        }
    267367  }
    268368 
    269369  @stream_stmts
    270370
    271   while(chars_avail>0){
     371  while(1){
    272372
    273373    PERF_SEC_START(parser_timer);
     
    276376
    277377    if(chars_avail < BUFFER_SIZE){
    278    
     378     
    279379      while (block_pos < chars_avail){
    280380
     
    320420          StreamScan((ScanBlock *) &name_check, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
    321421        }
    322 
    323         if (bitblock_has_bit(tag_marks)) {
    324           StreamScan((ScanBlock *) &tag_marks, sizeof(BitBlock)/sizeof(ScanBlock), Tag_match);
    325         }
     422         
     423        if (bitblock_has_bit(PI_namestarts)){
     424          StreamScan((ScanBlock *) &PI_namestarts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
     425        }
     426       
     427        if (bitblock_has_bit(CD_starts)){
     428          StreamScan((ScanBlock *) &CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
     429        }
     430       
     431        if (bitblock_has_bit(GenRef2)){
     432          StreamScan((ScanBlock *) &GenRef2, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
     433        }
     434       
     435        if (bitblock_has_bit(DecRef3)){
     436          StreamScan((ScanBlock *) &DecRef3, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
     437        }
     438       
     439        if (bitblock_has_bit(HexRef4)){
     440          StreamScan((ScanBlock *) &HexRef4, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
     441        }
     442       
     443        if (bitblock_has_bit(AttRef)){
     444          StreamScan((ScanBlock *) &AttRef, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
     445        }
     446       
     447        t.store_streams(tag_marks, NameFollows);
    326448       
    327449        block_pos += BLOCK_SIZE;
     
    359481        }
    360482       
    361         if (bitblock_has_bit(tag_marks)) {
    362           StreamScan((ScanBlock *) &tag_marks, sizeof(BitBlock)/sizeof(ScanBlock), Tag_match);
    363         }
     483        if (bitblock_has_bit(PI_namestarts)){
     484          StreamScan((ScanBlock *) &PI_namestarts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
     485        }
     486       
     487        if (bitblock_has_bit(CD_starts)){
     488          StreamScan((ScanBlock *) &CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
     489        }
     490       
     491        if (bitblock_has_bit(GenRef2)){
     492          StreamScan((ScanBlock *) &GenRef2, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
     493        }
     494       
     495        if (bitblock_has_bit(DecRef3)){
     496          StreamScan((ScanBlock *) &DecRef3, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
     497        }
     498       
     499        if (bitblock_has_bit(HexRef4)){
     500          StreamScan((ScanBlock *) &HexRef4, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
     501        }
     502       
     503        t.store_streams(tag_marks, NameFollows);
     504
    364505        block_pos += BLOCK_SIZE;
    365506      }
    366507    }
    367508
     509    t.StreamScan(chars_avail);
     510    t.Advance_buffer();
     511
    368512    PERF_SEC_END(parser_timer, chars_avail);
    369513
    370514    buf_pos += chars_avail;
    371515    buffer_base = buf_pos;
    372     chars_avail = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
    373     buffer_last = buffer_base + chars_avail;
     516    if(chars_avail!=chars_read){
     517      int bytes_left = chars_read-chars_avail;
     518      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
     519      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE , infile)+bytes_left;
     520      chars_avail = min(chars_read,BUFFER_SIZE);
     521    }
     522    else
     523      break;   
    374524  }
    375   if(tag_depth!=0){
    376     fprintf(stderr, "tag matching error (depth %i) at position %i\n", tag_depth, buffer_last);
     525  if(t.depth!=0){
     526    fprintf(stderr, "tag matching error (depth %i) at position %i\n", t.depth, buffer_base);
    377527    exit(-1);
    378528  }       
Note: See TracChangeset for help on using the changeset viewer.