createGrammars.c

Go to the documentation of this file.

/*==================================================================*\
|                EXIP - Embeddable EXI Processor in C                |
|--------------------------------------------------------------------|
|          This work is licensed under BSD 3-Clause License          |
|  The full license terms and conditions are located in LICENSE.txt  |
\===================================================================*/

#include "procTypes.h"
#include "schemaOutputUtils.h"
#include "grammars.h"
#include "sTables.h"
#include <stdio.h>
#include <time.h>
#include "createGrammars.h"

errorCode toText(EXIPSchema* schemaPtr, FILE *outfile)
{
    EXIGrammar* tmpGrammar;
    QNameID qnameId = {0, 0};

    fprintf(outfile, "\n/** GLOBAL ELEMENT GRAMMARS **/\n\n");
    for(qnameId.uriId = 0; qnameId.uriId < schemaPtr->uriTable.count; qnameId.uriId++)
    {
        for(qnameId.lnId = 0; qnameId.lnId < schemaPtr->uriTable.uri[qnameId.uriId].lnTable.count; qnameId.lnId++)
        {
            tmpGrammar = GET_ELEM_GRAMMAR_QNAMEID(schemaPtr, qnameId);
            if(tmpGrammar != NULL)
            {
                if(EXIP_OK != recursiveTextGrammarOutput(qnameId, GET_LN_URI_QNAME(schemaPtr->uriTable, qnameId).elemGrammar, tmpGrammar, schemaPtr, outfile))
                {
                    printf("\n ERROR: OUT_TEXT output format!");
                    return EXIP_UNEXPECTED_ERROR;
                }
            }
        }
    }

    fprintf(outfile, "\n/** GLOBAL TYPE GRAMMARS **/\n\n");
    for(qnameId.uriId = 0; qnameId.uriId < schemaPtr->uriTable.count; qnameId.uriId++)
    {
        for(qnameId.lnId = 0; qnameId.lnId < schemaPtr->uriTable.uri[qnameId.uriId].lnTable.count; qnameId.lnId++)
        {
            tmpGrammar = GET_TYPE_GRAMMAR_QNAMEID(schemaPtr, qnameId);
            if(tmpGrammar != NULL)
            {
                if(EXIP_OK != textGrammarOutput(qnameId, GET_LN_URI_QNAME(schemaPtr->uriTable, qnameId).typeGrammar, tmpGrammar, schemaPtr, outfile))
                {
                    printf("\n ERROR: OUT_TEXT output format!");
                    return EXIP_UNEXPECTED_ERROR;
                }
            }
        }
    }

    return EXIP_OK;
}

