void
CcsBuffer_SetBusy(CcsBuffer_t * self, long startBusy)
{
CcsAssert(startBusy >= self->start);
self->busyFirst = self->buf + (startBusy - self->start);
CcsAssert(self->busyFirst <= self->cur);
}
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;
}
void
PatchScanner_Destruct(PatchScanner_t * self)
{
CcsScanInput_t * cur, * next;
for (cur = self->cur; cur; cur = next) {
next = cur->next;
/* May be trigged by .atg/.xatg. */
CcsAssert(cur->busyFirst == NULL);
CcsAssert(cur->busyLast == NULL);
CcsScanInput_Detach(cur);
}
/* May be trigged by .atg semantic code. */
CcsAssert(self->dummyToken->refcnt == 1);
CcsToken_Destruct(self->dummyToken);
}
long
CcsBuffer_StringTo(CcsBuffer_t * self, size_t * len, const char * needle)
{
int loadret;
char * cur; long curpos;
size_t nlen = strlen(needle);
for (cur = self->cur; (cur + nlen) - self->cur <= *len; ++cur) {
while ((cur + nlen) > self->loaded) {
/* There is not enough data in the buffer. */
curpos = self->start + (cur - self->buf);
loadret = CcsBuffer_LoadMore(self);
cur = self->buf + (curpos - self->start);
if (loadret == ErrorChr) return -1;
if (loadret == EoF) {
cur = self->loaded; goto done;
}
}
if (*cur == *needle && !memcmp(cur + 1, needle + 1, nlen - 1)) {
/* needle found. */
cur += nlen; break;
}
}
done:
CcsAssert(cur - self->cur <= *len);
*len = cur - self->cur;
return self->start + (self->cur - self->buf);
}
void
CcsBuffer_Lock(CcsBuffer_t * self)
{
CcsAssert(self->lockCur == NULL);
self->lockCur = self->cur;
self->lockNext = self->next;
}
void
PatchScanner_IndentLimit(PatchScanner_t * self, const CcsToken_t * indentIn)
{
CcsAssert(indentIn->input == self->cur);
/*CcsAssert(indentIn->kind == PatchScanner_INDENT_IN);*/
CcsIndent_SetLimit((CcsIndent_t *)(self->cur + 1), indentIn);
}
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;
}
CcsToken_t *
CcsIndent_Generator(CcsIndent_t * self, CcsScanInput_t * input)
{
int newLen; int * newIndent, * curIndent;
CcsToken_t * head, * cur;
if (!self->lineStart) return NULL;
CcsAssert(self->indent < self->indentUsed);
/* Skip blank lines. */
if (input->ch == '\r' || input->ch == '\n') return NULL;
/* Dump all required IndentOut when EoF encountered. */
if (input->ch == EoF) {
head = NULL;
while (self->indent < self->indentUsed - 1) {
cur = CcsScanInput_NewToken(input, self->info->kIndentOut);
cur->next = head; head = cur;
--self->indentUsed;
}
return head;
}
if (self->indentLimit != -1 && input->col >= self->indentLimit) return NULL;
self->indentLimit = -1;
self->lineStart = FALSE;
if (input->col > self->indentUsed[-1]) {
if (self->indentUsed == self->indentLast) {
newLen = (self->indentLast - self->indent) + START_INDENT_SPACE;
newIndent = CcsRealloc(self->indent, sizeof(int) * newLen);
if (!newIndent) return NULL;
self->indentUsed = newIndent + (self->indentUsed - self->indent);
self->indentLast = newIndent + newLen;
self->indent = newIndent;
}
CcsAssert(self->indentUsed < self->indentLast);
*self->indentUsed++ = input->col;
return CcsScanInput_NewToken(input, self->info->kIndentIn);
}
for (curIndent = self->indentUsed - 1; input->col < *curIndent; --curIndent);
if (input->col > *curIndent)
return CcsScanInput_NewToken(input, self->info->kIndentErr);
head = NULL;
while (curIndent < self->indentUsed - 1) {
cur = CcsScanInput_NewToken(input, self->info->kIndentOut);
cur->next = head; head = cur;
--self->indentUsed;
}
return head;
}
void
CcsBuffer_LockReset(CcsBuffer_t * self)
{
CcsAssert(self->lockCur != NULL);
self->cur = self->lockCur;
self->next = self->lockNext;
self->lockCur = NULL;
}
CcNode_t *
CcSyntax_NodeFromSymbol(CcSyntax_t * self, const CcSymbol_t * sym, int line,
CcsBool_t weak)
{
if (sym->base.type == symbol_t && weak) {
self->weakUsed = TRUE;
return (CcNode_t *)CcEBNF_NewNode(&self->base, CcNodeWT(line, sym));
} else if (sym->base.type == symbol_t) {
return (CcNode_t *)CcEBNF_NewNode(&self->base, CcNodeT(line, sym));
} else if (sym->base.type == symbol_pr) {
return (CcNode_t *)CcEBNF_NewNode(&self->base, CcNodePR(line));
} else if (sym->base.type == symbol_nt) {
return (CcNode_t *)CcEBNF_NewNode(&self->base, CcNodeNT(line, sym));
} else if (sym->base.type == symbol_rslv) {
return (CcNode_t *)CcEBNF_NewNode(&self->base, CcNodeRslv(line));
}
CcsAssert(0);
return NULL;
}
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
CcsBuffer_Unlock(CcsBuffer_t * self)
{
CcsAssert(self->lockCur != NULL);
self->lockCur = NULL;
}
