unsigned int getBitsFirstPartCode(EXIOptions opts, EXIGrammar* grammar, GrammarRule* currentRule, SmallIndex currentRuleIndx, boolean isNilType)
{
unsigned char secondLevelExists = 0;
if(IS_BUILT_IN_ELEM(grammar->props))
{
// Built-in element grammar
// There is always a second level production
return getBitsNumber(currentRule->pCount);
}
else if(IS_DOCUMENT(grammar->props))
{
// Document grammar
if(IS_PRESERVED(opts.preserve, PRESERVE_COMMENTS) || IS_PRESERVED(opts.preserve, PRESERVE_PIS))
secondLevelExists = 1;
else if(currentRuleIndx == 0 && IS_PRESERVED(opts.preserve, PRESERVE_DTD))
secondLevelExists = 1;
return getBitsNumber(currentRule->pCount - 1 + secondLevelExists);
}
else if(IS_FRAGMENT(grammar->props))
{
// Fragment grammar
if(IS_PRESERVED(opts.preserve, PRESERVE_COMMENTS) || IS_PRESERVED(opts.preserve, PRESERVE_PIS))
secondLevelExists = 1;
return getBitsNumber(currentRule->pCount - 1 + secondLevelExists);
}
else
{
// Schema-informed element/type grammar
Index prodCount;
if(isNilType == FALSE)
prodCount = currentRule->pCount;
else
prodCount = RULE_GET_AT_COUNT(currentRule->meta) + RULE_CONTAIN_EE(currentRule->meta);
if(WITH_STRICT(opts.enumOpt))
{
// Strict mode
if(isNilType == FALSE && currentRuleIndx == 0 && (HAS_NAMED_SUB_TYPE_OR_UNION(grammar->props) || IS_NILLABLE(grammar->props)))
secondLevelExists = 1;
return getBitsNumber(prodCount - 1 + secondLevelExists);
}
else // Non-strict mode
{
// There is always a second level production
return getBitsNumber(prodCount);
}
}
}
errorCode convertProtoGrammar(AllocList* memlist, ProtoGrammar* pg, EXIGrammar* exiGrammar)
{
Index ruleIter;
Index prodIter;
exiGrammar->props = 0;
SET_SCHEMA(exiGrammar->props);
exiGrammar->contentIndex = pg->contentIndex;
exiGrammar->count = pg->count;
// #DOCUMENT# one more rule slot is created as it can be needed for addUndeclaredProductions
exiGrammar->rule = (GrammarRule*) memManagedAllocate(memlist, sizeof(GrammarRule)*(pg->count + 1));
if(exiGrammar->rule == NULL)
return MEMORY_ALLOCATION_ERROR;
for(ruleIter = 0; ruleIter < pg->count; ruleIter++)
{
/* Initialize Part 2 */
exiGrammar->rule[ruleIter].part[1].prod = NULL;
exiGrammar->rule[ruleIter].part[1].count = 0;
exiGrammar->rule[ruleIter].part[1].bits = 0;
/* Initialize Part 3 */
exiGrammar->rule[ruleIter].part[2].prod = NULL;
exiGrammar->rule[ruleIter].part[2].count = 0;
exiGrammar->rule[ruleIter].part[2].bits = 0;
/* Part 1 */
exiGrammar->rule[ruleIter].part[0].prod = (Production*) memManagedAllocate(memlist, sizeof(Production)*pg->rule[ruleIter].count);
if(exiGrammar->rule[ruleIter].part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
exiGrammar->rule[ruleIter].part[0].count = pg->rule[ruleIter].count;
exiGrammar->rule[ruleIter].part[0].bits = getBitsNumber(pg->rule[ruleIter].count - 1);
for(prodIter = 0; prodIter < pg->rule[ruleIter].count; prodIter++)
{
exiGrammar->rule[ruleIter].part[0].prod[prodIter] = pg->rule[ruleIter].prod[prodIter];
}
}
return ERR_OK;
}
errorCode insertZeroProduction(DynGrammarRule* rule, EventType eventType, SmallIndex nonTermID, QNameID* qnameId)
{
if(rule->part[0].count == rule->part0Dimension) // The dynamic array rule->prods[0] needs to be resized
{
void* ptr = EXIP_REALLOC(rule->part[0].prod, sizeof(Production)*(rule->part0Dimension + DEFAULT_PROD_ARRAY_DIM));
if(ptr == NULL)
return MEMORY_ALLOCATION_ERROR;
rule->part[0].prod = ptr;
rule->part0Dimension += DEFAULT_PROD_ARRAY_DIM;
}
rule->part[0].prod[rule->part[0].count].eventType = eventType;
rule->part[0].prod[rule->part[0].count].typeId = INDEX_MAX;
rule->part[0].prod[rule->part[0].count].nonTermID = nonTermID;
rule->part[0].prod[rule->part[0].count].qnameId = *qnameId;
rule->part[0].count += 1;
rule->part[0].bits = getBitsNumber(rule->part[0].count - 1 + (rule->part[1].count + rule->part[2].count > 0));
return ERR_OK;
}
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;
}
errorCode createFragmentGrammar(EXIPSchema* schema, QNameID* elQnameArr, Index qnameCount)
{
GrammarRule* tmp_rule;
schema->docGrammar.count = DEF_FRAG_GRAMMAR_RULE_NUMBER;
schema->docGrammar.props = 0;
schema->docGrammar.contentIndex = 0;
schema->docGrammar.rule = (GrammarRule*) memManagedAllocate(&schema->memList, sizeof(GrammarRule)*DEF_FRAG_GRAMMAR_RULE_NUMBER);
if(schema->docGrammar.rule == NULL)
return MEMORY_ALLOCATION_ERROR;
/* Rule for Fragment */
/* Fragment : SD FragmentContent 0 */
tmp_rule = &schema->docGrammar.rule[GR_FRAGMENT];
/* Part 1 */
tmp_rule->part[0].prod = static_prod_start_doc_part0;
tmp_rule->part[0].count = 1;
tmp_rule->part[0].bits = 0;
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
/* Rule for Fragment content */
tmp_rule = &schema->docGrammar.rule[GR_FRAGMENT_CONTENT];
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
/* Part 1 */
if(elQnameArr != NULL) // Creates Schema Informed Grammar
{
unsigned int e = 0;
Index tmp_code1;
SET_SCHEMA(schema->docGrammar.props);
tmp_code1 = qnameCount + 2;
tmp_rule->part[0].prod = (Production*) memManagedAllocate(&schema->memList, sizeof(Production)*tmp_code1);
if(tmp_rule->part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/*
* FragmentContent :
* SE (F-0) FragmentContent 0
* SE (F-1) FragmentContent 1
* ⋮ ⋮ ⋮
* SE (F-n−1) FragmentContent n-1
* // SE (*) FragmentContent n // This is created as part of the Build-In grammar further on
* // ED n+1 // This is created as part of the Build-In grammar further on
*/
for(e = 0; e < qnameCount; e++)
{
tmp_rule->part[0].prod[qnameCount - e].eventType = EVENT_SE_QNAME;
tmp_rule->part[0].prod[qnameCount - e].typeId = GET_LN_URI_QNAME(schema->uriTable, elQnameArr[e]).elemGrammar;
tmp_rule->part[0].prod[qnameCount - e].nonTermID = GR_FRAGMENT_CONTENT;
tmp_rule->part[0].prod[qnameCount - e].qnameId = elQnameArr[e];
}
tmp_rule->part[0].count = tmp_code1;
tmp_rule->part[0].bits = getBitsNumber(tmp_code1 - 1);
}
else
{
tmp_rule->part[0].prod = (Production*) memManagedAllocate(&schema->memList, sizeof(Production)*2);
if(tmp_rule->part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/* Productions further on... */
tmp_rule->part[0].count = 2;
tmp_rule->part[0].bits = 1;
}
/*
* FragmentContent :
* SE (*) FragmentContent 0
* ED 1
*/
tmp_rule->part[0].prod[0].eventType = EVENT_ED;
tmp_rule->part[0].prod[0].typeId = INDEX_MAX;
tmp_rule->part[0].prod[0].nonTermID = GR_VOID_NON_TERMINAL;
tmp_rule->part[0].prod[0].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[0].prod[0].qnameId.lnId = INDEX_MAX;
tmp_rule->part[0].prod[1].eventType = EVENT_SE_ALL;
tmp_rule->part[0].prod[1].typeId = INDEX_MAX;
tmp_rule->part[0].prod[1].nonTermID = GR_FRAGMENT_CONTENT;
tmp_rule->part[0].prod[1].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[0].prod[1].qnameId.lnId = INDEX_MAX;
return ERR_OK;
}
errorCode createDocGrammar(EXIPSchema* schema, QNameID* elQnameArr, Index qnameCount)
{
GrammarRule* tmp_rule;
schema->docGrammar.count = DEF_DOC_GRAMMAR_RULE_NUMBER;
schema->docGrammar.props = 0;
schema->docGrammar.contentIndex = 0;
schema->docGrammar.rule = (GrammarRule*) memManagedAllocate(&schema->memList, sizeof(GrammarRule)*DEF_DOC_GRAMMAR_RULE_NUMBER);
if(schema->docGrammar.rule == NULL)
return MEMORY_ALLOCATION_ERROR;
/* Rule for Document */
/*
* Document :
* SD DocContent 0
*/
tmp_rule = &schema->docGrammar.rule[GR_DOCUMENT];
/* Part 1 */
tmp_rule->part[0].prod = static_prod_start_doc_part0;
tmp_rule->part[0].count = 1;
tmp_rule->part[0].bits = 0;
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
/* Rule for document content */
tmp_rule = &schema->docGrammar.rule[GR_DOC_CONTENT];
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
/* Part 1 */
if(elQnameArr != NULL) // Creates Schema Informed Grammar
{
unsigned int e = 0;
Index tmp_code1;
SET_SCHEMA(schema->docGrammar.props);
tmp_code1 = qnameCount + 1;
tmp_rule->part[0].prod = (Production*) memManagedAllocate(&schema->memList, sizeof(Production)*tmp_code1);
if(tmp_rule->part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/*
* DocContent :
* SE (G-0) DocEnd 0
* SE (G-1) DocEnd 1
* ⋮ ⋮ ⋮
* SE (G-n−1) DocEnd n-1
* // SE (*) DocEnd n // This is created as part of the Built-In grammar further on
*/
for(e = 0; e < qnameCount; e++)
{
tmp_rule->part[0].prod[qnameCount - e].eventType = EVENT_SE_QNAME;
tmp_rule->part[0].prod[qnameCount - e].typeId = GET_LN_URI_QNAME(schema->uriTable, elQnameArr[e]).elemGrammar;
tmp_rule->part[0].prod[qnameCount - e].nonTermID = GR_DOC_END;
tmp_rule->part[0].prod[qnameCount - e].qnameId = elQnameArr[e];
}
tmp_rule->part[0].count = tmp_code1;
tmp_rule->part[0].bits = getBitsNumber(qnameCount);
}
else
{
tmp_rule->part[0].prod = (Production*) memManagedAllocate(&schema->memList, sizeof(Production));
if(tmp_rule->part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
tmp_rule->part[0].count = 1;
tmp_rule->part[0].bits = 0;
}
/*
* DocContent :
* SE (*) DocEnd 0
*/
tmp_rule->part[0].prod[0].eventType = EVENT_SE_ALL;
tmp_rule->part[0].prod[0].typeId = INDEX_MAX;
tmp_rule->part[0].prod[0].nonTermID = GR_DOC_END;
tmp_rule->part[0].prod[0].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[0].prod[0].qnameId.lnId = INDEX_MAX;
/* Rule for Document end */
/*
* DocEnd :
* ED 0
*/
tmp_rule = &schema->docGrammar.rule[GR_DOC_END];
/* Part 1 */
tmp_rule->part[0].prod = static_prod_doc_end_part0;
tmp_rule->part[0].count = 1;
tmp_rule->part[0].bits = 0;
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
return ERR_OK;
}
errorCode createBuiltInElementGrammar(EXIGrammar* elementGrammar, EXIStream* strm)
{
unsigned int tmp_code1 = 0; // the number of productions with event codes with length 1
unsigned int tmp_code2 = 0; // the number of productions with event codes with length 2
unsigned int tmp_code3 = 0; // the number of productions with event codes with length 3
DynGrammarRule* tmp_rule;
unsigned int p = 1;
elementGrammar->count = DEF_ELEMENT_GRAMMAR_RULE_NUMBER;
elementGrammar->props = 0;
SET_BUILT_IN_ELEM(elementGrammar->props);
SET_AUGMENTED(elementGrammar->props);
elementGrammar->contentIndex = 0;
elementGrammar->rule = (GrammarRule*) EXIP_MALLOC(sizeof(DynGrammarRule)*DEF_ELEMENT_GRAMMAR_RULE_NUMBER);
if(elementGrammar->rule == NULL)
return MEMORY_ALLOCATION_ERROR;
/* Rule for StartTagContent */
/* StartTagContent :
* EE 0.0
* AT (*) StartTagContent 0.1
* NS StartTagContent 0.2
* SC Fragment 0.3
* SE (*) ElementContent 0.4
* CH ElementContent 0.5
* ER ElementContent 0.6
* CM ElementContent 0.7.0
* PI ElementContent 0.7.1
*/
tmp_rule = &((DynGrammarRule*) elementGrammar->rule)[GR_START_TAG_CONTENT];
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
tmp_code1 = 0;
tmp_code2 = 4;
tmp_code3 = 0;
/* Part 1 */
tmp_rule->part[0].prod = (Production*) EXIP_MALLOC(sizeof(Production)*DEFAULT_PROD_ARRAY_DIM);
if(tmp_rule->part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/* The part 1 productions get added later... */
tmp_rule->part[0].count = 0;
tmp_rule->part[0].bits = 0;
tmp_rule->part0Dimension = DEFAULT_PROD_ARRAY_DIM;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_PREFIXES))
tmp_code2 += 1;
if(WITH_SELF_CONTAINED(strm->header.opts.enumOpt))
tmp_code2 += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_DTD))
tmp_code2 += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_COMMENTS))
tmp_code3 += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_PIS))
tmp_code3 += 1;
/* Part 2 */
tmp_rule->part[1].prod = (Production*) EXIP_MALLOC(sizeof(Production)*tmp_code2);
if(tmp_rule->part[1].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/* EE 0.0 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_EE;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_VOID_NON_TERMINAL;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
/* AT (*) StartTagContent 0.1 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_AT_ALL;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_START_TAG_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_PREFIXES))
{
/* NS StartTagContent 0.2 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_NS;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_START_TAG_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
}
if(WITH_SELF_CONTAINED(strm->header.opts.enumOpt))
{
/* SC Fragment 0.3 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_SC;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_FRAGMENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
}
/* SE (*) ElementContent 0.2 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_SE_ALL;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
/* CH ElementContent 0.3 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_CH;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_DTD))
{
/* ER ElementContent 0.6 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_ER;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
}
tmp_rule->part[1].count = tmp_code2;
tmp_rule->part[1].bits = getBitsNumber(tmp_code2 - 1 + (tmp_code3 > 0));
/* Part 3 */
if(tmp_code3 > 0)
{
p = 1;
tmp_rule->part[2].prod = (Production*) EXIP_MALLOC(sizeof(Production)*tmp_code3);
if(tmp_rule->part[2].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_COMMENTS))
{
/* CM ElementContent 0.7.0 */
tmp_rule->part[2].prod[tmp_code3-p].eventType = EVENT_CM;
tmp_rule->part[2].prod[tmp_code3-p].typeId = INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.lnId = INDEX_MAX;
p += 1;
}
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_PIS))
{
/* PI ElementContent 0.7.1 */
tmp_rule->part[2].prod[tmp_code3-p].eventType = EVENT_PI;
tmp_rule->part[2].prod[tmp_code3-p].typeId = INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.lnId = INDEX_MAX;
}
tmp_rule->part[2].count = tmp_code3;
tmp_rule->part[2].bits = tmp_code3 > 1;
}
p = 1;
/* Rule for ElementContent */
/* ElementContent :
* EE 0
* SE (*) ElementContent 1.0
* CH ElementContent 1.1
* ER ElementContent 1.2
* CM ElementContent 1.3.0
* PI ElementContent 1.3.1
*/
tmp_rule = &((DynGrammarRule*) elementGrammar->rule)[GR_ELEMENT_CONTENT];
/* Initialize Part 2 */
tmp_rule->part[1].prod = NULL;
tmp_rule->part[1].count = 0;
tmp_rule->part[1].bits = 0;
/* Initialize Part 3 */
tmp_rule->part[2].prod = NULL;
tmp_rule->part[2].count = 0;
tmp_rule->part[2].bits = 0;
tmp_code1 = 1;
tmp_code2 = 2;
tmp_code3 = 0;
/* Part 1 */
tmp_rule->part[0].prod = (Production*) EXIP_MALLOC(sizeof(Production)*DEFAULT_PROD_ARRAY_DIM);
if(tmp_rule->part[0].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/* EE 0 */
tmp_rule->part[0].prod[0].eventType = EVENT_EE;
tmp_rule->part[0].prod[0].typeId = INDEX_MAX;
tmp_rule->part[0].prod[0].nonTermID = GR_VOID_NON_TERMINAL;
tmp_rule->part[0].prod[0].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[0].prod[0].qnameId.lnId = INDEX_MAX;
tmp_rule->part[0].count = 1;
tmp_rule->part[0].bits = 1;
tmp_rule->part0Dimension = DEFAULT_PROD_ARRAY_DIM;
/* More part 1 productions get added later... */
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_DTD))
tmp_code2 += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_COMMENTS))
tmp_code3 += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_PIS))
tmp_code3 += 1;
/* Part 2 */
tmp_rule->part[1].prod = (Production*) EXIP_MALLOC(sizeof(Production)*tmp_code2);
if(tmp_rule->part[1].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
/* SE (*) ElementContent 1.0 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_SE_ALL;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
/* CH ElementContent 1.1 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_CH;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
p += 1;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_DTD))
{
/* ER ElementContent 1.2 */
tmp_rule->part[1].prod[tmp_code2-p].eventType = EVENT_ER;
tmp_rule->part[1].prod[tmp_code2-p].typeId = INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[1].prod[tmp_code2-p].qnameId.lnId = INDEX_MAX;
}
tmp_rule->part[1].count = tmp_code2;
tmp_rule->part[1].bits = 1 + ((tmp_code2 - 2 + tmp_code3) > 0);
/* Part 3 */
if(tmp_code3 > 0)
{
p = 1;
tmp_rule->part[2].prod = (Production*) EXIP_MALLOC(sizeof(Production)*tmp_code3);
if(tmp_rule->part[2].prod == NULL)
return MEMORY_ALLOCATION_ERROR;
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_COMMENTS))
{
/* CM ElementContent 1.3.0 */
tmp_rule->part[2].prod[tmp_code3-p].eventType = EVENT_CM;
tmp_rule->part[2].prod[tmp_code3-p].typeId = INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.lnId = INDEX_MAX;
p += 1;
}
if(IS_PRESERVED(strm->header.opts.preserve, PRESERVE_PIS))
{
/* PI ElementContent 1.3.1 */
tmp_rule->part[2].prod[tmp_code3-p].eventType = EVENT_PI;
tmp_rule->part[2].prod[tmp_code3-p].typeId = INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].nonTermID = GR_ELEMENT_CONTENT;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.uriId = SMALL_INDEX_MAX;
tmp_rule->part[2].prod[tmp_code3-p].qnameId.lnId = INDEX_MAX;
}
tmp_rule->part[2].count = tmp_code3;
tmp_rule->part[2].bits = tmp_code3 > 1;
}
return ERR_OK;
}
