genexi.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>

//#define EXIP_DECIMAL int

#include "EXIParser.h"
#include "EXISerializer.h"
#include "stringManipulate.h"
#include "grammarGenerator.h"


#define BUFFER_SIZE 30000000 // 30 MB
size_t writeFileOutputStream(void* buf, size_t readSize, void* stream);


// EXIP strings

#define EXIP_STRING(str) {(char*)str, sizeof(str)-1}

const String STR_EMPTY = {NULL, 0};
const String STR_DOCUMENT = EXIP_STRING("document");
const String STR_QUERY = EXIP_STRING("query");
const String STR_RESULT = EXIP_STRING("result");
const String STR_VALUE = EXIP_STRING("value");
const String STR_ID = EXIP_STRING("id");
const String STR_OP = EXIP_STRING("op");
const String STR_ADD = EXIP_STRING("add");


void _error(int lineno, const char *msg) {
    fprintf(stderr, "Error: %s. Line number: %d.\n", msg, lineno);
    fflush(stderr);
}

void _error2(int lineno, const char *msg, int code) {
    fprintf(stderr, "Error: %s. Code: %d. Line number: %d.\n", msg, code, lineno);
    fflush(stderr);
}

#define error(msg) _error(__LINE__, msg)
#define error2(msg, code) _error2(__LINE__, msg, code)


int main(int argc, char *argv[]) {
    printf("%s starting\n", argv[0]);

    // Seed random number generator
    srand(time(NULL));

    int i;
    for (i=1; i <= 100; i++) {
        char txt[100];
        int n = pow(i*20, 1.6);
        //int numqueries = i*100;
        printf("data%05d.exi, %d entries\n", i, n);

        // Init output file
        sprintf(txt, "data%05d.exi", i);
        FILE *fd = fopen(txt, "wb");
        if (fd == NULL) {
            error("creating file");
            return 1;
        }


        // Init serializer
        EXIStream serStrm;
        errorCode err;
        QName qname = {&STR_EMPTY, NULL, NULL};
        EXITypeClass valueType;
        char *buf = malloc(BUFFER_SIZE);

        BinaryBuffer serbuf;
        serbuf.buf = buf;
        serbuf.bufLen = BUFFER_SIZE;
        serbuf.bufContent = 0;
        serbuf.ioStrm.readWriteToStream = writeFileOutputStream;
        serbuf.ioStrm.stream = fd;

        serialize.initHeader(&serStrm);
        serStrm.header.has_cookie = TRUE;
        serStrm.header.has_options = TRUE;
        serStrm.header.opts.valueMaxLength = 300;
        serStrm.header.opts.valuePartitionCapacity = 50;
        SET_STRICT(serStrm.header.opts.enumOpt);

        err = serialize.initStream(&serStrm, serbuf, NULL, SCHEMA_ID_ABSENT, NULL);
        if (err != EXIP_OK) {
            error2("initializing EXI output stream", err);
            fclose(fd);
            return 1;
        }

        err += serialize.exiHeader(&serStrm);
        err += serialize.startDocument(&serStrm);

        // <document>
        qname.localName = &STR_DOCUMENT;
        err += serialize.startElement(&serStrm, qname, &valueType);


        // <query id="1" op="add"><value>497</value><value>5102</value></query>
        int j;
        for (j=1; j <= n; j++) {
            String chVal;

            // <query
            qname.localName = &STR_QUERY;
            err += serialize.startElement(&serStrm, qname, &valueType);

            // id=
            qname.localName = &STR_ID;
            err += serialize.attribute(&serStrm, qname, TRUE, &valueType);
            sprintf(txt, "%d", j);
            err += asciiToString(txt, &chVal, &serStrm.memList, TRUE);
            err += serialize.stringData(&serStrm, chVal);

            // op="add"
            qname.localName = &STR_OP;
            err += serialize.attribute(&serStrm, qname, TRUE, &valueType);
            err += asciiToString("add", &chVal, &serStrm.memList, TRUE);
            err += serialize.stringData(&serStrm, chVal);

            // generate 1 <= x,y <= 1000
            int x = (rand()%1000)+1;
            int y = (rand()%1000)+1;

            // <value>x</value>
            qname.localName = &STR_VALUE;
            err += serialize.startElement(&serStrm, qname, &valueType);
            sprintf(txt, "%d", x);
            err += asciiToString(txt, &chVal, &serStrm.memList, TRUE);
            err += serialize.stringData(&serStrm, chVal);
            err += serialize.endElement(&serStrm);

            // <value>y</value>
            err += serialize.startElement(&serStrm, qname, &valueType);
            sprintf(txt, "%d", y);
            err += asciiToString(txt, &chVal, &serStrm.memList, TRUE);
            err += serialize.stringData(&serStrm, chVal);
            err += serialize.endElement(&serStrm);

            // </query>
            err += serialize.endElement(&serStrm);
        }

        // </document>
        err += serialize.endElement(&serStrm);
        err += serialize.endDocument(&serStrm);
        err += serialize.closeEXIStream(&serStrm);

        if (err != EXIP_OK) {
            error2("EXI serializer", err);
            fclose(fd);
            return 1;
        }

        free(buf);
    }

    printf("All done.\n");


    return 0;
}

size_t writeFileOutputStream(void* buf, size_t readSize, void* stream)
{
    FILE *outfile = (FILE*) stream;
    return fwrite(buf, 1, readSize, outfile);
}