PT_Tree CO_getFunctionArgument(PT_Tree function, int i)
{
/* "name" L "(" L <arg0> L "," L <arg1> L "," L <arg2> L ... */
/* |-----4------| |------4-----| |-----4------| |-------- ... */
return PT_getArgsArgumentAt(PT_getTreeArgs(function),4 + 4 * i);
}
PT_Tree PT_getTreeBracketTree(PT_Tree tree)
{
if (PT_isTreeBracket(tree)) {
return PT_getArgsArgumentAt(PT_getTreeArgs(tree),2);
}
return NULL;
}
static PT_Tree pList(PT_Tree tree, int *i, SDF_Symbol ssym)
{
PT_Tree layout;
PT_Args elems;
PT_Args newElems;
ATbool isLayout;
int indent = *i;
assert(PT_isTreeApplList(tree) && "This tool only supports AsFix2ME");
assert(SDF_isSymbolIterStar(ssym) || SDF_isSymbolIter(ssym));
layout = (PT_Tree) SDF_getSymbolWsAfterSymbol(ssym);
elems = PT_getTreeArgs(tree);
newElems = PT_makeArgsEmpty();
isLayout = ATfalse;
for (; !PT_isArgsEmpty(elems); elems = PT_getArgsTail(elems)) {
PT_Tree head = PT_getArgsHead(elems);
if (isLayout) {
newElems = PT_makeArgsList(createLayoutTree(*i, layout), newElems);
*i = calcIndentationLevel(*i, layout);
}
else {
newElems = PT_makeArgsList(pTree(head, i), newElems);
}
isLayout = !isLayout;
*i = indent;
}
return PT_setTreeArgs(tree, PT_reverseArgs(newElems));
}
PT_Tree PT_findTreeParentRecursive(PT_Tree needle, PT_Tree haystack)
{
assert(needle != NULL);
assert(haystack != NULL);
assert(needle != haystack);
if (ATtableGet(findParentCache, PT_TreeToTerm(haystack)) != NULL) {
return NULL;
}
if (PT_hasTreeArgs(haystack)) {
PT_Args children = PT_getTreeArgs(haystack);
while (!PT_isArgsEmpty(children)) {
PT_Tree child = PT_getArgsHead(children);
if (PT_isEqualTree(child, needle)) {
return haystack;
}
else {
PT_Tree suspect = PT_findTreeParentRecursive(needle, child);
if (suspect != NULL) {
return suspect;
}
}
children = PT_getArgsTail(children);
}
}
ATtablePut(findParentCache, PT_TreeToTerm(haystack), PT_TreeToTerm(NeedleNotHere));
return NULL;
}
ATbool PT_containsTreeCycle(PT_Tree tree) {
if (PT_isTreeCycle(tree)) {
return ATtrue;
}
if (PT_hasTreeArgs(tree)) {
return PT_containsArgsCycle(PT_getTreeArgs(tree));
}
return ATfalse;
}
static PT_Tree flattenTreeAgain(PT_Tree tree)
{
if (PT_isTreeAppl(tree)) {
PT_Production prod = PT_getTreeProd(tree);
PT_Args args = PT_getTreeArgs(tree);
args = flattenArgsAgain(args);
if (PT_isProductionList(prod)) {
args = flattenListAgain(prod, args);
}
return PT_setTreeArgs(tree, args);
}
else if (PT_isTreeAmb(tree)) {
PT_Args ambs = PT_getTreeArgs(tree);
ambs = flattenArgsAgain(ambs);
return PT_setTreeArgs(tree, ambs);
}
return tree;
}
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;
}
}
static PT_Tree pAppl(PT_Tree tree, int *i)
{
int indent = *i;
PT_Args args = PT_getTreeArgs(tree);
PT_Production prod = PT_getTreeProd(tree);
SDF_Production sprod = (SDF_Production) ATtableGet(mapping, (ATerm) prod);
if (sprod != NULL) {
PT_Args newArgs = PT_makeArgsEmpty();
SDF_SymbolList slhs = SDF_getSymbolsList(SDF_getProductionSymbols(sprod));
PT_Symbols lhs = PT_getProductionLhs(prod);
PT_Tree nextLayout = NULL;
for (; !PT_isArgsEmpty(args); args = PT_getArgsTail(args), lhs = PT_getSymbolsTail(lhs)) {
PT_Tree head = PT_getArgsHead(args);
PT_Symbol sym = PT_getSymbolsHead(lhs);
// here we put in the layout that's in between the symbols on the lhs
if (PT_isOptLayoutSymbol(sym)) {
assert(nextLayout != NULL);
newArgs = PT_makeArgsList(createLayoutTree(indent, nextLayout), newArgs);
*i = calcIndentationLevel(indent, nextLayout);
nextLayout = NULL;
}
else {
SDF_Symbol ssym = SDF_getSymbolListHead(slhs);
PT_Symbol real = PT_getSymbolSymbol(sym);
newArgs = PT_makeArgsList(pTreeWithSymbol(head, i, real, ssym), newArgs);
if (SDF_hasSymbolListTail(slhs)) {
nextLayout = (PT_Tree) SDF_getSymbolListWsAfterFirst(slhs);
slhs = SDF_getSymbolListTail(slhs);
}
}
}
tree = PT_setTreeArgs(tree, PT_reverseArgs(newArgs));
}
else {
tree = PT_setTreeArgs(tree, pArgs(args, i));
}
return tree;
}
static PT_Tree get_lex_term_anno(PT_Tree term, PT_Tree key)
{
ATerm label;
ATerm anno = NULL;
label = unquoteAppl(ATparse(PT_yieldTreeToString(key, ATfalse)));
if (label == NULL) {
return NULL;
}
if (PT_isTreeLexicalInjection(term)) {
PT_Tree lex = PT_getArgsHead(PT_getTreeArgs(term));
anno = PT_getTreeAnnotation(lex, label);
}
if (anno != NULL) {
return (PT_Tree) PTPT_liftATerm(anno);
}
return noAnno();
}
static PT_Tree pTreeWithSymbol(PT_Tree tree, int *i, PT_Symbol sym, SDF_Symbol ssym)
{
if (PT_isSymbolSort(sym)) {
return pTree(tree, i);
}
else if (PT_isSymbolLit(sym)) {
return tree;
}
else if (PT_isSymbolIterStar(sym) || PT_isSymbolIterPlus(sym)) {
return pList(tree, i, ssym);
}
else if (PT_isSymbolIterStarSep(sym) || PT_isSymbolIterPlusSep(sym)) {
return pSepList(tree, i, ssym);
}
/* the rest is handled by doing nothing */
if (PT_hasTreeArgs(tree)) {
return PT_setTreeArgs(tree, pArgs(PT_getTreeArgs(tree), i));
}
else {
return tree;
}
}
static PT_Tree pAmb(PT_Tree tree, int *i)
{
PT_Args args = PT_getTreeArgs(tree);
return PT_setTreeArgs(tree, pArgs(args, i));
}
