Changeset 92 for trunk


Ignore:
Timestamp:
Apr 8, 2008, 9:53:53 AM (11 years ago)
Author:
cameron
Message:

Passing buffer pointers/lgths to markup actions.

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/markup_stats.cxx

    r91 r92  
    8686int last_buffer_rel_pos = 0;
    8787
    88 void LastItemAction(int start_pos, int end_pos, int buffer_rel_pos) {
    89 #ifdef DEBUG
    90         if (start_pos < last_item_stop) {
    91                 printf("Anomaly start_pos %i < last_item_stop_pos %i \n", start_pos, last_item_stop);
    92                 printf("rel_positions: last = %i, this = %i\n", last_buffer_rel_pos, buffer_rel_pos);
    93         }
    94 #endif
    95         last_item_start = start_pos;
    96         last_item_stop = end_pos;
    97         last_buffer_rel_pos = buffer_rel_pos;
    98 }
    9988
    10089/* Action routine for an XML comment in "<!--"  "-->" brackets. */
    10190template <CodeUnit_Base C>
    102 inline void ParsingEngine<C>::Comment_action(int start_pos, int end_pos) {
     91inline void ParsingEngine<C>::Comment_action(unsigned char * item, int lgth) {
    10392        comment_count +=1;
    104         comment_length += end_pos - start_pos;
    105         LastItemAction(start_pos, end_pos, buffer_rel_pos);
     93        comment_length += lgth;
    10694}
    10795
    10896/* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
    10997template <CodeUnit_Base C>
    110 inline void ParsingEngine<C>::CDATA_start_action(int pos) {
    111         CDATA_start_pos = pos - 9;
     98inline void ParsingEngine<C>::CDATA_start_action(unsigned char * CDATA_ptr){
     99        CDATA_start_pos = AbsPos() - 9;
    112100        CDATA_start_count +=1;
    113         LastItemAction(pos-9, pos, buffer_rel_pos);
    114101}
    115102
    116103/* Action routine called upon recognizing "]]>" to end a CDATA section. */
    117104template <CodeUnit_Base C>
    118 inline void ParsingEngine<C>::CDATA_end_action(int pos) {
     105inline void ParsingEngine<C>::CDATA_end_action(unsigned char * CDATA_end_ptr) {
    119106        CDATA_end_count +=1;
    120         CDATA_length += pos - CDATA_start_pos;
    121         LastItemAction(pos-3, pos, buffer_rel_pos);
     107        CDATA_length += AbsPos() - CDATA_start_pos;
    122108}
    123109
    124110/* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
    125111template <CodeUnit_Base C>
    126 inline void ParsingEngine<C>::PI_action(int start_pos, int end_pos) {
     112inline void ParsingEngine<C>::PI_action(unsigned char * item, int lgth) {
    127113        PI_count +=1;
    128         PI_length += end_pos - start_pos;
    129         LastItemAction(start_pos, end_pos, buffer_rel_pos);
     114        PI_length += lgth;
    130115}
    131116
    132117/* Action routine for an empty element enclosed in "<" and "/>" brackets. */
    133118template <CodeUnit_Base C>
    134 inline void ParsingEngine<C>::EmptyElement_action(int start_pos, int end_pos) {
     119inline void ParsingEngine<C>::EmptyElement_action(unsigned char * item, int lgth) {
    135120        empty_elem_count +=1;
    136         empty_elem_length += end_pos - start_pos;
    137         LastItemAction(start_pos, end_pos, buffer_rel_pos);
     121        empty_elem_length += lgth;
    138122}
    139123
    140124/* Action routine for a start tag enclosed in "<" and ">" brackets. */
    141125template <CodeUnit_Base C>
    142 inline void ParsingEngine<C>::StartTag_action(int start_pos, int end_pos) {
     126inline void ParsingEngine<C>::StartTag_action(unsigned char * item, int lgth) {
    143127        start_tag_count +=1;
    144         start_tag_length += end_pos - start_pos;
     128        start_tag_length += lgth;
    145129        nesting_depth += 1;
    146130        if (nesting_depth > max_nesting_depth) max_nesting_depth = nesting_depth;
    147         LastItemAction(start_pos, end_pos, buffer_rel_pos);
    148131}
    149132
    150133/* Action routine for an end tag enclosed in "</" and ">" brackets. */
    151134template <CodeUnit_Base C>
    152 inline void ParsingEngine<C>::EndTag_action(int start_pos, int end_pos) {
     135inline void ParsingEngine<C>::EndTag_action(unsigned char * item, int lgth) {
    153136        end_tag_count +=1;
    154         end_tag_length += end_pos - start_pos;
     137        end_tag_length += lgth;
    155138        nesting_depth -= 1;
    156         LastItemAction(start_pos, end_pos, buffer_rel_pos);
    157139}
    158140
    159141/* Action routine for an error item */
    160142template <CodeUnit_Base C>
    161 inline void ParsingEngine<C>::Error_action(int start_pos, int end_pos) {
     143inline void ParsingEngine<C>::Error_action(unsigned char * item, int lgth) {
    162144        error_item_count +=1;
    163         error_item_length += end_pos - start_pos;
    164         printf("Error: illegal markup at positions %i through %i.\n", start_pos, end_pos);
    165         printf("length = %i; buffer_rel_pos = %i\n", end_pos - start_pos, buffer_rel_pos);
    166         printf("last_item from %i to %i (rel_pos = %i)\n",
    167                last_item_start, last_item_stop, last_buffer_rel_pos);
    168 
    169         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos+1 - start_pos) << endl;
    170 
    171 
    172 
     145        error_item_length += lgth;
     146        printf("Error: illegal markup at positions %i of length %i.\n", AbsPos()-lgth, lgth);
     147        cout << string((char *) item, lgth) << endl;
    173148}
    174149
    175150/* Action routine for a text item */
    176151template <CodeUnit_Base C>
    177 inline void ParsingEngine<C>::Text_action(int start_pos, int end_pos) {
     152inline void ParsingEngine<C>::Text_action(unsigned char * item, int lgth) {
    178153        text_item_count +=1;
    179         text_item_length += end_pos - start_pos;
    180         LastItemAction(start_pos, end_pos, buffer_rel_pos);
    181 }
    182 
    183 template <CodeUnit_Base C>
    184 inline void ParsingEngine<C>::Reference_action(int start_pos, int end_pos) {
     154        text_item_length += lgth;
     155}
     156
     157template <CodeUnit_Base C>
     158inline void ParsingEngine<C>::Reference_action(unsigned char * item, int lgth) {
    185159        reference_count +=1;
    186         reference_length += end_pos - start_pos;
    187         LastItemAction(start_pos, end_pos, buffer_rel_pos);
     160        reference_length += lgth;
    188161}
    189162
     
    212185   opening "<" of a start tag or empty element tag. */
    213186template <CodeUnit_Base C>
    214 inline void ParsingEngine<C>::ElementName_action(int start_pos, int end_pos) {
     187inline void ParsingEngine<C>::ElementName_action(unsigned char * item, int lgth) {
    215188}
    216189
     
    218191   after the opening "<?" of a processing instruction. */
    219192template <CodeUnit_Base C>
    220 inline void ParsingEngine<C>::PI_Target_action(int start_pos, int end_pos) {
     193inline void ParsingEngine<C>::PI_Target_action(unsigned char * item, int lgth) {
    221194}
    222195
     
    224197   a element start tag or an empty element tag. */
    225198template <CodeUnit_Base C>
    226 inline void ParsingEngine<C>::AttributeValue_action(int name_start, int name_end,
    227                                   int val_start, int val_end) {
     199inline void ParsingEngine<C>::AttributeValue_action(unsigned char * name, int name_lgth,
     200                                 unsigned char * val, int val_lgth) {
    228201        total_attribute_count+=1;
    229         total_att_name_length += name_end - name_start;
    230         total_att_value_length += val_end - val_start;
     202        total_att_name_length += name_lgth;
     203        total_att_value_length += val_lgth;
    231204}
    232205
     
    234207   a element start tag or an empty element tag. */
    235208template <CodeUnit_Base C>
    236 inline void ParsingEngine<C>::Namespace_action(int name_start, int name_end,
    237                              int URI_start, int URI_end) {
     209inline void ParsingEngine<C>::Namespace_action(unsigned char * name, int name_lgth,
     210                             unsigned char * URI, int URI_lgth) {
    238211        namespace_count+=1;
    239         total_namespace_name_length += name_end - name_start;
    240         total_namespace_URI_length += URI_end - URI_start;
     212        total_namespace_name_length += name_lgth;
     213        total_namespace_URI_length += URI_lgth;
    241214}
    242215
     
    270243#endif
    271244}
     245
     246template <CodeUnit_Base C>
     247inline void ParsingEngine<C>::Doctype_action(unsigned char * item, int lgth) {
     248#ifdef SHOW_DTD_ACTIONS
     249        printf("Document Type:\n");
     250        cout << string((char *) item, lgth) <<endl;
     251#endif
     252}
     253
     254template <CodeUnit_Base C>
     255inline void ParsingEngine<C>::PEReference_action(unsigned char * item, int lgth) {
     256}
     257
     258template <CodeUnit_Base C>
     259inline void ParsingEngine<C>::Elementdecl_action(unsigned char * item, int lgth) {
     260#ifdef SHOW_DTD_ACTIONS
     261        printf("Elementdecl:\n");
     262        cout << string((char *) item, lgth) <<endl;
     263#endif
     264}
     265
     266template <CodeUnit_Base C>
     267inline void ParsingEngine<C>::AttlistDecl_action(unsigned char * item, int lgth) {
     268#ifdef SHOW_DTD_ACTIONS
     269        printf("AttlistDecl:\n");
     270        cout << string((char *) item, lgth) <<endl;
     271#endif
     272}
     273
     274template <CodeUnit_Base C>
     275inline void ParsingEngine<C>::Entitydecl_action(unsigned char * entity_name, int entity_name_lgth, unsigned char * item, int lgth) {
     276#ifdef SHOW_DTD_ACTIONS
     277        printf("Entitydecl:\n");
     278        cout << string((char *) item, lgth) <<endl;
     279#endif
     280}
     281
     282template <CodeUnit_Base C>
     283inline void ParsingEngine<C>::Notationdecl_action(unsigned char * item, int lgth) {
     284#ifdef SHOW_DTD_ACTIONS
     285        printf("Notationdecl:\n");
     286        cout << string((char *) item, lgth) <<endl;
     287#endif
     288}
     289
     290template <CodeUnit_Base C>
     291inline void ParsingEngine<C>::Prolog_action(unsigned char * item, int lgth) {
     292#ifdef SHOW_DTD_ACTIONS
     293        printf("Prolog:\n");
     294        cout << string((char *) item, lgth) <<endl;
     295#endif
     296}
     297
    272298
    273299#define print_stats(stat_string, count, total_lgth) \
     
    276302        else if (count == 1) printf(" of length %i.\n", total_lgth);\
    277303        else printf("s of avg. lgth %i.\n", total_lgth/count);
    278 
    279 
    280 template <CodeUnit_Base C>
    281 inline void ParsingEngine<C>::Doctype_action(int start_pos, int end_pos) {
    282 #ifdef SHOW_DTD_ACTIONS
    283         printf("Document Type:\n");
    284         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos-start_pos) <<endl;
    285 #endif
    286 }
    287 
    288 template <CodeUnit_Base C>
    289 inline void ParsingEngine<C>::PEReference_action(int start_pos, int end_pos) {
    290 }
    291 
    292 template <CodeUnit_Base C>
    293 inline void ParsingEngine<C>::Elementdecl_action(int start_pos, int end_pos) {
    294 #ifdef SHOW_DTD_ACTIONS
    295         printf("Elementdecl:\n");
    296         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos-start_pos) <<endl;
    297 #endif
    298 }
    299 
    300 template <CodeUnit_Base C>
    301 inline void ParsingEngine<C>::AttlistDecl_action(int start_pos, int end_pos) {
    302 #ifdef SHOW_DTD_ACTIONS
    303         printf("AttlistDecl:\n");
    304         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos-start_pos) <<endl;
    305 #endif
    306 }
    307 
    308 template <CodeUnit_Base C>
    309 inline void ParsingEngine<C>::Entitydecl_action(int entity_name_start, int entity_name_end, int start_pos, int end_pos) {
    310 #ifdef SHOW_DTD_ACTIONS
    311         printf("Entitydecl:\n");
    312         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos-start_pos) <<endl;
    313 #endif
    314 }
    315 
    316 template <CodeUnit_Base C>
    317 inline void ParsingEngine<C>::Notationdecl_action(int start_pos, int end_pos) {
    318 #ifdef SHOW_DTD_ACTIONS
    319         printf("Notationdecl:\n");
    320         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos-start_pos) <<endl;
    321 #endif
    322 }
    323 
    324 template <CodeUnit_Base C>
    325 inline void ParsingEngine<C>::Prolog_action(int start_pos, int end_pos) {
    326 #ifdef SHOW_DTD_ACTIONS
    327         printf("Prolog:\n");
    328         cout << string((char *) GetCodeUnitPtr(start_pos), end_pos-start_pos) <<endl;
    329 #endif
    330 }
    331304
    332305int
  • trunk/src/engine.c

    r91 r92  
    149149}
    150150
     151template <CodeUnit_Base C>
     152inline int ParsingEngine<C>::LengthFrom(int start_pos) const {
     153  return buffer_base_pos + buffer_rel_pos - start_pos;
     154}
     155
     156
    151157
    152158template <CodeUnit_Base C>
     
    195201        buffer_rel_pos = bitstream_scan(buf->item_stream[MarkupStart], buffer_rel_pos);
    196202        while (buffer_rel_pos >= BUFFER_SIZE) {
    197                 Text_action(text_or_markup_start, AbsPos());
     203                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    198204                text_or_markup_start = AbsPos();
    199205                FinalizeBuffer_action(preserve_pos);
     
    208214        buffer_rel_pos = bitstream_scan(buf->item_stream[CD_End_check], buffer_rel_pos);
    209215        while (buffer_rel_pos >= BUFFER_SIZE) {
    210                 Text_action(text_or_markup_start, AbsPos());
     216                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    211217                text_or_markup_start = AbsPos();
    212218                FinalizeBuffer_action(preserve_pos);
     
    260266        else {
    261267                Advance(1);
    262                 Error_action(text_or_markup_start, AbsPos());
     268                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    263269        }
    264270}
     
    276282        if (at_Comment_End<C>(cur())) {
    277283                Advance(3); /* Skip "-->". */
    278                 Comment_action(text_or_markup_start, AbsPos());
     284                Comment_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    279285        }
    280286        else {
    281287                Advance(2);  /* "--" */
    282                 Error_action(text_or_markup_start, AbsPos());
     288                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    283289        }
    284290}
     
    291297        if (AtChar<C,'>'>(cur())) {
    292298                Advance(1);
    293                 EndTag_action(text_or_markup_start, AbsPos());
     299                EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    294300        }
    295301        else {
     
    297303                if (AtChar<C,'>'>(cur())) {
    298304                        Advance(1);
    299                         EndTag_action(text_or_markup_start, AbsPos());
    300                 }
    301                 else Error_action(text_or_markup_start, AbsPos());
     305                        EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     306                }
     307                else Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    302308        }
    303309}
     
    308314        Advance(8); /* Skip "<![CDATA". */
    309315        if (!AtChar<C,'['>(cur())) {
    310                 Error_action(text_or_markup_start, AbsPos());
     316                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    311317        }
    312318        else { 
    313319                Advance(1);
     320                CDATA_start_action(GetCodeUnitPtr(text_or_markup_start));
    314321                text_or_markup_start = AbsPos();
    315                 CDATA_start_action(text_or_markup_start);
    316322                ScanTo(CD_End_check);
    317323                while (!at_CDATA_End<C>(cur())) {
     
    319325                        ScanTo(CD_End_check);
    320326                }
    321                 Text_action(text_or_markup_start, AbsPos());
     327                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    322328                Advance(3); /* Skip "]]>". */
    323                 CDATA_end_action(AbsPos());
     329                CDATA_end_action(GetCodeUnitPtr(AbsPos()));
    324330        }
    325331}
     
    330336        ScanTo(NameFollow);  /* Name delimiter */
    331337        if (!AtChar<C,';'>(cur())) {
    332                 Error_action(text_or_markup_start, AbsPos());
     338                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    333339        }
    334340        else {
    335341                Advance(1);
    336                 Reference_action(text_or_markup_start, AbsPos());
     342                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    337343        }
    338344}
     
    345351        if (at_XxMmLll_WS<C>(cur())) {
    346352                Advance(4);
    347                 Error_action(text_or_markup_start, AbsPos());
     353                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    348354                return;
    349355        }
    350356        ScanTo(NameFollow);  /* Name delimiter */
    351         PI_Target_action(target_start, AbsPos());
     357        PI_Target_action(GetCodeUnitPtr(target_start), LengthFrom(target_start));
    352358        ScanTo(QMark);
    353359        while (!at_PI_End<C>(cur())) {
     
    356362        }
    357363        Advance(2); /* Skip "?>". */
    358         PI_action(text_or_markup_start, AbsPos());
     364        PI_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    359365}
    360366 
     
    368374        Advance(1);
    369375        ScanTo(NameFollow);  /* Name delimiter: WS, "/" or ">" */
    370         ElementName_action(text_or_markup_start+1, AbsPos());
     376        ElementName_action(GetCodeUnitPtr(text_or_markup_start+1), LengthFrom(text_or_markup_start+1));
    371377        /* The following test optimizes the most common case of a
    372378        start tag with no attributes.  */
    373379        if (AtChar<C,'>'>(cur())) {
    374380                Advance(1);
    375                 StartTag_action(text_or_markup_start, AbsPos());
     381                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    376382        }
    377383        else {
     
    379385                if (AtChar<C,'>'>(cur())) {
    380386                        Advance(1);
    381                         StartTag_action(text_or_markup_start, AbsPos());
     387                        StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    382388                }
    383389                else if (at_EmptyElementDelim<C>(cur())) {
    384390                        Advance(2);
    385                         EmptyElement_action(text_or_markup_start, AbsPos());
     391                        EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    386392                }
    387393                else do {
     
    396402                        else {
    397403                                if (LastAttOccurrence[attID] > text_or_markup_start) {
    398                                         Error_action(text_or_markup_start, AbsPos()); /* Duplicate attribute. */
     404                                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start)); /* Duplicate attribute. */
    399405                                        break;
    400406                                }                       
     
    412418                                ScanTo(NonWS);
    413419                                if (!AtChar<C,'='>(cur())) {
    414                                         Error_action(text_or_markup_start, AbsPos());
     420                                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    415421                                        break;
    416422                                }
     
    418424                                quoteCh = cur()[0];
    419425                                if (!AtQuote<C>(cur())) {
    420                                         Error_action(text_or_markup_start, AbsPos());
     426                                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    421427                                        break;
    422428                                }
     
    434440                                }
    435441                                else /* if (AtChar<C,'<'>(cur())) */{
    436                                         Error_action(text_or_markup_start, AbsPos());
     442                                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    437443                                        break;
    438444                                }
     
    441447                        Advance(1);
    442448                        if (at_xmlns<C>(cur()+att_name_start-AbsPos())) {
    443                                 Namespace_action(att_name_start, att_name_end,
    444                                                  att_val_start, att_val_end);
     449                                Namespace_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
     450                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
    445451                        }
    446452                        else {
    447                                 AttributeValue_action(att_name_start, att_name_end,
    448                                                       att_val_start, att_val_end);
     453                                AttributeValue_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
     454                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
    449455                        }
    450456                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
    451457                        if (AtChar<C,'>'>(cur())) {
    452458                                Advance(1);
    453                                 StartTag_action(text_or_markup_start, AbsPos());
     459                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    454460                                break;
    455461                        }
    456462                        else if (at_EmptyElementDelim<C>(cur())) {
    457463                                Advance(2);
    458                                 EmptyElement_action(text_or_markup_start, AbsPos());
     464                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    459465                                break;
    460466                        }
     
    462468                        if (AtChar<C,'>'>(cur())) {
    463469                                Advance(1);
    464                                 StartTag_action(text_or_markup_start, AbsPos());
     470                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    465471                                break;
    466472                        }
    467473                        else if (at_EmptyElementDelim<C>(cur())) {
    468474                                Advance(2);
    469                                 EmptyElement_action(text_or_markup_start, AbsPos());
     475                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    470476                                break;
    471477                        }
    472478                        else if (AbsPos() == att_val_end + 1) {
    473479                                /* No WS following att value */
    474                                 Error_action(text_or_markup_start, AbsPos());
     480                                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    475481                                break;
    476482                        }
     
    482488inline void ParsingEngine<C>::text_if_nonnull_action(){
    483489        if (AbsPos() > text_or_markup_start) {
    484                 Text_action(text_or_markup_start, AbsPos());
     490                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    485491                text_or_markup_start = AbsPos();
    486492        }
     
    524530                        text_if_nonnull_action();
    525531                        Advance(3);
    526                         Error_action(AbsPos()-3, AbsPos());
     532                        Error_action(GetCodeUnitPtr(AbsPos()-3), 3);
    527533                }
    528534                else if (at_EOF()) {
     
    560566    if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
    561567        if(old_abspos == AbsPos())
    562                 Error_action(start_pos, AbsPos());
     568                Error_action(GetCodeUnitPtr(start_pos), LengthFrom(start_pos));
    563569        Parse_ExternalID();
    564570    }
     
    572578                        Advance(1);
    573579                else
    574                         Error_action(start_pos, AbsPos());
     580                        Error_action(GetCodeUnitPtr(start_pos), LengthFrom(start_pos));
    575581                ScanTo(NonWS);
    576582        }
     
    578584        if (AtChar<C,'>'>(cur())){
    579585                Advance(1);   
    580                 Doctype_action(start_pos, AbsPos());
     586                Doctype_action(GetCodeUnitPtr(start_pos), LengthFrom(start_pos));
    581587        }
    582588}
     
    598604        }
    599605        else
    600                 Error_action(text_or_markup_start, AbsPos());
     606                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    601607}
    602608
     
    645651                        }
    646652                        else
    647                                 Error_action(text_or_markup_start, AbsPos());
     653                                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    648654                }
    649655                else if (AtChar<C,']'>(cur())){
     
    651657                }
    652658                else
    653                         Error_action(text_or_markup_start, AbsPos());
     659                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    654660        }
    655661}
     
    663669        if (AtChar<C,';'>(cur())) {
    664670                Advance(1);
    665                 PEReference_action(text_or_markup_start, AbsPos());
     671                PEReference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    666672        }
    667673        else
    668                 Error_action(text_or_markup_start, AbsPos());
     674                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    669675}
    670676
     
    699705        if (AtChar<C,'>'>(cur())) {
    700706                Advance(1);
    701                 Elementdecl_action(text_or_markup_start, AbsPos());
     707                Elementdecl_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    702708        }
    703709        else
    704                 Error_action(text_or_markup_start, AbsPos());
     710                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    705711}
    706712template <CodeUnit_Base C>
     
    766772        }
    767773        else
    768                 Error_action(text_or_markup_start, AbsPos());
     774                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    769775               
    770776        if (AtChar<C,'?'>(cur())||AtChar<C,'*'>(cur())||AtChar<C,'+'>(cur()))
     
    809815        while(!AtChar<C,'>'>(cur())) {
    810816                if(old_abspos == AbsPos())
    811                 Error_action(text_or_markup_start, AbsPos());
     817                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    812818               
    813819        name_start = AbsPos();
     
    864870        }
    865871        else
    866                 Error_action(text_or_markup_start, AbsPos());
     872                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    867873        requireWS();
    868874        Parse_DefaultDecl(this_info);
     
    873879
    874880        Advance(1);
    875         AttlistDecl_action(text_or_markup_start, AbsPos());
     881        AttlistDecl_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    876882}
    877883
     
    882888                Advance(1);
    883889        else
    884                 Error_action(text_or_markup_start, AbsPos());
     890                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    885891        ScanTo(NonWS);
    886892        ScanTo(NameFollow);
     
    894900                Advance(1);
    895901        else
    896                 Error_action(text_or_markup_start, AbsPos());
     902                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    897903}
    898904
     
    925931                        }
    926932                else
    927                         Error_action(text_or_markup_start, AbsPos());
     933                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    928934        }
    929935}
     
    952958        }
    953959        else
    954                 Error_action(text_or_markup_start, AbsPos());
     960                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    955961        }
    956962        else{
     
    965971                if(at_NOTATION<C>(cur())){
    966972                        if(old_abspos == AbsPos())
    967                                 Error_action(text_or_markup_start, AbsPos());
     973                                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    968974                        else
    969975                                Advance(5);
     
    976982        }
    977983        else
    978                 Error_action(text_or_markup_start, AbsPos());
     984                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    979985        }
    980986        ScanTo(NonWS);
    981987        if (AtChar<C,'>'>(cur())){
    982988                Advance(1);
    983                 Entitydecl_action(entity_name_start, entity_name_end, text_or_markup_start, AbsPos());
     989                Entitydecl_action(GetCodeUnitPtr(entity_name_start), entity_name_end - entity_name_start,
     990                                  GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    984991        }
    985992        else
    986                 Error_action(text_or_markup_start, AbsPos());
     993                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    987994}
    988995
     
    10071014                if (!AtChar<C,'>'>(cur())){
    10081015                        if (old_abspos == AbsPos())
    1009                                 Error_action(text_or_markup_start, AbsPos());
     1016                                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10101017                        Parse_MatchedQuote (); /*  SystemLiteral */
    10111018                }
    10121019        }
    10131020        else
    1014                 Error_action(text_or_markup_start, AbsPos());
     1021                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10151022        ScanTo(NonWS);
    10161023        if (AtChar<C,'>'>(cur())) {
    10171024                Advance(1);
    1018                 Notationdecl_action(text_or_markup_start, AbsPos());
     1025                Notationdecl_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10191026        }
    10201027        else
    1021                 Error_action(text_or_markup_start, AbsPos());
     1028                Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10221029}
    10231030
     
    10281035    ScanTo(NonWS);
    10291036    if(old_abspos == AbsPos())
    1030         Error_action(text_or_markup_start, AbsPos());
     1037        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10311038}
    10321039
     
    10481055                }
    10491056                else /* if (AtChar<C,'<'>(cur())) */
    1050                         Error_action(text_or_markup_start, AbsPos());
     1057                        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10511058        }
    10521059        Advance(1);
     
    10631070                                Parse_PI();
    10641071                else{
    1065                         Prolog_action(old_pos, AbsPos());
     1072                        Prolog_action(GetCodeUnitPtr(old_pos), LengthFrom(old_pos));
    10661073                        return;
    10671074                }
     
    10771084                ScanTo(NonWS);
    10781085        }
    1079         Prolog_action(old_pos, AbsPos());
    1080 }
    1081 
    1082 
    1083 
     1086        Prolog_action(GetCodeUnitPtr(old_pos), LengthFrom(old_pos));
     1087}
     1088
     1089
     1090
  • trunk/src/engine.h

    r91 r92  
    6060        /* Getters for current point/position information. */
    6161        int AbsPos() const;
     62        int LengthFrom(int start_pos) const;
    6263        int BufferRelPos() const;
    6364        unsigned char * cur() const;
     
    110111       
    111112        /* Action routine for an XML comment in "<!--"  "-->" brackets. */
    112         void Comment_action(int start_pos, int end_pos);
     113        void Comment_action(unsigned char * item, int lgth);
    113114       
    114115        /* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
    115         void CDATA_start_action(int pos);
     116        void CDATA_start_action(unsigned char * CDATA_ptr);
    116117
    117118        /* Action routine called upon recognizing "]]>" to end a CDATA section. */
    118         void CDATA_end_action(int pos);
     119        void CDATA_end_action(unsigned char * CDATA_end_ptr);
    119120       
    120121        /* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
    121         void PI_action(int start_pos, int end_pos);
     122        void PI_action(unsigned char * item, int lgth);
    122123       
    123124        /* Action routine for an empty element enclosed in "<" and "/>" brackets. */
    124         void EmptyElement_action(int start_pos, int end_pos);
     125        void EmptyElement_action(unsigned char * item, int lgth);
    125126       
    126127        /* Action routine for a start tag enclosed in "<" and ">" brackets. */
    127         void StartTag_action(int start_pos, int end_pos);
     128        void StartTag_action(unsigned char * item, int lgth);
    128129       
    129130        /* Action routine for an end tag enclosed in "</" and ">" brackets. */
    130         void EndTag_action(int start_pos, int end_pos);
     131        void EndTag_action(unsigned char * item, int lgth);
    131132       
    132133        /* Action routine for an error item */
    133         void Error_action(int start_pos, int end_pos);
     134        void Error_action(unsigned char * item, int lgth);
    134135       
    135136        /* Action routine for a text item */
    136         void Text_action(int start_pos, int end_pos);
     137        void Text_action(unsigned char * item, int lgth);
    137138       
    138139        /* Action routine for a character or entity reference.*/
    139         void Reference_action(int start_pos, int end_pos);
     140        void Reference_action(unsigned char * item, int lgth);
    140141       
    141142        /* Action routine for an element name occurring immediately after the
    142143        opening "<" of a start tag or empty element tag. */
    143         void ElementName_action(int start_pos, int end_pos);
     144        void ElementName_action(unsigned char * item, int lgth);
    144145       
    145146        /* Action routine for a processing instruction target name occurring immediately
    146147        after the opening "<?" of a processing instruction. */
    147         void PI_Target_action(int start_pos, int end_pos);
     148        void PI_Target_action(unsigned char * item, int lgth);
    148149       
    149150        /* Action routine for an individual attribute/value pair occurring in
    150151        a element start tag or an empty element tag. */
    151         void AttributeValue_action(int name_start, int name_end,
    152                                         int val_start, int val_end);
     152        void AttributeValue_action(unsigned char * name, int name_lgth,
     153                                   unsigned char * val, int val_lgth);
    153154       
    154155        /* Action routine for an individual namespace binding occurring in
    155156        a element start tag or an empty element tag. */
    156         void Namespace_action(int name_start, int name_end,
    157                                 int URI_start, int URI_end);
     157        void Namespace_action(unsigned char * name, int name_end,
     158                              unsigned char * URI, int URI_end);
    158159       
    159160        /*Action routine for end of buffer events.
     
    163164       
    164165        /*Document Type actions.*/
    165         void Doctype_action(int start_pos, int end_pos);
    166         void PEReference_action(int start_pos, int end_pos);
    167         void Elementdecl_action(int start_pos, int end_pos);
    168         void AttlistDecl_action(int start_pos, int end_pos);
    169         void Entitydecl_action(int entity_name_start, int entity_name_end, int start_pos, int end_pos);
    170         void Notationdecl_action(int start_pos, int end_pos);
     166        void Doctype_action(unsigned char * item, int lgth);
     167        void PEReference_action(unsigned char * item, int lgth);
     168        void Elementdecl_action(unsigned char * item, int lgth);
     169        void AttlistDecl_action(unsigned char * item, int lgth);
     170        void Entitydecl_action(unsigned char * entity_name, int entity_name_lgth, unsigned char * item, int lgth);
     171        void Notationdecl_action(unsigned char * item, int lgth);
    171172       
    172         void Prolog_action(int start_pos, int end_pos);
     173        void Prolog_action(unsigned char * item, int lgth);
    173174};
    174175
Note: See TracChangeset for help on using the changeset viewer.