/* For each production, get its first set. */
void calc_first_table() {
CC_Class *firstset;
CC_Class copy;
PT_Symbol symbol;
PT_Symbols symbols;
PT_Production prod;
ATbool changed = ATtrue;
int ip;
while(changed) {
changed = ATfalse;
for(ip = MIN_PROD_NUM; ip < PGEN_getMaxProductionNumber(); ip++) {
prod = PGEN_getProductionOfProductionNumber(ip);
assert(PT_isValidProduction(prod));
symbols = PT_getProductionLhs(prod);
symbol = PT_getProductionRhs(prod);
firstset = get_first_set(symbol, ATfalse);
if(firstset) {
CC_copy(firstset, ©);
first(firstset, symbols);
CC_union(firstset, ©, firstset);
changed |= !CC_isEqual(©, firstset);
}
else {
firstset = get_first_set(symbol, ATtrue);
first(firstset, symbols);
changed = ATtrue;
}
}
}
}
SDF_Production PTProductionToSDFProduction(PT_Production ptProduction)
{
PT_Symbols ptLhs;
PT_Symbol ptRhs;
PT_Attributes ptAttributes;
SDF_Symbols sdfLhs;
SDF_Symbol sdfRhs;
SDF_Attributes sdfAttributes;
ptLhs = PT_getProductionLhs(ptProduction);
sdfLhs = PTSymbolsToSDFSymbols(ptLhs);
ptRhs = PT_getProductionRhs(ptProduction);
sdfRhs = PTSymbolToSDFSymbol(ptRhs);
ptAttributes = PT_getProductionAttributes(ptProduction);
sdfAttributes = PTAttributesToSDFAttributes(ptAttributes);
return SDF_makeProductionProd(sdfLhs,
SDF_makeLayoutSpace(),
SDF_makeLayoutSpace(),
sdfRhs,
SDF_makeLayoutSpace(),
sdfAttributes);
}
static PT_Args flattenListAgain(PT_Production prod, PT_Args elems)
{
PT_Args newElems = PT_makeArgsEmpty();
for ( ; !PT_isArgsEmpty(elems); elems = PT_getArgsTail(elems)) {
PT_Tree arg = PT_getArgsHead(elems);
if (PT_hasTreeProd(arg)) {
ATbool nested = ATfalse;
PT_Production argProd = PT_getTreeProd(arg);
if (PT_isEqualProduction(prod, argProd)) {
nested = ATtrue;
}
else if (PT_isProductionList(argProd)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
PT_Symbol rhsArg = PT_getProductionRhs(argProd);
if (PT_isSymbolCf(rhs) || PT_isSymbolLex(rhs)) {
rhs = PT_getSymbolSymbol(rhs);
}
if (PT_isSymbolCf(rhsArg) || PT_isSymbolLex(rhsArg)) {
rhsArg = PT_getSymbolSymbol(rhsArg);
}
if (PT_isSymbolIterStar(rhs)
&& PT_isSymbolIterPlus(rhsArg)
&& PT_isEqualSymbol(PT_getSymbolSymbol(rhs),
PT_getSymbolSymbol(rhsArg))) {
nested = ATtrue;
}
}
if (nested) {
PT_Args nestedElems = PT_getTreeArgs(arg);
newElems = PT_concatArgs(PT_reverseArgs(nestedElems), newElems);
continue;
}
}
newElems = PT_makeArgsMany(arg, newElems);
}
return PT_reverseArgs(newElems);
}
PT_Tree PT_renameInTree(PT_Tree tree,
PT_Symbol formalParam,
PT_Symbol actualParam)
{
if (PT_isTreeAppl(tree)) {
PT_Production prod = PT_getTreeProd(tree);
PT_Symbol rhs = PT_getProductionRhs(prod);
PT_Args args = PT_getTreeArgs(tree);
PT_Production newProd = renameInProduction(prod, formalParam, actualParam);
PT_Symbol newRhs = PT_getProductionRhs(newProd);
PT_Args newArgs = renameInArgs(args, formalParam, actualParam);
PT_Tree newTree;
newTree = PT_setTreeArgs(PT_setTreeProd(tree, newProd), newArgs);
/* Wrap new variable lists in a proper list production */
if (PT_isTreeVar(newTree) &&
(PT_isIterSymbol(newRhs) || PT_isIterSepSymbol(newRhs)) &&
!(PT_isIterSymbol(rhs) || PT_isIterSepSymbol(rhs))) {
PT_Production listProd = PT_makeProductionList(newRhs);
PT_Tree listTree = PT_makeTreeAppl(listProd,
PT_makeArgsList(newTree,
PT_makeArgsEmpty()));
newTree = listTree;
}
return newTree;
}
else if (PT_isTreeLit(tree)) {
if (PT_isSymbolLit(formalParam)) {
char *localStr = PT_getTreeString(tree);
char *formalStr = PT_getSymbolString(formalParam);
if (strcmp(localStr, formalStr) == 0) {
return PT_setTreeString(tree, PT_getSymbolString(actualParam));
}
}
return tree;
}
else {
return tree;
}
}
ATbool PT_isTreeCilit(PT_Tree tree)
{
if (PT_hasTreeProd(tree)) {
return PT_isSymbolCilit(PT_getProductionRhs(PT_getTreeProd(tree)));
}
else {
return ATfalse;
}
}
ATbool PT_isTreeLexical(PT_Tree tree)
{
if (PT_isTreeAppl(tree)) {
PT_Production prod = PT_getTreeProd(tree);
PT_Symbol rhs = PT_getProductionRhs(prod);
return PT_isSymbolLex(rhs);
}
return ATfalse;
}
ATbool PT_prodHasVarSymAsRhs(PT_Production prod)
{
/* This implements: "prod([<list>],varsym(<str>),no-attrs)" */
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
return PT_isSymbolVarSym(rhs);
}
return ATfalse;
}
ATbool PT_isOptLayoutProd(PT_Production prod)
{
/* This implements: "prod([<list>],cf(opt(layout)),<term>)" */
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
return PT_isOptLayoutSymbol(rhs);
}
return ATfalse;
}
ATbool PT_isTreeFlatLexical(PT_Tree tree)
{
static PT_Symbol allCharsSymbol;
allCharsSymbol = makeSymbolAllChars();
if (PT_isTreeAppl(tree)) {
PT_Production listProd = PT_getTreeProd(tree);
PT_Symbol listSymbol = PT_getProductionRhs(listProd);
return PT_isEqualSymbol(listSymbol, allCharsSymbol);
}
return ATfalse;
}
ATbool PT_prodHasIterAsRhs(PT_Production prod)
{
/* This implements:
* "prod([<list>],cf(iter-star(<term>,lit(<str>))),<term>)"
* "prod([<list>],cf(iter(<term>,lit(<str>))),<term>)"
*/
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
return PT_isIterSymbol(rhs);
}
return ATfalse;
}
static
PT_Production renameInProduction(PT_Production prod,
PT_Symbol formalParam,
PT_Symbol actualParam)
{
if (PT_isProductionDefault(prod)) {
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Symbol rhs = PT_getProductionRhs(prod);
PT_Symbols newLhs = renameInSymbols(lhs, formalParam, actualParam);
PT_Symbol newRhs = renameInSymbol(rhs, formalParam, actualParam);
return PT_setProductionRhs(PT_setProductionLhs(prod, newLhs), newRhs);
}
else {
PT_Symbol rhs = PT_getProductionRhs(prod);
PT_Symbol newRhs = renameInSymbol(rhs, formalParam, actualParam);
return PT_setProductionRhs(prod, newRhs);
}
}
ATbool PT_prodHasSTARTAsRhs(PT_Production prod)
{
/* This implements:
* "prod([<list>],sort(\"<START>\"),no-attrs)"
*/
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isSymbolSort(rhs)) {
char *startsym = PT_getSymbolString(rhs);
return strcmp(startsym,"<START>") == 0;
}
}
return ATfalse;
}
ATbool PT_isTreeVarListPlus(PT_Tree tree)
{
if (PT_isTreeAppl(tree)) {
PT_Production prod = PT_getTreeProd(tree);
if (PT_isProductionVariable(prod)) {
PT_Symbol rhssym = PT_getProductionRhs(prod);
if (PT_isSymbolCf(rhssym) || PT_isSymbolLex(rhssym)) {
PT_Symbol sym = PT_getSymbolSymbol(rhssym);
return PT_isSymbolIterPlus(sym)
|| PT_isSymbolIterPlusSep(sym);
}
}
}
return ATfalse;
}
ATbool PT_isLexicalProd(PT_Production prod)
{
/* This implements: "prod([<list>],lex(sort(<term>)),<term>)" */
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isSymbolLex(rhs)) {
PT_Symbol symbol = PT_getSymbolSymbol(rhs);
return PT_isSymbolSort(symbol);
}
return ATfalse;
}
return ATfalse;
}
ATbool PT_prodHasCfLayoutAsRhs(PT_Production prod)
{
/* This implements: "prod([<list>],cf(layout),<term>)" */
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isSymbolCf(rhs)) {
PT_Symbol symbol = PT_getSymbolSymbol(rhs);
return PT_isSymbolLayout(symbol);
}
return ATfalse;
}
return ATfalse;
}
ATbool PT_isProductionVariable(PT_Production prod)
{
/* This implements: "prod([varsym(<term>)],cf(<term>),<term>)" */
if (PT_isProductionDefault(prod)) {
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Symbol rhs = PT_getProductionRhs(prod);
if ((PT_isSymbolCf(rhs) || PT_isSymbolLex(rhs)) && PT_hasSymbolsHead(lhs)) {
PT_Symbol lhssym = PT_getSymbolsHead(lhs);
PT_Symbols tail = PT_getSymbolsTail(lhs);
return PT_isSymbolsEmpty(tail) && PT_isSymbolVarSym(lhssym);
}
return ATfalse;
}
return ATfalse;
}
static int
lengthOfProd(PT_Production prod)
{
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isProductionList(prod)) {
return lengthOfSymbol(rhs);
}
else {
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Attributes attrs = PT_getProductionAttributes(prod);
return lengthOfSymbols(lhs) + 4 +
lengthOfSymbol(rhs) +
lengthOfAttributes(attrs);
}
}
ATbool PT_isTreeAlt(PT_Tree tree)
{
PT_Production prod;
PT_Symbol rhs;
if (PT_hasTreeProd(tree)) {
prod = PT_getTreeProd(tree);
rhs = PT_getProductionRhs(prod);
if (PT_isSymbolCf(rhs) || PT_isSymbolLex(rhs)) {
rhs = PT_getSymbolSymbol(rhs);
}
if (PT_isSymbolAlt(rhs)) {
return ATtrue;
}
}
return ATfalse;
}
ATbool PT_isLexicalInjectionProd(PT_Production prod)
{
/* This implements: "prod([lex(<term>)],cf(<term>),<term>)" */
if (PT_isProductionDefault(prod)) {
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isSymbolCf(rhs) && PT_hasSymbolsHead(lhs)) {
PT_Symbol rhsNestedSymbol = PT_getSymbolSymbol(rhs);
PT_Symbol lhssym = PT_getSymbolsHead(lhs);
PT_Symbols tail = PT_getSymbolsTail(lhs);
if (PT_isSymbolsEmpty(tail) && PT_isSymbolLex(lhssym)) {
PT_Symbol lhsNestedSymbol = PT_getSymbolSymbol(lhssym);
return PT_isEqualSymbol(rhsNestedSymbol, lhsNestedSymbol);
}
}
return ATfalse;
}
return ATfalse;
}
static int
yieldProd(PT_Production prod, int idx, char *buf, int bufSize)
{
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isProductionList(prod)) {
idx = yieldSymbol(rhs, idx, buf, bufSize);
}
else {
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Attributes attrs = PT_getProductionAttributes(prod);
idx = yieldSymbols(lhs, idx, buf, bufSize);
buf[idx++] = '-';
buf[idx++] = '>';
buf[idx++] = ' ';
idx = yieldSymbol(rhs, idx, buf, bufSize);
idx = yieldAttributes(attrs, idx, buf, bufSize);
}
return idx;
}
static PT_Production normalizeProduction(PT_Production prod)
{
PT_Symbol layout = PT_makeOptLayoutSymbol();
if (!PT_isProductionList(prod)) {
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Symbols newLhs = PT_makeSymbolsEmpty();
PT_Symbol rhs = PT_getProductionRhs(prod);
for(; !PT_isSymbolsEmpty(lhs); lhs = PT_getSymbolsTail(lhs)) {
PT_Symbol head = PT_getSymbolsHead(lhs);
PT_Symbol newHead;
if (!PT_isSymbolLit(head)) {
newHead = PT_makeSymbolCf(head);
}
else {
newHead = head;
}
newLhs = PT_makeSymbolsList(newHead, newLhs);
if (PT_hasSymbolsTail(PT_getSymbolsTail(lhs))) {
newLhs = PT_makeSymbolsList(layout, newLhs);
}
}
prod = PT_setProductionRhs(prod, PT_makeSymbolCf(rhs));
prod = PT_setProductionLhs(prod, PT_reverseSymbols(newLhs));
return prod;
}
else {
return prod;
}
}
static PT_Tree listToTree(PT_Production prod, ATermList elems)
{
PT_Tree layout = defaultLayout;
PT_Tree sepTree = NULL;
PT_Symbol rhs;
PT_Args args = PT_makeArgsEmpty();
ATbool contextfree;
int sepLength = 0;
int i;
rhs = PT_getProductionRhs(prod);
if (PT_isSymbolCf(rhs)) {
rhs = PT_getSymbolSymbol(rhs);
contextfree = ATtrue;
} else if (PT_isSymbolLex(rhs)) {
rhs = PT_getSymbolSymbol(rhs);
contextfree = ATfalse;
} else {
contextfree = ATfalse;
}
if (PT_hasSymbolSeparator(rhs)) {
PT_Symbol sepSym = PT_getSymbolSeparator(rhs);
assert(PT_isSymbolLit(sepSym));
sepTree = PT_makeTreeLit(PT_getSymbolString(sepSym));
sepLength = contextfree ? 3 : 1;
}
if (!ATisEmpty(elems)) {
/* get a free part of the term store */
TERM_STORE_FRAME(ATgetLength(elems),
for (i = 0; !ATisEmpty(elems); elems = ATgetNext(elems)) {
PT_Tree newTree = termToTree(ATgetFirst(elems));
/* Note that TERM_STORE contains a reference to a global
* that may be updated by termToTree, so do not remove the
* newTree temporary variable and do not inline the call to termToTree
* in the following assignment.
*/
TERM_STORE_CHECK(i);
TERM_STORE[i] = (ATerm) newTree;
i++;
}
while(--i >= 0) {
args = PT_makeArgsMany((PT_Tree) TERM_STORE[i], args);
if (i != 0) {
if (sepTree) {
if (!keep_layout && contextfree) {
args = PT_makeArgsMany(layout, args);
}
if (!keep_layout) {
args = PT_makeArgsMany(sepTree, args);
}
}
if (!keep_layout && contextfree) {
args = PT_makeArgsMany(layout, args);
}
}
}
)
}
