void
CcXmlSpecData_Destruct(CcXmlSpecData_t * self, size_t num)
{
CcXmlSpecData_t * cur;
for (cur = self; cur - self < num; ++cur) CcFree(cur->name);
CcFree(self);
}
static void
CcXmlData_Destruct(CcObject_t * self)
{
CcXmlData_t * ccself = (CcXmlData_t *)self;
if (ccself->name) CcFree(ccself->name);
if (ccself->tokenName) CcFree(ccself->tokenName);
CcObject_Destruct(self);
}
void
CcSyntax_Destruct(CcSyntax_t * self)
{
CcArrayList_Destruct(&self->errors);
if (self->allSyncSets) CcBitArray_Destruct(self->allSyncSets);
if (self->visited) CcBitArray_Destruct(self->visited);
if (self->grammarPrefix) CcFree(self->grammarPrefix);
if (self->schemeName) CcFree(self->schemeName);
if (self->destructor) CcsPosition_Destruct(self->destructor);
if (self->constructor) CcsPosition_Destruct(self->constructor);
if (self->members) CcsPosition_Destruct(self->members);
CcEBNF_Destruct(&self->base);
}
static void
CcString_Destruct(CcObject_t * self)
{
CcString_t * ccself = (CcString_t *)self;
CcFree(ccself->value);
CcObject_Destruct(self);
}
static CcsBool_t
CSOS_InitSet(CcCSharpBaseOutputScheme_t * self, CcOutput_t * output)
{
char * setstr; int setlen, index;
const CcBitArray_t * cur;
setlen = self->base.globals->symtab.terminals.Count;
setstr = CcMalloc(setlen + 1); setstr[setlen] = 0;
if (setlen > 4) {
for (index = 0; index < setlen; ++index)
if (index == 0) setstr[index] = '*';
else setstr[index] = index % 5 == 0 ? '0' + index % 10 : ' ';
CcPrintfIL(output, "/%s */", setstr);
}
for (cur = self->symSet.start; cur < self->symSet.used; ++cur) {
CcsAssert(setlen == CcBitArray_getCount(cur));
for (index = 0; index < setlen; ++index)
setstr[index] = CcBitArray_Get(cur, index) ? '*' : '.';
CcPrintfIL(output, "\"%s.\"%c /* %d */", setstr,
cur < self->symSet.used - 1 ? ',' : ' ',
cur - self->symSet.start);
}
CcFree(setstr);
return TRUE;
}
static CcsBool_t
CSOS_SynErrors(CcCSharpBaseOutputScheme_t * self, CcOutput_t * output)
{
CcArrayListIter_t iter; char * str;
const CcSyntaxError_t * synerr;
const CcArrayList_t * errors = &self->base.globals->syntax.errors;
for (synerr = (const CcSyntaxError_t *)CcArrayList_FirstC(errors, &iter);
synerr;
synerr = (const CcSyntaxError_t *)CcArrayList_NextC(errors, &iter)) {
CcPrintfI(output, "case %d: s = \"", synerr->base.index);
str = CcEscape(synerr->sym->name);
switch (synerr->type) {
case cet_t:
CcPrintf(output, "\\\"\" + %s + \"\\\" expected", str);
break;
case cet_alt:
CcPrintf(output,
"this symbol not expected in \\\"\" + %s + \"\\\"", str);
break;
case cet_sync:
CcPrintf(output, "invalid \\\"\" + %s + \"\\\"", str);
break;
}
CcFree(str);
CcPrintfL(output, "\"; break;");
}
return TRUE;
}
void
CcSyntaxSymSet_Destruct(CcSyntaxSymSet_t * self)
{
CcBitArray_t * cur;
for (cur = self->start; cur < self->used; ++cur)
CcBitArray_Destruct(cur);
CcFree(self->start);
}
static void
CcSection_Destruct(CcObject_t * self)
{
CcSection_t * ccself = (CcSection_t *)self;
CcsPosition_Destruct(ccself->pos);
CcFree(ccself->name);
CcObject_Destruct(self);
}
void
CcCharSet_Destruct(CcCharSet_t * self)
{
CcCharSet_Clear(self);
CcFree(self);
}
void
CcArrayList_Destruct(CcArrayList_t * self)
{
CcArrayList_Clear(self);
if (self->Objects) CcFree(self->Objects);
}
static CcsBool_t
CcSyntax_NoCircularProductions(CcSyntax_t * self)
{
CcBitArray_t singles;
SymbolPair_t * firstPair, * prevPair, * curPair, * curPair0;
CcSymbolNT_t * sym; CcArrayListIter_t iter; int index;
CcsBool_t ok, changed, onLeftSide, onRightSide;
CcSymbol_t * leftsym, * rightsym;
CcSymbolTable_t * symtab = &self->globals->symtab;
CcArrayList_t * ntarr = &symtab->nonterminals;
firstPair = NULL;
CcBitArray(&singles, ntarr->Count);
for (sym = (CcSymbolNT_t *)CcArrayList_First(ntarr, &iter);
sym; sym = (CcSymbolNT_t *)CcArrayList_Next(ntarr, &iter)) {
CcBitArray_SetAll(&singles, FALSE);
/* Get nonterminals s such that sym-->s */
GetSingles(&singles, sym->graph);
for (index = 0; index < ntarr->Count; ++index) {
if (!CcBitArray_Get(&singles, index)) continue;
curPair = CcMalloc(sizeof(SymbolPair_t));
curPair->left = sym->base.kind;
curPair->right = index;
curPair->next = firstPair;
firstPair = curPair;
}
}
CcBitArray_Destruct(&singles);
do {
changed = FALSE;
prevPair = NULL; curPair = firstPair;
while (curPair) {
onLeftSide = FALSE; onRightSide = FALSE;
for (curPair0 = curPair; curPair0; curPair0 = curPair0->next) {
if (curPair->left == curPair0->right) onRightSide = TRUE;
if (curPair->right == curPair0->left) onLeftSide = TRUE;
}
if (onLeftSide && onRightSide) { /* Circular Production found. */
prevPair = curPair; curPair = curPair->next;
} else { /* Remove non-circular nonterminal symbol pair. */
curPair0 = curPair->next;
if (prevPair == NULL) firstPair = curPair0;
else prevPair->next = curPair0;
CcFree(curPair);
curPair = curPair0;
changed = TRUE;
}
}
} while (changed);
ok = TRUE;
for (curPair = firstPair; curPair; curPair = curPair0) {
ok = FALSE;
leftsym = (CcSymbol_t *)CcArrayList_Get(ntarr, curPair->left);
rightsym = (CcSymbol_t *)CcArrayList_Get(ntarr, curPair->right);
CcsErrorPool_Error(self->globals->errpool, NULL, " '%s' --> '%s'",
leftsym->name, rightsym->name);
curPair0 = curPair->next;
CcFree(curPair);
}
return ok;
}
void
CcGraph_Destruct(CcGraph_t * self)
{
CcFree(self);
}
void
CcComment_Destruct(CcComment_t * self)
{
CcFree(self);
}
