root/proto/parabix2/pablo_template.cpp @ 2160

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

#define LocalCarryDeclare(name, count)\
CarryArray<count> name;\

#include "../lib/bitblock.hpp"
#include "../lib/carryQ.hpp"
#include "../lib/bitstream_iterator.hpp"
#include "../lib/bitblock_iterator.hpp"
#include "../lib/s2p.hpp"
#include "../lib/perflib/perfsec.h"

#include "xmldecl.h"
#include "namechars.h"
#include "TagMatcher.hpp"
#include "LineColTracker.hpp"
#include "ErrorUtil.h"
#include "ErrorTracker.h"
#include "XMLTestSuiteError.h"

#ifdef BUFFER_PROFILING
    BOM_Table * parser_timer;
#elif CODE_CLOCKER
    //#define NUM_EVENTS 1
    //int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
    //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
    #define NUM_EVENTS 2
    int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
    int cal_size = 20;
    CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
#else
    void * parser_timer;
#endif

ErrorTracker error_tracker;
BitBlock EOF_mask = simd<1>::constant<1>();

//////////////////////////////////////////////////////////////////////////////////////////
// Buffer Management
//////////////////////////////////////////////////////////////////////////////////////////
#include "../lib/buffer.hpp"

#define OVERLAP_BUFSIZE PADDING_SIZE //sizeof(BitBlock)

//////////////////////////////////////////////////////////////////////////////////////////
// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
//////////////////////////////////////////////////////////////////////////////////////////
@global

//////////////////////////////////////////////////////////////////////////////////////////
// Headers that depend @ global stream struct types.
//////////////////////////////////////////////////////////////////////////////////////////
#include "../lib/transpose.hpp"
#include "post_process.hpp"

static void do_process(FILE *infile, FILE *outfile);

int main(int argc, char * argv[]) {

        char * infilename, * outfilename;
        FILE *infile, *outfile;
        struct stat fileinfo;

        if (argc < 2) {
                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
                exit(-1);
        }

        infilename = argv[1];
        stat(infilename, &fileinfo);
        infile = fopen(infilename, "rb");
        if (!infile) {
                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
                exit(-1);
        }

        if (argc < 3) outfile = stdout;
        else {
                outfilename = argv[2];
                outfile = fopen(outfilename, "wb");
                if (!outfile) {
                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
                        exit(-1);
                }
        }

        PERF_SEC_BIND(1);

        PERF_SEC_INIT(parser_timer);

        do_process(infile, outfile);

        PERF_SEC_DUMP(parser_timer);

        PERF_SEC_DESTROY(parser_timer);

        fclose(infile);
        fclose(outfile);

        return(0);
}

void do_process(FILE *infile, FILE *outfile) {

    @decl

    LineColTracker tracker;
    TagMatcher<SEGMENT_SIZE,OVERLAP_BUFSIZE> matcher;

    uint8_t * src_buf;
    int block_base=0;
    int buffer_base=0;
    int buffer_pos = 0;
    int block_pos = 0;
    int chars_avail = 0;
    int check_pos = 0;
    int chars_read = 0;

    //////////////////////////////////////////////////////////////////////////////////////////
    // Buffer Management
    //////////////////////////////////////////////////////////////////////////////////////////
    BitBlock buf[(PADDING_SIZE + SEGMENT_SIZE + PADDING_SIZE)/sizeof(BitBlock)];
    src_buf = (uint8_t *)buf + PADDING_SIZE;

    //ALLOC_STATIC_ALIGNED_BYTE_BUFFER(src_buf, (PADDING_SIZE + SEGMENT_SIZE + PADDING_SIZE));

    buffer_base = buffer_pos;
    chars_read = fread((void *)src_buf, 1, BUFFER_SIZE, infile);
    chars_avail = chars_read;
    if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;

    //////////////////////////////////////////////////////////////////////////////////////////
    // XML Validation / Content Model
    //////////////////////////////////////////////////////////////////////////////////////////
    if(chars_read<4){
    fprintf(stderr,"File is too short. Not well formed.\n");
    exit(-1);
    }

    Entity_Info * e = new Entity_Info;
    e->AnalyzeSignature((unsigned char *)src_buf);

    if (e->code_unit_base == ASCII) {

    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)src_buf);

    decl_parser.ReadXMLInfo(*e);

    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
        exit(-1);
    }
    }
    else {
        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
        exit(-1);
    }

    if (e->content_start != 0) {
    memmove(&src_buf[0], &src_buf[e->content_start], chars_read - e->content_start);
    buffer_pos = e->content_start;
    if (chars_avail == SEGMENT_SIZE) {
        chars_read = chars_read - e->content_start + fread(&src_buf[chars_read-e->content_start], 1, e->content_start, infile);
        chars_avail = chars_read;
        if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
    }
    else {
      chars_read -=e->content_start;
      chars_avail -=e->content_start;
    }
    }

    @stream_stmts


    //////////////////////////////////////////////////////////////////////////////////////////
    // Full Segments
    //////////////////////////////////////////////////////////////////////////////////////////
    matcher.setSrc((char *)src_buf);
    while (chars_avail == SEGMENT_SIZE) {
      PERF_SEC_START(parser_timer);
      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
          block_base = blk*BLOCK_SIZE;
          s2p_do_block((BytePack *) &src_buf[block_base], basis_bits);

          @block_stmts

          tracker.StoreNewlines(lex.LF);
          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buf, buffer_base, block_base, chars_avail, tracker);
          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
          tracker.AdvanceBlock();
      }
      matcher.StreamScan(chars_avail);
      matcher.Advance_buffer();
      PERF_SEC_END(parser_timer, chars_avail);

      int bytes_left = chars_read - chars_avail;
      memmove(src_buf, &src_buf[SEGMENT_SIZE], bytes_left);
      chars_read = fread(&src_buf[bytes_left], 1, BUFFER_SIZE - bytes_left, infile) + bytes_left;
      chars_avail = chars_read;
      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
      buffer_pos += chars_avail;
      buffer_base = buffer_pos;
    }

    //////////////////////////////////////////////////////////////////////////////////////////
    // Final Partial Segment
    //////////////////////////////////////////////////////////////////////////////////////////
    PERF_SEC_START(parser_timer);

    block_pos = 0;
    int remaining = chars_avail;

    /* Full Blocks */
    while (remaining >= BLOCK_SIZE) {
          block_base = block_pos;
          s2p_do_block((BytePack *) &src_buf[block_pos], basis_bits);
          @block_stmts
          tracker.StoreNewlines(lex.LF);
          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buf, buffer_base, block_base, chars_avail, tracker);
          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
          tracker.AdvanceBlock();
          block_pos += BLOCK_SIZE;
          remaining -= BLOCK_SIZE;
    }
    block_base = block_pos;

    /* Partial Block or Any Carry */
    if (remaining > 0 || @any_carry) {
          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
          s2p_do_final_block((BytePack *) &src_buf[block_pos], basis_bits, EOF_mask);
          @final_block_stmts
          tracker.StoreNewlines(lex.LF);
          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buf, buffer_base, block_base, chars_avail, tracker);
          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
          tracker.AdvanceBlock();

    }

    buffer_pos += chars_avail;
    buffer_base = buffer_pos;

    matcher.StreamScan(chars_avail);
    matcher.Advance_buffer();

    PERF_SEC_END(parser_timer, chars_avail);
    if (matcher.depth != 0) {
      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
      exit(-1);
    }
}