static void _lookupSchema() {
int i, j;
EXIGrammar *gr;
GrammarRule *rule;
extern errorCode printGrammarRule(SmallIndex nonTermID, GrammarRule* rule, EXIPSchema *schema);
printf ("*** DocGrammar\n");
gr=&g_schemaPtr->docGrammar;
for (j=0, rule=gr->rule; j<gr->count; j++, rule++) {
printGrammarRule(j, rule, g_schemaPtr);
}
printf (" grammarTable %d\n", g_schemaPtr->grammarTable.count);
for (i=0, gr=g_schemaPtr->grammarTable.grammar; i<g_schemaPtr->grammarTable.count; i++, gr++) {
printf ("*** Grammar #%d : %d rules\n", i, gr->count);
for (j=0, rule=gr->rule; j<gr->count; j++, rule++) {
printGrammarRule(j, rule, g_schemaPtr);
}
}
}
errorCode processNextProduction(EXIStream* strm, SmallIndex* nonTermID_out, ContentHandler* handler, void* app_data)
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
unsigned int tmp_bits_val = 0;
unsigned char b = 0;
GrammarRule* currentRule;
DEBUG_MSG(INFO, DEBUG_GRAMMAR, (">Next production non-term-id: %u\n", (unsigned int) strm->context.currNonTermID));
if(strm->context.currNonTermID >= strm->gStack->grammar->count)
return INCONSISTENT_PROC_STATE;
if(IS_BUILT_IN_ELEM(strm->gStack->grammar->props)) // If the current grammar is build-in Element grammar ...
currentRule = (GrammarRule*) &((DynGrammarRule*) strm->gStack->grammar->rule)[strm->context.currNonTermID];
else
currentRule = &strm->gStack->grammar->rule[strm->context.currNonTermID];
#if DEBUG_GRAMMAR == ON
{
tmp_err_code = printGrammarRule(strm->context.currNonTermID, currentRule, strm->schema);
if(tmp_err_code != ERR_OK)
{
DEBUG_MSG(INFO, DEBUG_GRAMMAR, (">Error printing grammar rule\n"));
}
}
#endif
for(b = 0; b < 3; b++)
{
if(currentRule->part[b].count == 0) // No productions available with this length code
continue;
if(currentRule->part[b].bits == 0) // encoded with zero bits
return handleProduction(strm, currentRule, ¤tRule->part[b].prod[0], nonTermID_out, handler, app_data, b + 1);
tmp_err_code = decodeNBitUnsignedInteger(strm, currentRule->part[b].bits, &tmp_bits_val);
if(tmp_err_code != ERR_OK)
return tmp_err_code;
if(tmp_bits_val == currentRule->part[b].count) // The code has more parts
continue;
return handleProduction(strm, currentRule, ¤tRule->part[b].prod[currentRule->part[b].count - 1 - tmp_bits_val], nonTermID_out, handler, app_data, b + 1);
}
return tmp_err_code;
}
errorCode getEmptyTypeGrammar(EXIStream* strm, EXIGrammar* src, EXIGrammar** dest)
{
SmallIndex i;
Index p;
Index destProdIndx, partNum;
*dest = memManagedAllocate(&strm->memList, sizeof(EXIGrammar));
if(*dest == NULL)
return MEMORY_ALLOCATION_ERROR;
(*dest)->contentIndex = src->contentIndex;
(*dest)->count = src->contentIndex;
(*dest)->props = src->props;
(*dest)->rule = memManagedAllocate(&strm->memList, sizeof(GrammarRule)*((*dest)->count));
if((*dest)->rule == NULL)
return MEMORY_ALLOCATION_ERROR;
if(WITH_STRICT(strm->header.opts.enumOpt))
{
for(i = 0; i < (*dest)->count - 1; i++)
{
for(partNum = 0; partNum < 3; partNum++)
{
// Copy all productions in the rules less than contentIndex i.e. (*dest)->count - 1
// except the AT(xsi:type) and AT(xsi:nil)
(*dest)->rule[i].part[partNum].prod = memManagedAllocate(&strm->memList, sizeof(Production)*(src->rule[i].part[partNum].count));
if((*dest)->rule[i].part[partNum].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
destProdIndx = 0;
for(p = 0; p < src->rule[i].part[partNum].count; p++)
{
if(src->rule[i].part[partNum].prod[p].qnameId.uriId == XML_SCHEMA_INSTANCE_ID &&
(src->rule[i].part[partNum].prod[p].qnameId.lnId == XML_SCHEMA_INSTANCE_NIL_ID ||
src->rule[i].part[partNum].prod[p].qnameId.lnId == XML_SCHEMA_INSTANCE_TYPE_ID))
{
// In case of AT(xsi:type) and AT(xsi:nil) productions, exclude them
continue;
}
else
{
(*dest)->rule[i].part[partNum].prod[destProdIndx] = src->rule[i].part[partNum].prod[p];
destProdIndx++;
}
}
(*dest)->rule[i].part[partNum].count = destProdIndx;
(*dest)->rule[i].part[partNum].bits = getBitsNumber(destProdIndx - 1);
}
}
/* The last rule is an empty rule with a single EE production */
(*dest)->rule[(*dest)->count - 1].part[0].prod = static_prod_empty_part0;
(*dest)->rule[(*dest)->count - 1].part[0].bits = 0;
(*dest)->rule[(*dest)->count - 1].part[0].count = 1;
(*dest)->rule[(*dest)->count - 1].part[1].prod = NULL;
(*dest)->rule[(*dest)->count - 1].part[1].bits = 0;
(*dest)->rule[(*dest)->count - 1].part[1].count = 0;
(*dest)->rule[(*dest)->count - 1].part[2].prod = NULL;
(*dest)->rule[(*dest)->count - 1].part[2].bits = 0;
(*dest)->rule[(*dest)->count - 1].part[2].count = 0;
}
else
{ // STRICT FALSE mode
for(i = 0; i < (*dest)->count - 1; i++)
{
for(partNum = 0; partNum < 3; partNum++)
{
// Copy all productions in the rules less than contentIndex i.e. (*dest)->count - 1
// while taking into account that we do not need the Content2 index added during augmentation
(*dest)->rule[i].part[partNum].prod = memManagedAllocate(&strm->memList, sizeof(Production)*(src->rule[i].part[partNum].count));
if((*dest)->rule[i].part[partNum].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
destProdIndx = 0;
for(p = 0; p < src->rule[i].part[partNum].count; p++)
{
if(src->rule[i].part[partNum].prod[p].eventType == EVENT_AT_ALL ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_AT_QNAME ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_AT_URI ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_EE ||
(partNum > 0 &&
(src->rule[i].part[partNum].prod[p].eventType == EVENT_NS ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_SC)
)
)
{
(*dest)->rule[i].part[partNum].prod[destProdIndx] = src->rule[i].part[partNum].prod[p];
destProdIndx++;
}
else if(partNum > 0 &&
(src->rule[i].part[partNum].prod[p].eventType == EVENT_SE_ALL ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_CH ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_ER ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_CM ||
src->rule[i].part[partNum].prod[p].eventType == EVENT_PI))
{
(*dest)->rule[i].part[partNum].prod[destProdIndx] = src->rule[i].part[partNum].prod[p];
(*dest)->rule[i].part[partNum].prod[destProdIndx].nonTermID = (*dest)->count - 1;
destProdIndx++;
}
}
(*dest)->rule[i].part[partNum].count = destProdIndx;
}
(*dest)->rule[i].part[0].bits = getBitsNumber((*dest)->rule[i].part[0].count - 1 + ((*dest)->rule[i].part[1].count > 0));
(*dest)->rule[i].part[1].bits = getBitsNumber((*dest)->rule[i].part[1].count - 1 + ((*dest)->rule[i].part[2].count > 0));
(*dest)->rule[i].part[2].bits = getBitsNumber((*dest)->rule[i].part[2].count - 1);
}
/* The last rule is:
*
* NT-contentIndex-1 :
* EE 0
* SE (*) NT-contentIndex-1 1.0
* CH [untyped value] NT-contentIndex-1 1.1
* ER NT-contentIndex-1 1.2
* CM NT-contentIndex-1 1.3.0
* PI NT-contentIndex-1 1.3.1
* */
/* Part 1 */
(*dest)->rule[(*dest)->count - 1].part[0].prod = static_prod_empty_part0;
(*dest)->rule[(*dest)->count - 1].part[0].bits = 1;
(*dest)->rule[(*dest)->count - 1].part[0].count = 1;
{ /* Part 2 and 3 */
int part2count = 2;
int part3count = 0;
if(IS_PRESENT(strm->header.opts.preserve, PRESERVE_DTD))
part2count++;
if(IS_PRESENT(strm->header.opts.preserve, PRESERVE_COMMENTS))
part3count++;
if(IS_PRESENT(strm->header.opts.preserve, PRESERVE_PIS))
part3count++;
(*dest)->rule[(*dest)->count - 1].part[1].prod = memManagedAllocate(&strm->memList, sizeof(Production)*part2count);
if((*dest)->rule[(*dest)->count - 1].part[1].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
(*dest)->rule[(*dest)->count - 1].part[1].prod[part2count-1].eventType = EVENT_SE_ALL;
(*dest)->rule[(*dest)->count - 1].part[1].prod[part2count-1].nonTermID = (*dest)->count - 1;
(*dest)->rule[(*dest)->count - 1].part[1].prod[part2count-1].typeId = INDEX_MAX;
(*dest)->rule[(*dest)->count - 1].part[1].prod[part2count-2].eventType = EVENT_CH;
(*dest)->rule[(*dest)->count - 1].part[1].prod[part2count-2].nonTermID = (*dest)->count - 1;
(*dest)->rule[(*dest)->count - 1].part[1].prod[part2count-2].typeId = INDEX_MAX;
if(IS_PRESENT(strm->header.opts.preserve, PRESERVE_DTD))
{
(*dest)->rule[(*dest)->count - 1].part[1].prod[0].eventType = EVENT_ER;
(*dest)->rule[(*dest)->count - 1].part[1].prod[0].nonTermID = (*dest)->count - 1;
(*dest)->rule[(*dest)->count - 1].part[1].prod[0].typeId = INDEX_MAX;
}
(*dest)->rule[(*dest)->count - 1].part[1].bits = getBitsNumber(part2count - 1 + (part3count > 0));
(*dest)->rule[(*dest)->count - 1].part[1].count = part2count;
if(part3count > 0)
{
(*dest)->rule[(*dest)->count - 1].part[2].prod = memManagedAllocate(&strm->memList, sizeof(Production)*part3count);
if((*dest)->rule[(*dest)->count - 1].part[2].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
if(IS_PRESENT(strm->header.opts.preserve, PRESERVE_COMMENTS))
{
(*dest)->rule[(*dest)->count - 1].part[2].prod[part3count - 1].eventType = EVENT_CM;
(*dest)->rule[(*dest)->count - 1].part[2].prod[part3count - 1].nonTermID = (*dest)->count - 1;
(*dest)->rule[(*dest)->count - 1].part[2].prod[part3count - 1].typeId = INDEX_MAX;
}
if(IS_PRESENT(strm->header.opts.preserve, PRESERVE_PIS))
{
(*dest)->rule[(*dest)->count - 1].part[2].prod[0].eventType = EVENT_PI;
(*dest)->rule[(*dest)->count - 1].part[2].prod[0].nonTermID = (*dest)->count - 1;
(*dest)->rule[(*dest)->count - 1].part[2].prod[0].typeId = INDEX_MAX;
}
(*dest)->rule[(*dest)->count - 1].part[2].bits = part3count > 1;
(*dest)->rule[(*dest)->count - 1].part[2].count = part3count;
}
else
{
(*dest)->rule[(*dest)->count - 1].part[2].prod = NULL;
(*dest)->rule[(*dest)->count - 1].part[2].bits = 0;
(*dest)->rule[(*dest)->count - 1].part[2].count = 0;
}
}
}
#if DEBUG_GRAMMAR == ON
{
unsigned int r;
DEBUG_MSG(INFO, DEBUG_GRAMMAR, (">Empty grammar:\n"));
for(r = 0; r < (*dest)->count; r++)
{
if(printGrammarRule(r, &(*dest)->rule[r], strm->schema) != ERR_OK)
DEBUG_MSG(INFO, DEBUG_GRAMMAR, (">Error printing grammar rule\n"));
}
}
#endif
return ERR_OK;
}