errorCode toStaticSrc(EXIPSchema* schemaPtr, char* prefix, FILE *outfile, Deviations dvis)
{
    time_t now;
    Index count;
    Index uriId;
    Index stId, stIdMax;
    Index grIter;
    EXIGrammar* tmpGrammar;

    time(&now);
    fprintf(outfile, "/** AUTO-GENERATED: %.24s\n  * Copyright (c) 2010 - 2011, Rumen Kyusakov, EISLAB, LTU\n  * $Id$ */\n\n",  ctime(&now));

    fprintf(outfile, "/** Compilation parameters:\n");
    if(dvis.grammar != 0 || dvis.ln != 0 || dvis.url != 0 || dvis.pfx != 0)
    {
        fprintf(outfile, "  * Compiled for possible deviations from the schema:\n  * URLs: %d\n  * Local names: %d\n  * Prefixes: %d\n  * Built-in grammars: %d */\n\n", dvis.url, dvis.ln, dvis.pfx, dvis.grammar);
    }
    else
        fprintf(outfile, "  * Compiled for no deviations from the schema! (lower memory usage) */\n\n");


    fprintf(outfile, "#include \"procTypes.h\"\n\n");
    fprintf(outfile, "#define CONST\n\n");

    staticStringTblDefsOutput(&schemaPtr->uriTable, prefix, outfile);

    for(grIter = 0; grIter < schemaPtr->grammarTable.count; grIter++)
    {
        staticProductionsOutput(&schemaPtr->grammarTable.grammar[grIter], prefix, grIter, outfile);
        staticRulesOutput(&schemaPtr->grammarTable.grammar[grIter], prefix, grIter, outfile);
    }

    /* The array of schema-informed EXI grammars in the EXIPSchema object */
    fprintf(outfile, "static CONST EXIGrammar %sgrammarTable[%u] =\n{\n", prefix, (unsigned int) schemaPtr->grammarTable.count + dvis.grammar);
    for(grIter = 0; grIter < schemaPtr->grammarTable.count; grIter++)
    {
        tmpGrammar = &schemaPtr->grammarTable.grammar[grIter];
        fprintf(outfile,"   {%srule_%u, %u, %u},\n",
                prefix,
                (unsigned int) grIter,
                (unsigned int) tmpGrammar->props,
                (unsigned int) tmpGrammar->count);
    }
    // Reserving space for built-in grammar deviations
    for(grIter = 0; grIter < dvis.grammar; grIter++)
    {
        fprintf(outfile,"   {NULL, 0, 0},\n");
    }

    fprintf(outfile, "};\n\n");

    /* Build the Prefix and LN table structures */
    for(uriId = 0; uriId < schemaPtr->uriTable.count; uriId++)
    {
        /* Prefix table */
        staticPrefixOutput(&schemaPtr->uriTable.uri[uriId].pfxTable, prefix, uriId, dvis, outfile);
        /* Ln table */
        staticLnEntriesOutput(&schemaPtr->uriTable.uri[uriId].lnTable, prefix, uriId, dvis, outfile);
    }

    /* Build the URI table structure */
    staticUriTableOutput(&schemaPtr->uriTable, prefix, dvis, outfile);

    /* Build the document grammar */
    staticDocGrammarOutput(&schemaPtr->docGrammar, prefix, outfile);

    /* Build the simple types structure */
    fprintf(outfile, "static CONST SimpleType %ssimpleTypes[%u] =\n{\n", prefix, (unsigned int) schemaPtr->simpleTypeTable.count);

    if(schemaPtr->simpleTypeTable.sType != NULL)
    {
        stIdMax = schemaPtr->simpleTypeTable.count;
        for(stId = 0; stId < stIdMax; stId++)
        {
            fprintf(outfile,
                    "    {%d, %d, 0x%016lX, 0x%016lX}%s",
                    schemaPtr->simpleTypeTable.sType[stId].content,
                    schemaPtr->simpleTypeTable.sType[stId].length,
                    (long unsigned) schemaPtr->simpleTypeTable.sType[stId].max,
                    (long unsigned) schemaPtr->simpleTypeTable.sType[stId].min,
                    stId==(stIdMax-1) ? "\n};\n\n" : ",\n");
        }
    }

    /* Enum table entries */
    staticEnumTableOutput(schemaPtr, prefix, outfile);

    /* Finally, build the schema structure */
    fprintf(outfile,
            "CONST EXIPSchema %sschema =\n{\n",
            prefix);


    fprintf(outfile, "    {NULL, NULL},\n");

    count = schemaPtr->uriTable.count;
    fprintf(outfile,
            "    {{sizeof(UriEntry), %u, %u}, %suriEntry, %u},\n",
            (unsigned int) count,
            (unsigned int) count + dvis.url,
            prefix,
            (unsigned int) count);

    fprintf(outfile,
            "    {%sdocGrammarRule, %u, %u},\n",
            prefix,
            (unsigned int) schemaPtr->docGrammar.props,
            (unsigned int) schemaPtr->docGrammar.count);

    count = schemaPtr->simpleTypeTable.count;
    fprintf(outfile,
            "    {{sizeof(SimpleType), %u, %u}, %ssimpleTypes, %u},\n",
            (unsigned int) count,
            (unsigned int) count,
            prefix,
            (unsigned int) count);

    count = schemaPtr->grammarTable.count;
    fprintf(outfile,
            "    {{sizeof(EXIGrammar), %u, %u}, %sgrammarTable, %u},\n    %u,\n",
            (unsigned int) count,
            (unsigned int) count + dvis.grammar,
            prefix,
            (unsigned int) count,
            (unsigned int) count);

    count = schemaPtr->enumTable.count;
    fprintf(outfile,
            "    {{sizeof(EnumDefinition), %u, %u}, %s%s, %u}\n};\n\n",

            (unsigned int) count,
            (unsigned int) count,
            count == 0?"":prefix, count == 0?"NULL":"enumTable",
            (unsigned int) count);

    return EXIP_OK;
}

errorCode toDynSrc(EXIPSchema* schemaPtr, FILE *outfile)
{
    return EXIP_NOT_IMPLEMENTED_YET;
}

errorCode toEXIP(EXIPSchema* schemaPtr, FILE *outfile)
{
    return EXIP_NOT_IMPLEMENTED_YET;
}