Changeset 7 for trunk/src


Ignore:
Timestamp:
Dec 22, 2007, 11:08:10 AM (11 years ago)
Author:
cameron
Message:

Reference extraction; checking ]]> in text; < in atts.

Location:
trunk/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r4 r7  
    2828static inline void ComputeLexicalItemBlocks(BitBlock bit[], BitBlock LexItem[]) {
    2929  BitBlock temp1 = simd_or(bit[0], bit[1]);
    30   BitBlock temp2 = simd_and(bit[2], bit[3]);
     30  BitBlock temp2 = simd_andc(bit[2], bit[3]);
    3131  BitBlock temp3 = simd_andc(temp2, temp1);
    32   BitBlock temp4 = simd_and(bit[4], bit[5]);
    33   BitBlock temp5 = simd_or(bit[6], bit[7]);
    34   BitBlock temp6 = simd_andc(temp4, temp5);
    35   LexItem[LAngle] = simd_and(temp3, temp6);
    36   BitBlock temp7 = simd_andc(bit[6], bit[7]);
    37   BitBlock temp8 = simd_and(temp4, temp7);
    38   LexItem[RAngle] = simd_and(temp3, temp8);
    39   BitBlock temp9 = simd_andc(bit[2], bit[3]);
    40   BitBlock temp10 = simd_andc(temp9, temp1);
    41   BitBlock temp11 = simd_and(bit[6], bit[7]);
    42   BitBlock temp12 = simd_and(temp4, temp11);
    43   BitBlock Slash = simd_and(temp10, temp12);
    44   BitBlock temp13 = simd_andc(bit[1], bit[0]);
    45   BitBlock temp14 = simd_andc(bit[3], bit[2]);
    46   BitBlock temp15 = simd_and(temp13, temp14);
    47   BitBlock temp16 = simd_andc(bit[7], bit[6]);
    48   BitBlock temp17 = simd_and(temp4, temp16);
    49   LexItem[RBracket] = simd_and(temp15, temp17);
    50   LexItem[Hyphen] = simd_and(temp10, temp17);
    51   LexItem[QMark] = simd_and(temp3, temp12);
    52   BitBlock Equals = simd_and(temp3, temp17);
    53   BitBlock temp18 = simd_andc(bit[5], bit[4]);
    54   BitBlock temp19 = simd_and(temp18, temp11);
    55   LexItem[SQuote] = simd_and(temp10, temp19);
    56   BitBlock temp20 = simd_or(bit[4], bit[5]);
    57   BitBlock temp21 = simd_andc(temp7, temp20);
    58   LexItem[DQuote] = simd_and(temp10, temp21);
    59   BitBlock temp22 = simd_or(temp20, temp5);
    60   BitBlock temp23 = simd_andc(temp10, temp22);
    61   BitBlock temp24 = simd_or(bit[2], bit[3]);
    62   BitBlock temp25 = simd_or(temp1, temp24);
    63   BitBlock temp26 = simd_andc(temp17, temp25);
    64   BitBlock temp27 = simd_or(temp23, temp26);
    65   BitBlock temp28 = simd_andc(bit[4], bit[5]);
    66   BitBlock temp29 = simd_and(temp28, temp16);
    67   BitBlock temp30 = simd_andc(temp29, temp25);
     32  BitBlock temp4 = simd_andc(bit[5], bit[4]);
     33  BitBlock temp5 = simd_andc(bit[6], bit[7]);
     34  BitBlock temp6 = simd_and(temp4, temp5);
     35  BitBlock RefStart = simd_and(temp3, temp6);
     36  BitBlock temp7 = simd_and(bit[2], bit[3]);
     37  BitBlock temp8 = simd_andc(temp7, temp1);
     38  BitBlock temp9 = simd_andc(bit[4], bit[5]);
     39  BitBlock temp10 = simd_and(bit[6], bit[7]);
     40  BitBlock temp11 = simd_and(temp9, temp10);
     41  BitBlock Semicolon = simd_and(temp8, temp11);
     42  BitBlock temp12 = simd_and(bit[4], bit[5]);
     43  BitBlock temp13 = simd_or(bit[6], bit[7]);
     44  BitBlock temp14 = simd_andc(temp12, temp13);
     45  BitBlock LAngle = simd_and(temp8, temp14);
     46  BitBlock temp15 = simd_and(temp12, temp5);
     47  LexItem[RAngle] = simd_and(temp8, temp15);
     48  BitBlock temp16 = simd_andc(bit[1], bit[0]);
     49  BitBlock temp17 = simd_andc(bit[3], bit[2]);
     50  BitBlock temp18 = simd_and(temp16, temp17);
     51  BitBlock temp19 = simd_andc(bit[7], bit[6]);
     52  BitBlock temp20 = simd_and(temp12, temp19);
     53  LexItem[RBracket] = simd_and(temp18, temp20);
     54  LexItem[Hyphen] = simd_and(temp3, temp20);
     55  BitBlock temp21 = simd_and(temp12, temp10);
     56  LexItem[QMark] = simd_and(temp8, temp21);
     57  BitBlock Equals = simd_and(temp8, temp20);
     58  BitBlock temp22 = simd_and(temp4, temp10);
     59  LexItem[SQuote] = simd_and(temp3, temp22);
     60  BitBlock temp23 = simd_or(bit[4], bit[5]);
     61  BitBlock temp24 = simd_andc(temp5, temp23);
     62  LexItem[DQuote] = simd_and(temp3, temp24);
     63  BitBlock temp25 = simd_or(temp1, bit[2]);
     64  BitBlock Control = simd_andc(simd_const_1(1), temp25);
     65  BitBlock temp26 = simd_or(temp23, temp13);
     66  BitBlock temp27 = simd_andc(temp3, temp26);
     67  BitBlock temp28 = simd_or(bit[2], bit[3]);
     68  BitBlock temp29 = simd_or(temp1, temp28);
     69  BitBlock temp30 = simd_andc(temp20, temp29);
    6870  BitBlock temp31 = simd_or(temp27, temp30);
    69   BitBlock temp32 = simd_and(temp28, temp7);
    70   BitBlock temp33 = simd_andc(temp32, temp25);
    71   BitBlock WhiteSpace = simd_or(temp31, temp33);
     71  BitBlock temp32 = simd_and(temp9, temp19);
     72  BitBlock temp33 = simd_andc(temp32, temp29);
     73  BitBlock temp34 = simd_or(temp31, temp33);
     74  BitBlock temp35 = simd_and(temp9, temp5);
     75  BitBlock temp36 = simd_andc(temp35, temp29);
     76  BitBlock WhiteSpace = simd_or(temp34, temp36);
     77  BitBlock Slash = simd_and(temp3, temp21);
     78  BitBlock AttScan = simd_or(LAngle, RefStart);
     79  LexItem[SQuote] = simd_or(LexItem[SQuote], AttScan);
     80  LexItem[DQuote] = simd_or(LexItem[DQuote], AttScan);
     81  LexItem[MarkupStart] = simd_or(simd_or(LAngle, RefStart), LexItem[RBracket]);
    7282  LexItem[NonWS] = simd_not(WhiteSpace);
    73   LexItem[NameFollow] = simd_or(simd_or(WhiteSpace,
     83  LexItem[NameFollow] = simd_or(simd_or(simd_or(WhiteSpace, Semicolon),
    7484                                        simd_or(Slash, LexItem[RAngle])),
    7585                                simd_or(Equals, LexItem[QMark]));
     
    94104  start_BOM_interval(lextranspose_timer);
    95105#endif
    96   for (int j = LAngle; j < LexicalItemCount; j++) {
     106  for (int j = MarkupStart; j < LexicalItemCount; j++) {
    97107    for (int i = 0; i < BUFFER_BLOCKS; i++) {
    98108      parsing_engine_data->item_stream[j][i] = lx_blk[i].LexicalItems[j];
  • trunk/src/bitlex.h

    r4 r7  
    3030
    3131enum lexical_item {
    32   LAngle, RAngle, RBracket, Hyphen, QMark, DQuote, SQuote,
     32  MarkupStart, RAngle, RBracket, Hyphen, QMark, DQuote, SQuote,
    3333  NonWS, NameFollow};
    3434
  • trunk/src/charsets/ext_ascii_8.c

    r4 r7  
    1818
    1919int Ext_ASCII_8_Lexer::AdvanceBuffer(int newpos) {
     20  int new_blocks, new_packs;
    2021  unsigned char * buf_ptr = xml_buf->GetBytePtr(newpos * CODE_UNIT_BYTES);
     22  BytePack * src_data = (BytePack *) buf_ptr;
    2123  int avail_bytes = xml_buf->PrepareBytes(BYTE_STREAM_SIZE);
    22   int new_blocks = min(BUFFER_BLOCKS, (avail_bytes + BLOCKSIZE - 1)/BLOCKSIZE);
    23   int new_packs = new_blocks * 8 + 1;
    2424#ifdef BUFFER_PROFILING
    2525  start_BOM_interval(bitstream_timer);
    2626#endif
    27   BytePack * src_data = (BytePack *) buf_ptr;
    28   for (int pk = 0; pk < new_packs; pk++) {
    29     parsing_engine_data->x8data[pk] = sisd_load_unaligned(&src_data[pk]);
     27  if (avail_bytes >= BYTE_STREAM_SIZE) {
     28    new_blocks = BUFFER_BLOCKS;
     29    new_packs = new_blocks * 8 + 1;
     30    for (int pk = 0; pk < new_packs; pk++) {
     31      parsing_engine_data->x8data[pk] = sisd_load_unaligned(&src_data[pk]);
     32    }
     33  }
     34  else {
     35    new_blocks = min(BUFFER_BLOCKS, (avail_bytes + BLOCKSIZE - 1)/BLOCKSIZE);
     36    new_packs = new_blocks * 8 + 1;
     37    for (int pk = 0; pk < new_packs; pk++) {
     38      parsing_engine_data->x8data[pk] = sisd_load_unaligned(&src_data[pk]);
     39    }
     40    ((unsigned char *) parsing_engine_data->x8data)[avail_bytes] = ']';
    3041  }
    3142  ComputeLexicalItemStreams(new_blocks);
  • trunk/src/engine.c

    r6 r7  
    4141  BitBlock sentinel_value = bitblock_sfli(simd_const_1(1), 8*sizeof(unsigned long));
    4242#endif
    43   for (int j = LAngle; j < LexicalItemCount; j++) {
     43  for (int j = MarkupStart; j < LexicalItemCount; j++) {
    4444    buf.item_stream[j][BUFFER_BLOCKS] = sentinel_value;
    4545  }
     
    221221   character. */
    222222inline bool ParsingEngine::at_ElementTag_Start() const {
    223   assert(*(x8dataPtr(0)) == '<');
    224   return (*(x8dataPtr(1)) & 0xE1) != 0x21;
    225 }
    226 
    227 
    228 
    229 
    230 inline void ParsingEngine::Parse_Text () {
    231         int text_start;
    232         int text_lgth;
    233         if (!AtChar('<')) {
    234                 text_start = AbsPos();
    235 /*
    236                 ScanTo(NonWS);
    237                 non_WS_start = AbsPos(); */
    238                 ScanTo(LAngle);
    239                 /*if (text_lgth > 0) {*/
    240                 Text_action(text_start, AbsPos());
    241         }
     223 
     224  return (*(x8dataPtr(0)) == '<') &
     225         ((*(x8dataPtr(1)) & 0xE1) != 0x21);
    242226}
    243227
     
    314298}
    315299
     300inline void ParsingEngine::Parse_Reference () {
     301        int markup_start = AbsPos();
     302        /* Advance(1);  // skip "&" */
     303        ScanTo(NameFollow);  /* Name delimiter */
     304        if (!AtChar(';')) {
     305                Error_action(markup_start, AbsPos());
     306        }
     307        else {
     308                Advance(1);
     309                Reference_action(markup_start, AbsPos());
     310        }
     311}
     312
    316313inline void ParsingEngine::Parse_PI () {
    317314        int markup_start = AbsPos();
     
    335332        int att_val_start;
    336333        int att_name_end, att_val_end;
     334        lexical_item Quote_stream;
    337335        ScanTo(NameFollow);  /* Name delimiter: WS, "/" or ">" */
    338336        ElementName_action(markup_start+1, AbsPos());
     
    365363                                Advance(2);
    366364                                att_val_start = AbsPos();
    367                                 ScanTo(DQuote);
     365                                Quote_stream = DQuote;
    368366                        }
    369367                        else if (at_EqualsSQuote()) {
    370368                                Advance(2);
    371369                                att_val_start = AbsPos();
    372                                 ScanTo(SQuote);
     370                                Quote_stream = SQuote;
    373371                        }
    374372                        else {
     
    382380                                if (AtChar('"')) {
    383381                                        Advance(1);
    384                                         ScanTo(DQuote);
     382                                        Quote_stream = DQuote;
    385383                                }
    386384                                else if (AtChar('\'')) {
    387385                                        Advance(1);
    388                                         ScanTo(SQuote);
     386                                        Quote_stream = SQuote;
    389387                                }
    390388                                else {
     
    393391                                }
    394392                        }
    395                         /* ScanTo(DQuote) or ScanTo(SQuote) complete. */
     393                        ScanTo(Quote_stream);
     394                        while (AtChar('&')) {
     395                                Parse_Reference();
     396                                ScanTo(Quote_stream);
     397                        }
     398                        if (AtChar('<')) {
     399                                Error_action(markup_start, AbsPos());
     400                                break;
     401                        }
    396402                        att_val_end = AbsPos();
    397403                        Advance(1);
     
    438444inline void ParsingEngine::ParseContent () {
    439445
    440        
    441         while (!at_EOF()) {
    442                 Parse_Text();
    443                 if (!at_EOF()) {
     446        int text_start = AbsPos();
     447        do {
     448                ScanTo(MarkupStart); /* '<', '&', or ']' for ']]>' test */
     449/*              if (AtChar('<')) {
     450                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    444451                        Parse_Markup();
    445                 }
    446         }
    447         if (BufferRelPos() > rel_EOF_pos) {
    448                 printf("Incomplete markup item at end of file.\n");
    449         }
     452                }*/
     453                int markup_start = AbsPos();
     454                if (at_ElementTag_Start()) {
     455                        Parse_StartTag();
     456                }
     457                else if (at_EndTag_Start()) {
     458                        Parse_EndTag();
     459                }
     460                else if (at_Comment_Start()) {
     461                        Parse_Comment();
     462                }
     463                else if (AtChar('&')) {
     464                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
     465                        Parse_Reference();
     466                }
     467                else if (at_CDATA_Start()) {
     468                        Parse_CDATA();
     469                }
     470                else if (at_PI_Start()) {
     471                        Parse_PI();
     472                }
     473                else if (at_CDATA_End()) {
     474                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
     475                        Advance(3);
     476                        Error_action(AbsPos()-3, AbsPos());
     477                }
     478                else if (at_EOF()) {
     479                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
     480                        break;
     481                }
     482                else {
     483                        Advance(1);
     484                        continue;
     485                }
     486                text_start = AbsPos();
     487        } while (1);
    450488#ifdef BUFFER_PROFILING
    451489        printf("Bit stream computation.\n");
  • trunk/src/engine.h

    r4 r7  
    5454                  /* Parsing routines. */
    5555
    56                   void Parse_Text ();
    5756                  void Parse_Markup ();
    5857                  void Parse_Comment ();
     
    6160                  void Parse_CDATA ();
    6261                  void Parse_PI ();
     62                  void Parse_Reference ();
    6363
    6464                  /* Co-classes */
  • trunk/src/ilax.h

    r4 r7  
    4242static inline void Text_action(int start_pos, int end_pos);
    4343
     44/* Action routine for a character or entity reference.*/
     45static inline void Reference_action(int start_pos, int end_pos);
     46
    4447/* Action routine for an element name occurring immediately after the
    4548   opening "<" of a start tag or empty element tag. */
Note: See TracChangeset for help on using the changeset viewer.