static void
CcBitArray_RandomSet(CcBitArray_t * self)
{
long int rnd;
int idx, bit, numbits = CcBitArray_getCount(self);
for (idx = 0; idx < numbits; idx += 16) {
rnd = rand();
for (bit = 0; bit < 16 && idx + bit < self->numbits; ++bit)
if ((rnd & (1 << bit))) CcBitArray_Set(self, idx + bit, 1);
else CcBitArray_Set(self, idx + bit, 0);
}
}
static void
CcSyntax_CompFollowSets(CcSyntax_t * self)
{
CcSymbolNT_t * sym; CcArrayListIter_t iter;
CcSymbolTable_t * symtab = &self->globals->symtab;
CcArrayList_t * tarr = &symtab->terminals;
CcArrayList_t * ntarr = &symtab->nonterminals;
for (sym = (CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
sym->follow = CcBitArray(&sym->followSpace, tarr->Count);
sym->nts = CcBitArray(&sym->ntsSpace, ntarr->Count);
}
CcBitArray_Set(((CcSymbolNT_t *)self->gramSy)->follow,
self->eofSy->kind, TRUE);
self->visited = CcBitArray(&self->visitedSpace, self->base.nodes.Count);
for (sym =(CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
self->curSy = (CcSymbol_t *)sym;
CcSyntax_CompFollow(self, sym->graph);
}
CcBitArray_Destruct(self->visited); self->visited = NULL;
for (sym =(CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
self->visited = CcBitArray(&self->visitedSpace, ntarr->Count);
self->curSy = (CcSymbol_t *)sym;
CcSyntax_Complete(self, sym);
CcBitArray_Destruct(self->visited); self->visited = NULL;
}
}
static CcsBool_t
CcSyntax_AllNtToTerm(CcSyntax_t * self)
{
CcBitArray_t mark;
CcSymbolNT_t * sym; CcArrayListIter_t iter;
CcsBool_t changed, ok = TRUE;
CcSymbolTable_t * symtab = &self->globals->symtab;
CcArrayList_t * ntarr = &symtab->nonterminals;
CcBitArray(&mark, ntarr->Count);
do {
changed = FALSE;
for (sym = (CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
if (!CcBitArray_Get(&mark, sym->base.kind) &&
CcSyntax_IsTerm(self, sym->graph, &mark)) {
CcBitArray_Set(&mark, sym->base.kind, TRUE);
changed = TRUE;
}
}
} while (changed);
for (sym = (CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
if (!CcBitArray_Get(&mark, sym->base.kind)) {
ok = FALSE;
CcsErrorPool_Error(self->globals->errpool, NULL,
" %s cannot be derived to terminals",
sym->base.name);
}
}
CcBitArray_Destruct(&mark);
return ok;
}
static void
CcSyntax_First0(CcSyntax_t * self, CcBitArray_t * ret,
CcNode_t * p, CcBitArray_t * mark)
{
CcBitArray_t fs0;
CcSymbolTable_t * symtab = &self->globals->symtab;
CcBitArray(ret, symtab->terminals.Count);
while (p != NULL && !CcBitArray_Get(mark, p->base.index)) {
CcBitArray_Set(mark, p->base.index, TRUE);
if (p->base.type == node_nt) {
CcNodeNT_t * p0 = (CcNodeNT_t *)p;
CcSymbolNT_t * sym = (CcSymbolNT_t *)p0->sym;
if (sym->firstReady) {
CcBitArray_Or(ret, sym->first);
} else {
CcSyntax_First0(self, &fs0, sym->graph, mark);
CcBitArray_Or(ret, &fs0);
CcBitArray_Destruct(&fs0);
}
} else if (p->base.type == node_t) {
CcNodeT_t * p0 = (CcNodeT_t *)p;
CcBitArray_Set(ret, p0->sym->kind, TRUE);
} else if (p->base.type == node_wt) {
CcNodeWT_t * p0 = (CcNodeWT_t *)p;
CcBitArray_Set(ret, p0->sym->kind, TRUE);
} else if (p->base.type == node_any) {
CcNodeANY_t * p0 = (CcNodeANY_t *)p;
CcBitArray_Or(ret, p0->set);
} else if (p->base.type == node_alt) {
CcSyntax_First0(self, &fs0, p->sub, mark);
CcBitArray_Or(ret, &fs0);
CcBitArray_Destruct(&fs0);
CcSyntax_First0(self, &fs0, p->down, mark);
CcBitArray_Or(ret, &fs0);
CcBitArray_Destruct(&fs0);
} else if (p->base.type == node_iter || p->base.type == node_opt) {
CcSyntax_First0(self, &fs0, p->sub, mark);
CcBitArray_Or(ret, &fs0);
CcBitArray_Destruct(&fs0);
}
if (!CcNode_DelNode(p)) break;
p = p->next;
}
}
static void
CcSyntax_Complete(CcSyntax_t * self, CcSymbolNT_t * sym)
{
CcSymbolNT_t * s; CcArrayListIter_t iter;
CcSymbolTable_t * symtab = &self->globals->symtab;
CcArrayList_t * ntarr = &symtab->nonterminals;
if (CcBitArray_Get(self->visited, sym->base.kind)) return;
CcBitArray_Set(self->visited, sym->base.kind, TRUE);
for (s = (CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
s; s = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
if (CcBitArray_Get(sym->nts, s->base.kind)) {
CcSyntax_Complete(self, s);
CcBitArray_Or(sym->follow, s->follow);
if ((CcSymbol_t *)sym == self->curSy)
CcBitArray_Set(sym->nts, s->base.kind, FALSE);
}
}
}
void
CcXmlSpec_SetOption(CcXmlSpec_t * self, const CcsToken_t * token)
{
CcsXmlSpecOption_t option;
for (option = XSO_UnknownTag; option < XSO_SIZE; ++option)
if (!strcmp(token->val, CcsXmlSpecOptionNames[option])) {
CcBitArray_Set(&self->options, option, TRUE);
return;
}
CcsErrorPool_Error(self->globals->errpool, &token->loc,
"Unrecognized option '%s' encountered.", token->val);
}
static void
CcSyntax_CompSync(CcSyntax_t * self, CcNode_t * p)
{
CcNodeSYNC_t * syncp;
while (p != NULL && !CcBitArray_Get(self->visited, p->base.index)) {
CcBitArray_Set(self->visited, p->base.index, TRUE);
if (p->base.type == node_sync) {
syncp = (CcNodeSYNC_t *)p;
CcsAssert(syncp->set == NULL);
CcSyntax_Expected(self, &syncp->setSpace, p->next, self->curSy);
syncp->set = &syncp->setSpace;
CcBitArray_Set(syncp->set, self->eofSy->kind, TRUE);
CcBitArray_Or(self->allSyncSets, syncp->set);
} else if (p->base.type == node_alt) {
CcSyntax_CompSync(self, p->sub);
CcSyntax_CompSync(self, p->down);
} else if (p->base.type == node_opt || p->base.type == node_iter) {
CcSyntax_CompSync(self, p->sub);
}
p = p->next;
}
}
void
CcSyntax_SetupAnys(CcSyntax_t * self)
{
CcNode_t * p; CcNodeANY_t * pany; CcArrayListIter_t iter;
CcSymbolTable_t * symtab = &self->globals->symtab;
for (p = (CcNode_t *)CcArrayList_First(&self->base.nodes, &iter);
p; p = (CcNode_t *)CcArrayList_Next(&self->base.nodes, &iter)) {
if (p->base.type != node_any) continue;
pany = (CcNodeANY_t *)p;
pany->set = &pany->setSpace;
CcBitArray1(pany->set, symtab->terminals.Count);
CcBitArray_Set(pany->set, self->eofSy->kind, FALSE);
}
}
static void
CcSyntax_CompFollow(CcSyntax_t * self, CcNode_t * p)
{
CcBitArray_t s;
CcSymbolNT_t * sym;
while (p != NULL && !CcBitArray_Get(self->visited, p->base.index)) {
CcBitArray_Set(self->visited, p->base.index, TRUE);
if (p->base.type == node_nt) {
CcSyntax_First(self, &s, p->next);
sym = (CcSymbolNT_t *)((CcNodeNT_t *)p)->sym;
CcBitArray_Or(sym->follow, &s);
CcBitArray_Destruct(&s);
if (CcNode_DelGraph(p->next))
CcBitArray_Set(sym->nts, self->curSy->kind, TRUE);
} else if (p->base.type == node_opt || p->base.type == node_iter) {
CcSyntax_CompFollow(self, p->sub);
} else if (p->base.type == node_alt) {
CcSyntax_CompFollow(self, p->sub);
CcSyntax_CompFollow(self, p->down);
}
p = p->next;
}
}
static void
GetSingles(CcBitArray_t * singles, CcNode_t * p)
{
if (p == NULL) return; /* end of graph */
if (p->base.type == node_nt) {
if (p->up || CcNode_DelGraph(p->next))
CcBitArray_Set(singles, ((CcNodeNT_t *)p)->sym->kind, TRUE);
} else if (p->base.type == node_alt || p->base.type == node_iter
|| p->base.type == node_opt) {
if (p->up || CcNode_DelGraph(p->next)) {
GetSingles(singles, p->sub);
if (p->base.type == node_alt) GetSingles(singles, p->down);
}
}
if (p->up && CcNode_DelNode(p)) GetSingles(singles, p->next);
}
static void
CcSyntax_CompSyncSets(CcSyntax_t * self)
{
CcSymbolNT_t * sym; CcArrayListIter_t iter;
CcSymbolTable_t * symtab = &self->globals->symtab;
CcArrayList_t * ntarr = &symtab->nonterminals;
self->allSyncSets = CcBitArray(&self->allSyncSetsSpace,
symtab->terminals.Count);
CcBitArray_Set(self->allSyncSets, self->eofSy->kind, TRUE);
self->visited = CcBitArray(&self->visitedSpace, self->base.nodes.Count);
for (sym = (CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
self->curSy = (CcSymbol_t *)sym;
CcSyntax_CompSync(self, sym->graph);
}
CcBitArray_Destruct(self->visited); self->visited = NULL;
}
static CcsBool_t
CcSyntax_AllNtReached(CcSyntax_t * self)
{
int idx; CcSymbol_t * sym;
CcsBool_t ok = TRUE;
CcSymbolTable_t * symtab = &self->globals->symtab;
self->visited = CcBitArray(&self->visitedSpace,
symtab->nonterminals.Count);
CcBitArray_Set(self->visited, self->gramSy->kind, TRUE);
CcSyntax_MarkReachedNts(self, ((CcSymbolNT_t *)self->gramSy)->graph);
for (idx = 0; idx < symtab->nonterminals.Count; ++idx) {
sym = (CcSymbol_t *)CcArrayList_Get(&symtab->nonterminals, idx);
if (!CcBitArray_Get(self->visited, sym->kind)) {
ok = FALSE;
CcsErrorPool_Error(self->globals->errpool, NULL,
" '%s' cannot be reached", sym->name);
}
}
return ok;
}
static void
CcSyntax_MarkReachedNts(CcSyntax_t * self, CcNode_t * p)
{
while (p != NULL) {
if (p->base.type == node_nt) {
CcNodeNT_t * p0 = (CcNodeNT_t *)p;
CcSymbolNT_t * sym = (CcSymbolNT_t *)p0->sym;
if (!CcBitArray_Get(self->visited, sym->base.kind)) {
/* new nt reached */
CcBitArray_Set(self->visited, sym->base.kind, TRUE);
CcSyntax_MarkReachedNts(self, sym->graph);
}
} else if (p->base.type == node_alt || p->base.type == node_iter
|| p->base.type == node_opt) {
CcSyntax_MarkReachedNts(self, p->sub);
if (p->base.type == node_alt)
CcSyntax_MarkReachedNts(self, p->down);
}
if (p->up) break;
p = p->next;
}
}
