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);
}
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_isIterSymbol(PT_Symbol symbol)
{
/* This implements:
* "cf(iter-star(<term>))"
* "cf(iter(<term>))"
*/
if (PT_isSymbolCf(symbol) || PT_isSymbolLex(symbol)) {
PT_Symbol listsym = PT_getSymbolSymbol(symbol);
return PT_isSymbolIterPlus(listsym) || PT_isSymbolIterStar(listsym);
}
return ATfalse;
}
ATbool PT_isIterSepSymbol(PT_Symbol symbol)
{
/* This implements:
* "cf(iter-star-sep(<term>,lit(<str>)))" and
* "cf(iter-sep(<term>,lit(<str>)))"
*/
if (PT_isSymbolCf(symbol) || PT_isSymbolLex(symbol)) {
PT_Symbol listsym = PT_getSymbolSymbol(symbol);
return PT_isSymbolIterPlusSep(listsym) || PT_isSymbolIterStarSep(listsym);
}
return ATfalse;
}
ATbool PT_prodHasLexLayoutAsRhs(PT_Production prod)
{
/* This implements: "prod([<list>],lex(layout),<term>)" */
if (PT_isProductionDefault(prod)) {
PT_Symbol rhs = PT_getProductionRhs(prod);
if (PT_isSymbolLex(rhs)) {
PT_Symbol symbol = PT_getSymbolSymbol(rhs);
return PT_isSymbolLayout(symbol);
}
return ATfalse;
}
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_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;
}
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
lengthOfSymbol(PT_Symbol symbol)
{
if (PT_isOptLayoutSymbol(symbol)) {
return 0;
}
if (PT_isSymbolLit(symbol) || PT_isSymbolCilit(symbol)) {
char *str = PT_getSymbolString(symbol);
return strlen(str) + 2;
}
if (PT_isSymbolSort(symbol)) {
char *str = PT_getSymbolString(symbol);
return strlen(str);
}
if (PT_isSymbolEmpty(symbol)) {
return 3;
}
if (PT_isSymbolSeq(symbol)) {
PT_Symbols newSymbols = PT_getSymbolSymbols(symbol);
return lengthOfSymbols(newSymbols) + 2;
}
if (PT_isSymbolOpt(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
return lengthOfSymbol(newSymbol) + 1;
}
if (PT_isSymbolVarSym(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
return 6 + lengthOfSymbol(newSymbol);
}
if (PT_isSymbolCf(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
return lengthOfSymbol(newSymbol);
}
if (PT_isSymbolLex(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
return 6+ lengthOfSymbol(newSymbol);
}
if (PT_isSymbolAlt(symbol)) {
PT_Symbol leftSymbol = PT_getSymbolLhs(symbol);
PT_Symbol rightSymbol = PT_getSymbolRhs(symbol);
return lengthOfSymbol(leftSymbol) + 3 + lengthOfSymbol(rightSymbol);
}
if (PT_isSymbolTuple(symbol)) {
PT_Symbol headSymbol = PT_getSymbolHead(symbol);
PT_Symbols restSymbols = PT_getSymbolRest(symbol);
return lengthOfSymbol(headSymbol) + 3 + lengthOfSymbols(restSymbols);
}
if (PT_isSymbolIterPlus(symbol)
||
PT_isSymbolIterStar(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
return lengthOfSymbol(newSymbol) + 1;
}
if (PT_isSymbolIterPlusSep(symbol)
||
PT_isSymbolIterStarSep(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
PT_Symbol separator = PT_getSymbolSeparator(symbol);
return lengthOfSymbol(newSymbol) + lengthOfSymbol(separator) + 4;
}
if (PT_isSymbolIterN(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
int number = PT_getSymbolNumber(symbol);
return lengthOfSymbol(newSymbol) + lengthOfInteger(number) + 1;
}
if (PT_isSymbolIterSepN(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
PT_Symbol separator = PT_getSymbolSeparator(symbol);
int number = PT_getSymbolNumber(symbol);
return lengthOfSymbol(newSymbol) + lengthOfInteger(number) +
lengthOfSymbol(separator) + 4;
}
if (PT_isSymbolParameterizedSort(symbol)) {
char *str = PT_getSymbolSort(symbol);
PT_Symbols newSymbols = PT_getSymbolParameters(symbol);
return lengthOfSymbols(newSymbols) + strlen(str) + 4;
}
if (PT_isSymbolFunc(symbol)) {
PT_Symbols newSymbols = PT_getSymbolSymbols(symbol);
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
return lengthOfSymbols(newSymbols) + lengthOfSymbol(newSymbol) + 6;
}
if (PT_isSymbolCharClass(symbol)) {
return lengthOfCharRanges(PT_getSymbolRanges(symbol)) + 2;
}
if (PT_isSymbolLayout(symbol)) {
return 0;
}
ATwarning("lengthOfSymbol: unknown symbol: %t\n", symbol);
return 0;
}
static int
yieldSymbol(PT_Symbol symbol, int idx, char *buf, int bufSize)
{
int i;
assert(idx <= bufSize);
if (PT_isOptLayoutSymbol(symbol)) {
return idx;
}
if (PT_isSymbolLit(symbol) || PT_isSymbolCilit(symbol)) {
ATbool ci = PT_isSymbolCilit(symbol);
char *str = PT_getSymbolString(symbol);
int len = strlen(str);
buf[idx++] = ci ? '\'' : '"';
for (i = 0; i < len; i++) {
buf[idx++] = str[i];
}
buf[idx++] = ci ? '\'' : '"';
return idx;
}
if (PT_isSymbolSort(symbol)) {
char *str = PT_getSymbolString(symbol);
int len = strlen(str);
for (i = 0; i < len; i++) {
buf[idx++] = str[i];
}
return idx;
}
if (PT_isSymbolEmpty(symbol)) {
buf[idx++] = '(';
buf[idx++] = ' ';
buf[idx++] = ')';
return idx;
}
if (PT_isSymbolSeq(symbol)) {
PT_Symbols newSymbols = PT_getSymbolSymbols(symbol);
buf[idx++] = '(';
idx = yieldSymbols(newSymbols, idx, buf, bufSize);
buf[idx++] = ')';
return idx;
}
if (PT_isSymbolOpt(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = '?';
return idx;
}
if (PT_isSymbolVarSym(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
buf[idx++] = '<';
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = '-';
buf[idx++] = 'V';
buf[idx++] = 'A';
buf[idx++] = 'R';
buf[idx++] = '>';
return idx;
}
if (PT_isSymbolCf(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
return idx;
}
if (PT_isSymbolLex(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
buf[idx++] = '<';
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = '-';
buf[idx++] = 'L';
buf[idx++] = 'E';
buf[idx++] = 'X';
buf[idx++] = '>';
return idx;
}
if (PT_isSymbolAlt(symbol)) {
PT_Symbol leftSymbol = PT_getSymbolLhs(symbol);
PT_Symbol rightSymbol = PT_getSymbolRhs(symbol);
idx = yieldSymbol(leftSymbol, idx, buf, bufSize);
buf[idx++] = ' ';
buf[idx++] = '|';
buf[idx++] = ' ';
idx = yieldSymbol(rightSymbol, idx, buf, bufSize);
return idx;
}
if (PT_isSymbolTuple(symbol)) {
PT_Symbol headSymbol = PT_getSymbolHead(symbol);
PT_Symbols restSymbols = PT_getSymbolRest(symbol);
buf[idx++] = '<';
idx = yieldSymbol(headSymbol, idx, buf, bufSize);
buf[idx++] = ',';
idx = yieldSymbolParameters(restSymbols, idx, buf, bufSize);
buf[idx++] = '>';
return idx;
}
if (PT_isSymbolIterPlus(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = '+';
return idx;
}
if (PT_isSymbolIterStar(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = '*';
return idx;
}
if (PT_isSymbolIterPlusSep(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
PT_Symbol separator = PT_getSymbolSeparator(symbol);
buf[idx++] = '{';
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = ' ';
idx = yieldSymbol(separator, idx, buf, bufSize);
buf[idx++] = '}';
buf[idx++] = '+';
return idx;
}
if (PT_isSymbolIterStarSep(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
PT_Symbol separator = PT_getSymbolSeparator(symbol);
buf[idx++] = '{';
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = ' ';
idx = yieldSymbol(separator, idx, buf, bufSize);
buf[idx++] = '}';
buf[idx++] = '*';
return idx;
}
if (PT_isSymbolIterN(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
int number = PT_getSymbolNumber(symbol);
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
idx = yieldInteger(number, idx, buf, bufSize);
buf[idx++] = '+';
return idx;
}
if (PT_isSymbolIterSepN(symbol)) {
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
PT_Symbol separator = PT_getSymbolSeparator(symbol);
int number = PT_getSymbolNumber(symbol);
buf[idx++] = '{';
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = ' ';
idx = yieldSymbol(separator, idx, buf, bufSize);
buf[idx++] = '}';
idx = yieldInteger(number, idx, buf, bufSize);
buf[idx++] = '+';
return idx;
}
if (PT_isSymbolParameterizedSort(symbol)) {
char *str = PT_getSymbolSort(symbol);
PT_Symbols newSymbols = PT_getSymbolParameters(symbol);
int len = strlen(str);
for (i = 0; i < len; i++) {
buf[idx++] = str[i];
}
buf[idx++] = '[';
buf[idx++] = '[';
idx = yieldSymbolParameters(newSymbols, idx, buf, bufSize);
buf[idx++] = ']';
buf[idx++] = ']';
return idx;
}
if (PT_isSymbolFunc(symbol)) {
PT_Symbols newSymbols = PT_getSymbolSymbols(symbol);
PT_Symbol newSymbol = PT_getSymbolSymbol(symbol);
buf[idx++] = '(';
idx = yieldSymbols(newSymbols, idx, buf, bufSize);
buf[idx++] = ' ';
buf[idx++] = '=';
buf[idx++] = '>';
buf[idx++] = ' ';
idx = yieldSymbol(newSymbol, idx, buf, bufSize);
buf[idx++] = ')';
return idx;
}
if (PT_isSymbolCharClass(symbol)) {
PT_CharRanges charRanges = PT_getSymbolRanges(symbol);
buf[idx++] = '[';
idx = yieldCharRanges(charRanges,idx,buf,bufSize);
buf[idx++] = ']';
return idx;
}
if (PT_isSymbolLayout(symbol)) {
return idx;
}
ATwarning("yieldSymbol: unknown symbol: %t\n", symbol);
return idx;
}
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);
}
}
}
)
}
SDF_Symbol PTSymbolToSDFSymbol(PT_Symbol ptSymbol)
{
SDF_Symbol result;
if (PT_isSymbolLit(ptSymbol)) {
char *str = PT_getSymbolString(ptSymbol);
char *qstr = escape(str, "\"\\", QUOTED);
SDF_Literal lit = SDF_makeLiteralQlit(SDF_makeQLiteralQuoted(SDF_makeCHARLISTString(qstr)));
free(qstr);
result = SDF_makeSymbolLit(lit);
}
else if (PT_isSymbolCf(ptSymbol)
|| PT_isSymbolLex(ptSymbol)
|| PT_isSymbolVarSym(ptSymbol)) {
result = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
}
else if (PT_isSymbolEmpty(ptSymbol)) {
result = SDF_makeSymbolEmpty(SDF_makeLayoutEmpty());
}
else if (PT_isSymbolSeq(ptSymbol)) {
PT_Symbols ptSymbols = PT_getSymbolSymbols(ptSymbol);
PT_Symbol ptHead = PT_getSymbolsHead(ptSymbols);
SDF_Symbol sdfHead = PTSymbolToSDFSymbol(ptHead);
PT_Symbols ptTail = PT_getSymbolsTail(ptSymbols);
if (PT_isSymbolsEmpty(ptTail)) {
ATabort("PTSymbolToSDFSymbol: empty tail in %s\n",
PT_yieldSymbol(ptSymbol));
result = NULL;
}
else {
SDF_SymbolTail sdfSymbolTail =
(SDF_SymbolTail)PTSymbolsToSDFSymbolList(ptTail);
result = SDF_makeSymbolSeq(SDF_makeLayoutEmpty(),
sdfHead,
SDF_makeLayoutSpace(),
sdfSymbolTail,
SDF_makeLayoutEmpty());
}
}
else if (PT_isSymbolOpt(ptSymbol)) {
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
result = SDF_makeSymbolOpt(sdfSymbol, SDF_makeLayoutEmpty());
}
else if (PT_isSymbolAlt(ptSymbol)) {
SDF_Symbol sdfLhs = PTSymbolToSDFSymbol(PT_getSymbolLhs(ptSymbol));
SDF_Symbol sdfRhs = PTSymbolToSDFSymbol(PT_getSymbolRhs(ptSymbol));
result = SDF_makeSymbolAlt(sdfLhs,
SDF_makeLayoutEmpty(),
SDF_makeLayoutEmpty(),
sdfRhs);
}
else if (PT_isSymbolTuple(ptSymbol)) {
SDF_Symbol sdfHead = PTSymbolToSDFSymbol(PT_getSymbolHead(ptSymbol));
SDF_SymbolRest sdfRest = PTSymbolsToSDFSymbolRest(PT_getSymbolRest(ptSymbol));
result = SDF_makeSymbolTuple(SDF_makeLayoutEmpty(),
sdfHead,
SDF_makeLayoutEmpty(),
SDF_makeLayoutEmpty(),
sdfRest,
SDF_makeLayoutEmpty());
}
else if (PT_isSymbolSort(ptSymbol)) {
char *str = PT_getSymbolSort(ptSymbol);
SDF_Sort sort = SDF_makeSortMoreChars(SDF_makeCHARLISTString(str));
result = SDF_makeSymbolSort(sort);
}
else if (PT_isSymbolIterPlus(ptSymbol)) {
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
result = SDF_makeSymbolIter(sdfSymbol, SDF_makeLayoutEmpty());
}
else if (PT_isSymbolIterStar(ptSymbol)) {
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
result = SDF_makeSymbolIterStar(sdfSymbol, SDF_makeLayoutEmpty());
}
else if (PT_isSymbolIterPlusSep(ptSymbol)) {
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
SDF_Symbol sdfSep = PTSymbolToSDFSymbol(PT_getSymbolSeparator(ptSymbol));
result = SDF_makeSymbolIterSep(SDF_makeLayoutEmpty(),
sdfSymbol,
SDF_makeLayoutSpace(),
sdfSep,
SDF_makeLayoutEmpty(),
SDF_makeLayoutEmpty());
}
else if (PT_isSymbolIterStarSep(ptSymbol)) {
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
SDF_Symbol sdfSep = PTSymbolToSDFSymbol(PT_getSymbolSeparator(ptSymbol));
result = SDF_makeSymbolIterStarSep(SDF_makeLayoutEmpty(),
sdfSymbol,
SDF_makeLayoutSpace(),
sdfSep,
SDF_makeLayoutEmpty(),
SDF_makeLayoutEmpty());
}
else if (PT_isSymbolIterN(ptSymbol)) {
char str[BUFSIZ];
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
int nr = PT_getSymbolNumber(ptSymbol);
SDF_NatCon sdfNatCon;
sprintf(str, "%d", nr);
sdfNatCon = SDF_makeNatConDigits(SDF_makeCHARLISTString(str));
result = SDF_makeSymbolIterN(sdfSymbol,
SDF_makeLayoutSpace(),
sdfNatCon,
SDF_makeLayoutEmpty());
}
else if (PT_isSymbolIterSepN(ptSymbol)) {
char str[BUFSIZ];
SDF_Symbol sdfSymbol = PTSymbolToSDFSymbol(PT_getSymbolSymbol(ptSymbol));
SDF_Symbol sdfSep = PTSymbolToSDFSymbol(PT_getSymbolSeparator(ptSymbol));
int nr = PT_getSymbolNumber(ptSymbol);
SDF_NatCon sdfNatCon;
sprintf(str, "%d", nr);
sdfNatCon = SDF_makeNatConDigits(SDF_makeCHARLISTString(str));
result = SDF_makeSymbolIterSepN(SDF_makeLayoutEmpty(),
sdfSymbol,
SDF_makeLayoutSpace(),
sdfSep,
SDF_makeLayoutEmpty(),
SDF_makeLayoutEmpty(),
sdfNatCon,
SDF_makeLayoutEmpty());
}
else if (PT_isSymbolLayout(ptSymbol)) {
ATabort("PTSymbolToSDFSymbol: layout.\n");
result = NULL;
}
else {
ATabort("PTSymbolToSDFSymbol: unable to convert symbol %t: %s\n",
ptSymbol, PT_yieldSymbol(ptSymbol));
result = NULL;
}
return result;
}
