Changeset 192 for trunk/PerfTest


Ignore:
Timestamp:
Aug 11, 2008, 5:07:41 PM (11 years ago)
Author:
ksherdy
Message:

Updated PerfTest? Makefiles to autodetect 32 vs. 64 bit architecture on Intel.
Initial Intel Markup Stats check in.
Renamed Xerces-C files names to be Xerces-C specific.

Location:
trunk/PerfTest
Files:
7 added
5 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/PerfTest/expat_markup_stats/Makefile

    r152 r192  
    11CC=g++
    22CFLAGS= -O3
    3 OBJECTS=
    4 LIBS=/opt/expat_2_0_1/lib
    5 LINKS=expat
    6 OS = $(shell uname)
    7 ICONV_FLAGS=
    8 ifeq ($(OS),Darwin)
    9         ICONV_FLAGS=-liconv
     3
     4ARCH=$(shell getconf LONG_BIT)
     5ifeq ($(ARCH),32)
     6    AFLAGS=-march=pentium4
     7        LIBS=-L/opt/expat_2_0_1/lib
     8    PAPI=-DPAPI -I/usr/local/papi-3.5.0-linux-x86/include -L/usr/local/papi-3.5.0-linux-x86/lib -lpapi     
     9else
     10    AFLAGS=-march=nocona -m64
     11        LIBS=-L/opt/expat_2_0_1/lib   
     12    PAPI=-DPAPI -I/usr/local/papi-3.5.0-linux-x86/include -L/usr/local/papi-3.5.0-linux-x86/lib64 -lpapi     
    1013endif
    1114
    12 INCLUDES=-I/usr/local/papi-3.5.0-linux-x86/include -I/opt/expat_2_0_1/include
    13 LINKS=-lpapi -lexpat
    14 LIBS=-L/usr/local/papi-3.5.0-linux-x86/lib -L/opt/expat_2_0_1/lib
    15 LIBS64=-L/usr/local/papi-3.5.0-linux-x86/lib64 -L/opt/expat_2_0_1/lib
    16 
    17 expat_markup_stats_32: expat_markup_stats.c
    18         $(CC) $(CFLAGS) -o expat_markup_stats expat_markup_stats.c -march=pentium4 $(INCLUDES) $(LINKS) $(LIBS) -DPAPI -DCALC_AVG
    19 
    20 expat_markup_stats_64: expat_markup_stats.c
    21         $(CC) $(CFLAGS) -o expat_markup_stats expat_markup_stats.c -march=nocona -m64 $(INCLUDES) $(LINKS) $(LIBS64) -DPAPI -DCALC_AVG
     15INCLUDES=-I/opt/expat_2_0_1/include
     16LINKS=-lexpat
     17   
     18all: expat_markup_stats.c
     19        $(CC) $(CFLAGS) -o expat_markup_stats expat_markup_stats.c -DCALC_AVG $(AFLAGS) $(INCLUDES) $(OBJECTS) $(LIBS) $(LINKS) $(PAPI)
    2220       
    2321clean:
  • trunk/PerfTest/expat_markup_stats/expat_markup_stats.c

    r155 r192  
    88
    99#ifndef REPEAT_RUNS
    10 #define REPEAT_RUNS 3
     10#define REPEAT_RUNS 1
    1111#endif
    1212
     
    4949//int total_namespace_URI_length = 0;
    5050
    51 void startElementHandler(void *data, const char *el, const char **attr) 
     51void startElementHandler(void *data, const char *el, const char **attr)
    5252{
    5353        start_tag_count += 1;
    54        
     54
    5555        #if defined(CALC_AVG)
    5656                start_tag_length += strlen(el);
    5757        #endif
    58        
    59        
     58
     59
    6060        nesting_depth += 1;
    61         if (nesting_depth > max_nesting_depth) max_nesting_depth = nesting_depth;       
    62 
    63         for (int i = 0; attr[i]; i += 2) 
     61        if (nesting_depth > max_nesting_depth) max_nesting_depth = nesting_depth;
     62
     63        for (int i = 0; attr[i]; i += 2)
    6464        {
    6565                total_attribute_count += 1;
    66                
     66
    6767                #if defined(CALC_AVG)
    6868                        total_att_name_length += strlen(attr[i]);
    6969                        total_att_value_length += strlen(attr[i+1]);
    70                 #endif         
    71                
    72         }       
    73        
    74 }
    75 
    76 void endElementHandler(void *data, const char *name)
     70                #endif
     71
     72        }
     73}
     74
     75void endElementHandler(void *data, const char *name)
    7776{
    7877        end_tag_count +=1;
    7978        nesting_depth -= 1;
    80        
     79
    8180        #if defined(CALC_AVG)
    8281                end_tag_length += strlen(name);
    8382        #endif
    84 } 
     83}
    8584
    8685void CharacterDataHandler(void *userData, const XML_Char *s, int len)
    8786{
    8887        text_item_count +=1;
    89        
     88
    9089        #if defined(CALC_AVG)
    9190                text_item_length += len;
     
    9695{
    9796        comment_count +=1;
    98        
     97
    9998        #if defined(CALC_AVG)
    10099                comment_length += strlen(data);
     
    105104{
    106105        PI_count +=1;
    107        
     106
    108107        #if defined(CALC_AVG)
    109108                PI_length += strlen(data);
     
    136135        }
    137136        char * src_filename = argv[1];
    138         char * cmdline = new char[strlen(argv[0]) + strlen(argv[1]) +1 +1]; 
     137        char * cmdline = new char[strlen(argv[0]) + strlen(argv[1]) +1 +1];
    139138        strcat(cmdline, argv[0]);
    140139        strcat(cmdline," ");
    141140        strcat(cmdline,argv[1]);
    142        
     141
    143142        #ifdef PAPI
    144143                #define NUM_EVENTS 1
     
    148147                int cal_size = 1000;
    149148                code_clocker = new CC(Events,NUM_EVENTS,cal_size);
    150                 code_clocker->cc_set_cmd(cmdline);
    151         #endif 
    152        
    153         // read the entire file into a memory buffer   
     149                code_clocker->set_cmd(cmdline);
     150        #endif
     151
     152        // read the entire file into a memory buffer
    154153        FILE * src_file;
    155154        struct stat fileinfo;
     
    157156        char * src_buf = NULL;
    158157        size_t result;
    159        
    160         // open file and fstat
     158
     159        //Open file and fstat
    161160        src_file = fopen ( src_filename , "rb" );
     161        if (!src_file) {
     162                fprintf(stderr, "Cannot open '%s'. Terminating the process ...\n", src_filename);
     163                exit(-1);
     164        }
     165
    162166        if(fstat(fileno(src_file), &fileinfo)!=0) {
    163                 fprintf(stderr, "Cannot fstat '%s'. Terminating the process ...\n", src_filename); 
    164                 exit(-1);
    165         }
    166        
    167         // allocate memory to contain the whole file
     167                fprintf(stderr, "Cannot fstat '%s'. Terminating the process ...\n", src_filename);
     168                exit(-1);
     169        }
     170
     171        //Allocate memory to contain the whole file
    168172        src_filesize = fileinfo.st_size;
    169173        src_buf = (char*) new char[src_filesize];
    170         if (src_buf == NULL) 
     174        if (src_buf == NULL)
    171175        {
    172176                fprintf(stderr, "Out of memory. Terminating the process ...\n");
    173177                exit(-1);
    174178        }
    175        
     179
    176180        // copy the file into the buffer:
    177181        result = fread (src_buf,1,src_filesize,src_file);
    178         if (result != src_filesize) 
     182        if (result != src_filesize)
    179183        {
    180184                fprintf(stderr, "Error reading '%s'. Terminating the process ...\n", src_filename);
    181185                exit(-1);
    182186        }
    183        
     187
    184188        // close file
    185189        fclose (src_file);
    186190
    187         for (int run = 0; run < REPEAT_RUNS; run++) 
    188         {       
    189                 const XML_Char * encoding = "UTF-8";   
     191        for (int run = 0; run < REPEAT_RUNS; run++)
     192        {
     193                const XML_Char * encoding = "UTF-8";
    190194                XML_Parser parser = XML_ParserCreate(encoding);
    191          
     195
    192196                XML_SetElementHandler(parser, startElementHandler, endElementHandler);
    193                 XML_SetCharacterDataHandler(parser, CharacterDataHandler);     
     197                XML_SetCharacterDataHandler(parser, CharacterDataHandler);
    194198                XML_SetProcessingInstructionHandler(parser, ProcessingInstructionHandler);
    195199                XML_SetCommentHandler(parser, CommentHandler);
    196200                XML_SetCdataSectionHandler(parser, StartCdataSectionHandler, EndCdataSectionHandler);
    197        
     201
    198202                #ifdef PAPI
    199                         code_clocker->cc_start_interval();
     203                        code_clocker->start_interval();
    200204                #endif
    201                
     205
    202206                int done = 1;
    203                 XML_Parse(parser, src_buf, src_filesize, done); 
    204        
     207                XML_Parse(parser, src_buf, src_filesize, done);
     208
    205209                #ifdef PAPI
    206210                        int elems = src_filesize;
    207                         code_clocker->cc_end_interval(elems);
     211                        code_clocker->end_interval(elems);
    208212                #endif
    209        
     213
    210214                XML_ParserFree(parser);
    211                 printf("Run %i complete.\n", run);     
    212         }
    213        
     215                printf("Run %i complete.\n", run);
     216        }
     217
    214218        #ifdef PAPI
    215                 code_clocker->cc_write_xml_file();
    216                 code_clocker->cc_display();
     219                code_clocker->write_xml_file();
     220                code_clocker->display_raw_event_data();
    217221                delete code_clocker;
    218         #endif         
     222        #endif
    219223
    220224        // clean up
    221225        delete [] src_buf;
    222                
     226
    223227        // print stats
    224228        print_stats("comment", comment_count, comment_length);
  • trunk/PerfTest/xerces_markup_stats/Makefile

    r152 r192  
    11CC= g++ $(CFLAGS)
    22CFLAGS= -O3 # -g
    3 OS = $(shell uname)
    4 ICONV_FLAGS=
    5 ifeq ($(OS),Darwin)
    6         ICONV_FLAGS=-liconv
     3
     4ARCH=$(shell getconf LONG_BIT)
     5ifeq ($(ARCH),32)
     6    AFLAGS=-march=pentium4
     7    LIBS=-L/opt/xerces-c_2_8_0-x86-linux-gcc_3_4/lib
     8    PAPI=-DPAPI -I/usr/local/papi-3.5.0-linux-x86/include -L/usr/local/papi-3.5.0-linux-x86/lib -lpapi     
     9else
     10    AFLAGS=-march=nocona -m64
     11    LIBS=-L/opt/xerces-c_2_8_0-x86-linux-gcc_3_4/lib
     12    PAPI=-DPAPI -I/usr/local/papi-3.5.0-linux-x86/include -L/usr/local/papi-3.5.0-linux-x86/lib64 -lpapi     
    713endif
    814
    9 INCLUDES=-I/usr/local/papi-3.5.0-linux-x86/include -I/opt/xerces-c_2_8_0-x86-linux-gcc_3_4/include
    10 LINKS=-lpapi -lxerces-c
    11 LIBS=-L/usr/local/papi-3.5.0-linux-x86/lib -L/opt/xerces-c_2_8_0-x86-linux-gcc_3_4/lib
    12 LIBS64=-L/usr/local/papi-3.5.0-linux-x86/lib64 -L/opt/xerces-c_2_8_0-x86-linux-gcc_3_4/lib
     15INCLUDES=-I/opt/xerces-c_2_8_0-x86-linux-gcc_3_4/include
     16LINKS=-lxerces-c
    1317
    14 xerces_markup_stats_32: xerces_markup_stats.hpp xerces_markup_stats.cpp markup_stats_handlers.hpp markup_stats_handlers.cpp
    15         $(CC) -o xerces_markup_stats xerces_markup_stats.cpp markup_stats_handlers.cpp -march=pentium4 $(INCLUDES) $(LINKS) $(LIBS) -DPAPI -DDEBUG -DCALC_AVG
    16 
    17 xerces_markup_stats_64: xerces_markup_stats.hpp xerces_markup_stats.cpp markup_stats_handlers.hpp markup_stats_handlers.cpp
    18         $(CC) -o xerces_markup_stats xerces_markup_stats.cpp markup_stats_handlers.cpp -march=nocona -m64 $(INCLUDES) $(LINKS) $(LIBS64) -DPAPI -DDEBUG -DCALC_AVG
     18all:    xerces_markup_stats.hpp xerces_markup_stats.cpp xerces_markup_stats_handlers.hpp xerces_markup_stats_handlers.cpp
     19        $(CC) -o xerces_markup_stats xerces_markup_stats.cpp xerces_markup_stats_handlers.cpp -DCALC_AVG $(AFLAGS) $(INCLUDES) $(OBJECTS) $(LIBS) $(LINKS) $(PAPI)
    1920       
    2021clean:
  • trunk/PerfTest/xerces_markup_stats/xerces_markup_stats.cpp

    r155 r192  
    2020#endif
    2121
    22 XERCES_CPP_NAMESPACE_USE 
    23  
     22XERCES_CPP_NAMESPACE_USE
     23
    2424int main(int argc, char* argv[])
    2525{
     
    2828                exit(-1);
    2929        }
    30        
     30
    3131        // read the source file name
    32         char * src_filename = argv[1]; 
    33         char * cmdline = new char[strlen(argv[0]) + strlen(argv[1]) +1 +1]; 
     32        char * src_filename = argv[1];
     33        char * cmdline = new char[strlen(argv[0]) + strlen(argv[1]) +1 +1];
    3434        strcat(cmdline, argv[0]);
    3535        strcat(cmdline," ");
    3636        strcat(cmdline,argv[1]);
    37                
    38         // read the entire file into a memory buffer   
     37
     38        // read the entire file into a memory buffer
    3939        FILE * src_file;
    4040        struct stat fileinfo;
     
    4242        char * src_buf = NULL;
    4343        size_t result;
    44        
    45         // open file and fstat
     44
     45        // Open file and fstat
    4646        src_file = fopen ( src_filename , "rb" );
    47         if(fstat(fileno(src_file), &fileinfo)!=0) {
    48                 fprintf(stderr, "Cannot fstat '%s'. Terminating the process ...\n", src_filename); 
     47        if(!src_file) {
     48                fprintf(stderr, "Cannot fstat '%s'. Terminating the process ...\n", src_filename);
    4949                exit(-1);
    5050        }
    51        
     51
     52        if(fstat(fileno(src_file), &fileinfo)!=0) {
     53                fprintf(stderr, "Cannot fstat '%s'. Terminating the process ...\n", src_filename);
     54                exit(-1);
     55        }
     56
    5257        // allocate memory to contain the whole file
    5358        src_filesize = fileinfo.st_size;
    5459        src_buf = (char*) new char[src_filesize];
    55         if (src_buf == NULL) 
     60        if (src_buf == NULL)
    5661        {
    5762                fprintf(stderr, "Out of memory. Terminating the process ...\n");
    5863                exit(-1);
    5964        }
    60        
     65
    6166        // copy the file into the buffer:
    6267        result = fread (src_buf,1,src_filesize,src_file);
    63         if (result != src_filesize) 
     68        if (result != src_filesize)
    6469        {
    6570                fprintf(stderr, "Error reading '%s'. Terminating the process ...\n", src_filename);
    6671                exit(-1);
    6772        }
    68        
     73
    6974        // close file
    70         fclose (src_file);             
    71                
     75        fclose (src_file);
     76
    7277        try {
    7378          XMLPlatformUtils::Initialize();
     
    9095        , src_buf_id
    9196        , false
    92     ); 
    93    
     97    );
     98
    9499    SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
    95    
    96     // Do not perform Namespace processing. 
     100
     101    // Do not perform Namespace processing.
    97102    parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, true);
    98103    parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
    99104
    100     MarkupStats* defaultHandler = new MarkupStats();
     105    MarkupStatsHandler* defaultHandler = new MarkupStatsHandler();
    101106    parser->setContentHandler(defaultHandler);
    102107    parser->setErrorHandler(defaultHandler);
    103108
    104109    try {
    105    
     110
    106111        // Parse the file
    107112                #ifdef PAPI
     
    112117                        int cal_size = 100;
    113118                        c = new CC(Events,NUM_EVENTS,cal_size);
    114                         c->cc_set_cmd(cmdline);
    115                 #endif         
    116        
    117                 for (int run = 0; run < REPEAT_RUNS; run++) 
    118                 {               
     119                        c->set_cmd(cmdline);
     120                #endif
     121
     122                for (int run = 0; run < REPEAT_RUNS; run++)
     123                {
    119124                        #ifdef PAPI
    120                                 c->cc_start_interval();
    121                         #endif         
    122                
     125                                c->start_interval();
     126                        #endif
     127
    123128                parser->parse(*mem_buf);
    124                        
     129
    125130                        #ifdef PAPI
    126131                                int elems = src_filesize;
    127                                 c->cc_end_interval(elems);                     
    128                         #endif 
     132                                c->end_interval(elems);
     133                        #endif
    129134                }
    130135
    131136                #ifdef PAPI
    132                         c->cc_write_xml_file();
    133                         c->cc_display();
     137                        c->write_xml_file();
     138                        c->display_raw_event_data();
    134139                        delete c;
    135                 #endif 
     140                #endif
    136141
    137142                std::cout << std::endl;
     
    153158                print_stats("error item", error_item_count, error_item_length);
    154159                printf("Maximum nesting depth = %i\n", max_nesting_depth);
    155    
     160
    156161    }
    157162    catch (const XMLException& toCatch) {
     
    173178        return -1;
    174179    }
    175        
     180
    176181        delete parser;
    177182    delete defaultHandler;
    178        
     183
    179184        XMLPlatformUtils::Terminate();
    180        
     185
    181186        return 0;
    182187}
  • trunk/PerfTest/xerces_markup_stats/xerces_markup_stats.hpp

    r144 r192  
    22#define MARKUP_STATS_HPP_
    33
    4 #include "markup_stats_handlers.hpp"
     4#include "xerces_markup_stats_handlers.hpp"
    55
    66extern int comment_count;
  • trunk/PerfTest/xerces_markup_stats/xerces_markup_stats_handlers.cpp

    r157 r192  
    1 #include "markup_stats_handlers.hpp"
     1#include "xerces_markup_stats_handlers.hpp"
    22#include <xercesc/sax/SAXParseException.hpp>
    33#include <xercesc/sax/SAXException.hpp>
     
    3838
    3939
    40 MarkupStats::MarkupStats()
    41 {       
     40MarkupStatsHandler::MarkupStatsHandler()
     41{
    4242
    4343}
    4444
    45 MarkupStats::~MarkupStats()
     45MarkupStatsHandler::~MarkupStatsHandler()
    4646{
    4747
    48 }       
     48}
    4949
    5050// -----------------------------------------------------------------------
    5151//  Handlers for the SAX2 ContentHandler interface
    5252// -----------------------------------------------------------------------
    53 void MarkupStats::startElement(const XMLCh* const uri
     53void MarkupStatsHandler::startElement(const XMLCh* const uri
    5454                                   , const XMLCh* const localname
    55                                    , const XMLCh* const qname 
     55                                   , const XMLCh* const qname
    5656                                   , const Attributes& attrs)
    5757{
    5858        start_tag_count +=1;
    59        
     59
    6060        #if defined(CALC_AVG)
    6161                start_tag_length += XMLString::stringLen(qname);
    6262        #endif
    63        
     63
    6464        nesting_depth += 1;
    6565        if (nesting_depth > max_nesting_depth) max_nesting_depth = nesting_depth;
    66        
     66
    6767        int len = attrs.getLength();
    6868        total_attribute_count += len;
    69        
     69
    7070        #if defined(CALC_AVG)
    71                
    72                 for (int i = 0; i < len; i++) 
     71
     72                for (int i = 0; i < len; i++)
    7373                {
    7474                        total_att_name_length += XMLString::stringLen(attrs.getQName(i));
    7575                        total_att_value_length += XMLString::stringLen(attrs.getValue(i));
    7676                }
    77                
     77
    7878        #endif
    7979}
    8080
    81 void MarkupStats::endElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname)
     81void MarkupStatsHandler::endElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname)
    8282{
    8383        end_tag_count +=1;
     
    8585                end_tag_length += XMLString::stringLen(qname);
    8686        #endif
    87         nesting_depth -= 1;     
     87        nesting_depth -= 1;
    8888}
    8989
    90 void MarkupStats::characters (const XMLCh *const chars, const unsigned int length)
     90void MarkupStatsHandler::characters (const XMLCh *const chars, const unsigned int length)
    9191{
    9292        text_item_count +=1;
    93         text_item_length += length;     
     93        text_item_length += length;
    9494}
    9595
    96 void MarkupStats::processingInstruction (const XMLCh *const target, const XMLCh *const data)
     96void MarkupStatsHandler::processingInstruction (const XMLCh *const target, const XMLCh *const data)
    9797{
    9898        PI_count +=1;
    99         #if defined(CALC_AVG)   
    100        
     99        #if defined(CALC_AVG)
     100
    101101                PI_length += XMLString::stringLen(data);
    102        
     102
    103103        #endif
    104104}
     
    107107//  Handlers for the SAXs2 LexicalHandler interface
    108108// -----------------------------------------------------------------------
    109 void MarkupStats::comment(const XMLCh *const chars, const unsigned int length)
     109void MarkupStatsHandler::comment(const XMLCh *const chars, const unsigned int length)
    110110{
    111111        comment_count +=1;
     
    113113}
    114114
    115 void MarkupStats::startCDATA()
     115void MarkupStatsHandler::startCDATA()
    116116{
    117117        CDATA_start_count +=1;
     
    119119}
    120120
    121 void MarkupStats::endCDATA()
     121void MarkupStatsHandler::endCDATA()
    122122{
    123123        CDATA_end_count +=1;
     
    125125}
    126126
    127 void MarkupStats::startEntity(const XMLCh *const name)
     127void MarkupStatsHandler::startEntity(const XMLCh *const name)
    128128{
    129129        reference_count += 1;
    130        
     130
    131131        #if defined(CALC_AVG)
    132        
     132
    133133                reference_length += XMLString::stringLen(name);
    134        
    135         #endif 
     134
     135        #endif
    136136}
    137137
    138 void MarkupStats::endEntity(const XMLCh *const name)
     138void MarkupStatsHandler::endEntity(const XMLCh *const name)
    139139{
    140        
     140
    141141}
    142142
     
    145145// ---------------------------------------------------------------------------
    146146
    147 void MarkupStats::error(const SAXParseException& e)
     147void MarkupStatsHandler::error(const SAXParseException& e)
    148148{
    149149        ::error_item_count++;
    150        
     150
    151151        #if defined (DEBUG)
    152    
     152
    153153    std::cout << "\nError at file " <<  XMLString::transcode(e.getSystemId())
    154154                 << ", line " << e.getLineNumber()
    155155                 << ", char " << e.getColumnNumber()
    156156         << "\n  Message: " <<  XMLString::transcode(e.getMessage()) << std::endl;
    157          
     157
    158158    #endif
    159159}
    160160
    161 void MarkupStats::fatalError(const SAXParseException& e)
     161void MarkupStatsHandler::fatalError(const SAXParseException& e)
    162162{
    163163        ::error_item_count++;
    164        
     164
    165165        #if defined (DEBUG)
    166        
     166
    167167        std::cout << "\nFatal Error at file " <<  XMLString::transcode(e.getSystemId())
    168168                 << ", line " << e.getLineNumber()
    169169                 << ", char " << e.getColumnNumber()
    170170             << "\n  Message: " <<  XMLString::transcode(e.getMessage()) << std::endl;
    171        
    172     #endif   
     171
     172    #endif
    173173}
    174174
    175 void MarkupStats::warning(const SAXParseException& e)
     175void MarkupStatsHandler::warning(const SAXParseException& e)
    176176{
    177177        #if defined (DEBUG)
    178        
     178
    179179    std::cout << "\nWarning at file " <<  XMLString::transcode(e.getSystemId())
    180180                 << ", line " << e.getLineNumber()
    181181                 << ", char " << e.getColumnNumber()
    182182         << "\n  Message: " <<  XMLString::transcode(e.getMessage()) << std::endl;
    183          
    184         #endif         
     183
     184        #endif
    185185}
    186186
  • trunk/PerfTest/xerces_markup_stats/xerces_markup_stats_handlers.hpp

    r157 r192  
    55XERCES_CPP_NAMESPACE_USE
    66
    7 class MarkupStats : public DefaultHandler {
     7class MarkupStatsHandler : public DefaultHandler {
    88
    99        public:
    1010    // -----------------------------------------------------------------------
    1111    //  Constructors and Destructor
    12     // ----------------------------------------------------------------------- 
    13         MarkupStats();
    14     ~MarkupStats();     
     12    // -----------------------------------------------------------------------
     13        MarkupStatsHandler();
     14    ~MarkupStatsHandler();
    1515
    1616    // -----------------------------------------------------------------------
    1717    //  Handlers for the SAX2 ContentHandler interface
    1818    // -----------------------------------------------------------------------
    19         void startElement(const XMLCh* const, const XMLCh* const, const XMLCh* const, const Attributes& attrs);   
     19        void startElement(const XMLCh* const, const XMLCh* const, const XMLCh* const, const Attributes& attrs);
    2020        void endElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname);
    2121        void characters (const XMLCh *const chars, const unsigned int length);
     
    3030        void startEntity(const XMLCh *const name);
    3131        void endEntity(const XMLCh *const name);
    32        
     32
    3333        /*
    3434        void startDTD (const XMLCh *const name, const XMLCh *const publicId, const XMLCh *const systemId);
     
    4646
    4747        private:
     48                // no private members
    4849
    4950};
Note: See TracChangeset for help on using the changeset viewer.