CcCharSet_t *
CcCharSet(void)
{
CcCharSet_t * self = CcMalloc(sizeof(CcCharSet_t));
self->head = NULL;
return self;
}
CcGraph_t *
CcGraph(void)
{
CcGraph_t * self = CcMalloc(sizeof(CcGraph_t));
self->head = self->r = NULL;
return self;
}
CcRange_t *
new_Range(int from, int to)
{
CcRange_t * self = CcMalloc(sizeof(CcRange_t));
self->from = from; self->to = to; self->next = NULL;
return self;
}
CcGraph_t *
CcGraphP(CcNode_t * p)
{
CcGraph_t * self = CcMalloc(sizeof(CcGraph_t));
self->head = self->r = p;
return self;
}
static CcXmlSpecData_t *
CcXmlSpec_GetSortedList(const CcArrayList_t * array, CcsBool_t useEnd,
const CcGlobals_t * globals, size_t * retNum)
{
CcXmlSpecData_t * retlist, * curret;
const CcXmlData_t * data; CcArrayListIter_t iter;
const CcSymbol_t * sym; char EndTag[128];
const CcSymbolTable_t * symtab = &globals->symtab;
*retNum = array->Count;
if (array->Count == 0) return NULL;
retlist = curret = CcMalloc(array->Count * sizeof(CcXmlSpecData_t));
for (data = (const CcXmlData_t *)CcArrayList_FirstC(array, &iter);
data; data = (const CcXmlData_t *)CcArrayList_NextC(array, &iter)) {
curret->name = CcStrdup(data->name);
sym = CcSymbolTable_CheckTerminal(symtab, data->tokenName);
CcsAssert(sym != NULL);
curret->kind0 = sym->base.index;
if (useEnd) {
snprintf(EndTag, sizeof(EndTag), "END_%s", data->tokenName);
sym = CcSymbolTable_CheckTerminal(symtab, EndTag);
CcsAssert(sym != NULL);
curret->kind1 = sym->base.index;
}
++curret;
}
CcsAssert(curret - retlist == array->Count);
qsort(retlist, array->Count, sizeof(CcXmlSpecData_t), cmpXSData);
return retlist;
}
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;
}
CcArrayList_t *
CcArrayList(CcArrayList_t * self)
{
self->Count = 0;
self->Capacity = 16;
self->Objects = CcMalloc(sizeof(void *) * self->Capacity);
return self;
}
CcCharSet_t *
CcCharSet_Clone(const CcCharSet_t * s)
{
CcRange_t * prev, * curnew;
const CcRange_t * cur1;
CcCharSet_t * self = CcMalloc(sizeof(CcCharSet_t));
self->head = NULL; prev = NULL;
for (cur1 = s->head; cur1; cur1 = cur1->next) {
curnew = new_Range(cur1->from, cur1->to);
if (prev == NULL) self->head = curnew;
else prev->next = curnew;
prev = curnew;
}
return self;
}
CcComment_t *
CcComment(const int * start, const int * stop, CcsBool_t nested)
{
int * cur0; const int * cur1;
CcComment_t * self = CcMalloc(sizeof(CcComment_t));
cur0 = self->start; cur1 = start;
while (*cur1) *cur0++ = *cur1++;
*cur0 = 0;
cur0 = self->stop; cur1 = stop;
while (*cur1) *cur0++ = *cur1++;
*cur0 = 0;
self->nested = nested;
self->next = NULL;
return self;
}
void
CcSyntaxSymSet(CcSyntaxSymSet_t * self)
{
self->start = self->used = CcMalloc(sizeof(CcBitArray_t) * SZ_SYMSET);
self->last = self->start + SZ_SYMSET;
}
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;
}
