void
CcXmlSpec_MakeTerminals(const CcXmlSpec_t * self, CcGlobals_t * globals)
{
char EndTag[128];
CcArrayListIter_t iter; const CcXmlData_t * data;
CcSymbolTable_t * symtab = &globals->symtab;
for (data = (const CcXmlData_t *)CcArrayList_FirstC(&self->Tags, &iter);
data; data = (const CcXmlData_t *)CcArrayList_NextC(&self->Tags, &iter)) {
if (!CcSymbolTable_NewTerminalWithCheck(symtab, data->tokenName, data->loc.line))
CcsErrorPool_Error(globals->errpool, &data->loc,
"Symbol %s is defined twice.\n", data->tokenName);
snprintf(EndTag, sizeof(EndTag), "END_%s", data->tokenName);
if (!CcSymbolTable_NewTerminalWithCheck(symtab, EndTag, data->loc.line))
CcsErrorPool_Error(globals->errpool, &data->loc,
"Symbol %s is defined twice.\n", EndTag);
}
for (data = (const CcXmlData_t *)CcArrayList_FirstC(&self->Attrs, &iter);
data; data = (const CcXmlData_t *)CcArrayList_NextC(&self->Attrs, &iter))
if (!CcSymbolTable_NewTerminalWithCheck(symtab, data->tokenName, data->loc.line))
CcsErrorPool_Error(globals->errpool, &data->loc,
"Symbol %s is defined twice.\n", data->tokenName);
for (data = (const CcXmlData_t *)CcArrayList_FirstC(&self->PInstructions, &iter);
data; data = (const CcXmlData_t *)CcArrayList_NextC(&self->PInstructions, &iter))
if (!CcSymbolTable_NewTerminalWithCheck(symtab, data->tokenName, data->loc.line))
CcsErrorPool_Error(globals->errpool, &data->loc,
"Symbol %s is defined twice.\n", data->tokenName);
}
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 void
SCSOS_GenCond(CcCSharpBaseOutputScheme_t * self, CcOutput_t * output,
const char * prefix, const char * suffix,
const CcBitArray_t * s, const CcNode_t * p)
{
const CcNodeRSLV_t * prslv; int n;
CcArrayListIter_t iter; const CcSymbol_t * sym;
const CcArrayList_t * terminals;
if (p->base.type == node_rslv) {
prslv = (CcNodeRSLV_t *)p;
CcPrintfIL(output, "%s%s%s", prefix, prslv->pos->text, suffix);
} else if ((n = CcBitArray_Elements(s)) == 0) {
CcPrintfIL(output, "%s%s%s", prefix, "false", suffix);
} else if (n <= maxTerm) {
CcPrintfI(output, "%s", prefix);
terminals = &self->base.globals->symtab.terminals;
for (sym = (const CcSymbol_t *)CcArrayList_FirstC(terminals, &iter);
sym; sym = (const CcSymbol_t *)CcArrayList_NextC(terminals, &iter))
if (CcBitArray_Get(s, sym->kind)) {
CcPrintf(output, "la.kind == %d", sym->kind);
if (--n > 0) CcPrintf(output, " || ");
}
CcPrintfL(output, "%s", suffix);
} else {
CcPrintfIL(output, "%sStartOf(%d)%s",
prefix, CcSyntaxSymSet_New(&self->symSet, s), suffix);
}
}
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;
}
static CcsBool_t
CSOS_Productions(CcCSharpBaseOutputScheme_t * self, CcOutput_t * output)
{
CcBitArray_t isChecked;
CcArrayListIter_t iter;
const CcSymbolNT_t * sym;
const CcArrayList_t * nonterminals =
&self->base.globals->symtab.nonterminals;
CcBitArray(&isChecked, self->base.globals->symtab.terminals.Count);
for (sym = (const CcSymbolNT_t *)CcArrayList_FirstC(nonterminals, &iter);
sym;
sym = (const CcSymbolNT_t *)CcArrayList_NextC(nonterminals, &iter)) {
self->curSy = (const CcSymbol_t *)sym;
if (sym->attrPos == NULL) {
CcPrintfIL(output, "private void %s()", sym->base.name);
} else {
CcPrintfIL(output, "private void %s(%s)",
sym->base.name, sym->attrPos->text);
}
CcPrintfIL(output, "{");
output->indent += 4;
if (sym->semPos) CcSource(output, sym->semPos);
SCSOS_GenCode(self, output, sym->graph, &isChecked);
output->indent -= 4;
CcPrintfIL(output, "}");
CcPrintfL(output, "");
}
CcBitArray_Destruct(&isChecked);
return TRUE;
}
const CcsPosition_t *
CcGlobals_GetSection(const CcGlobals_t * self, const char * secname)
{
CcArrayListIter_t iter; const CcSection_t * section;
for (section = (const CcSection_t *)CcArrayList_FirstC(&self->sections, &iter);
section;
section = (const CcSection_t *)CcArrayList_NextC(&self->sections, &iter))
if (!strcmp(section->name, secname)) return section->pos;
return NULL;
}
static void
CcSyntax_Errors(CcSyntax_t * self)
{
CcArrayListIter_t iter;
const CcSymbol_t * sym;
CcSyntaxError_t * error;
const CcArrayList_t * terminals = &self->globals->symtab.terminals;
for (sym = (const CcSymbol_t *)CcArrayList_FirstC(terminals, &iter);
sym; sym = (const CcSymbol_t *)CcArrayList_NextC(terminals, &iter)) {
error = (CcSyntaxError_t *)
CcArrayList_New(&self->errors, CcObject(&CcSyntaxErrorType));
error->type = cet_t;
error->sym = sym;
}
}
void
CcEBNF_DumpNodes(const CcEBNF_t * self)
{
CcArrayListIter_t iter;
const CcNode_t * node;
for (node = (const CcNode_t *)CcArrayList_FirstC(&self->nodes, &iter);
node; node = (const CcNode_t *)CcArrayList_NextC(&self->nodes, &iter)) {
fprintf(stderr, "Node(%d):%16s %4d %4d %4d %5s\n",
node->base.index, node->base.type->name,
node->next ? node->next->base.index : -1,
node->down ? node->down->base.index : -1,
node->sub ? node->sub->base.index : -1,
node->up ? "TRUE" : "FALSE");
}
}
static CcsBool_t
CSOS_Pragmas(CcCSharpBaseOutputScheme_t * self, CcOutput_t * output)
{
CcArrayListIter_t iter;
const CcSymbolPR_t * sym, * sym1;
const CcArrayList_t * pragmas = &self->base.globals->symtab.pragmas;
for (sym = sym1 = (const CcSymbolPR_t *)CcArrayList_FirstC(pragmas, &iter);
sym; sym = (const CcSymbolPR_t *)CcArrayList_NextC(pragmas, &iter)) {
CcPrintfIL(output, "%sif (la.kind == %d) {",
(sym == sym1) ? "" : "} else ", sym->base.kind);
if (sym->semPos) {
output->indent += 4;
CcSource(output, sym->semPos);
output->indent -= 4;
}
}
if (sym1) CcPrintfIL(output, "}");
return TRUE;
}
