std::string SymbolTable::ReplaceStringFrom(std::string src, std::string const& from)
{
size_t pos = from.find('$');
if (std::string::npos == pos)
{
return src;
}
char const* dollarSign = from.c_str() + pos;
int length = lengthOfSymbol(dollarSign + 1);
std::string symbol(dollarSign, length + 1);
try
{
std::string symbolValue = GetValue(dollarSign + 1, length);
boost::algorithm::replace_all(src
, symbol
, symbolValue);
return ReplaceStringFrom(src, src);
}
catch (std::exception const&)
{
// eat exception.
}
// We are running out of data.
if (from.size() == (pos + 1))
{
return src;
}
return ReplaceStringFrom(src, dollarSign + 1);
}
static char* replaceStringFrom(SymbolTable* symbolTable, const char* string, const char* from) {
char * dollarSign = strpbrk(from, "$");
if (dollarSign)
{
int length = lengthOfSymbol(dollarSign + 1);
const char * symbolValue = SymbolTable_FindSymbol(symbolTable, dollarSign + 1, length);
if (symbolValue)
{
int valueLength = strlen(symbolValue);
int bufferLength = strlen(string)+valueLength-(length+1) + 1;
char * newString = malloc(bufferLength);
memset(newString, 0, bufferLength);
strncat(newString, string, (dollarSign - string));
strcat(newString, symbolValue);
strcat(newString, dollarSign + 1 + length);
assert(bufferLength == strlen(newString) + 1);
char* recursedString = replaceStringFrom(symbolTable, newString, newString);
free(newString);
return recursedString;
}
else
{
if (*(dollarSign+1) == 0)
return buyString(string);
return replaceStringFrom(symbolTable, string, dollarSign+1);
}
}
return buyString(string);
}
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);
}
}
static int lengthOfSymbols(PT_Symbols symbols)
{
int length = 0;
while (PT_hasSymbolsHead(symbols)) {
length = length + lengthOfSymbol(PT_getSymbolsHead(symbols)) + 1;
symbols = PT_getSymbolsTail(symbols);
}
return length;
}
char *PT_yieldSymbol(PT_Symbol symbol) {
static char *buffer = NULL;
static int bufferSize = 0;
int idx = 0;
int len;
len = lengthOfSymbol(symbol) + 1;
if (len > bufferSize) {
buffer = (char *)realloc(buffer, len*sizeof(char));
bufferSize = len;
}
idx = yieldSymbol(symbol, idx, buffer, len);
assert(idx <= len);
buffer[idx++] = '\0';
return buffer;
}
char *PT_yieldSymbolVisualVariables(PT_Symbol symbol) {
static char *buffer = NULL;
static int bufferSize = 0;
int idx = 0;
int len;
len = strlen(VARIABLE " ") + lengthOfSymbol(symbol) + 1;
if (len > bufferSize) {
buffer = (char *)realloc(buffer, len*sizeof(char));
bufferSize = len;
}
strcpy(buffer, VARIABLE " ");
idx = strlen(VARIABLE " ");
idx = yieldSymbol(symbol, idx, buffer, len);
assert(idx <= len);
buffer[idx++] = '\0';
return buffer;
}
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;
}
