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; }