static void ExpandInline(CatExpr fxns, PushFunction q, int nMaxDepth)
{
CatExpr tmp = new CatExpr();
foreach (Function f in q.GetChildren())
{
ExpandInline(tmp, f, nMaxDepth - 1);
}
fxns.Add(new PushFunction(tmp));
}
private static void ApplyMacrosInner(INameLookup names, CatExpr fxns)
{
// Recursively apply macros for all quotations.
for (int i = 0; i < fxns.Count; ++i)
{
if (fxns[i] is PushFunction)
{
PushFunction qf = fxns[i] as PushFunction;
CatExpr tmp = new CatExpr(qf.GetChildren());
ApplyMacros(names, tmp);
fxns[i] = new PushFunction(tmp);
}
}
// This could be done multiple time
List <MacroMatch> matches = new List <MacroMatch>();
// The peephole is the maximum size of the range of functions that we will consider
// for rewriting. This helps to reduces the overall complexity of the algorithm.
//int nPeephole = 20;
// This is the maximum size of the sub-expression that will be considered for matching.
int nMaxSubExpr = 10;
// Find matches
int nLastMatchPos = -1;
for (int nPos = 0; nPos < fxns.Count; ++nPos)
{
string s = fxns[nPos].msName;
if (mMacros.ContainsKey(s))
{
foreach (AstMacro m in mMacros[s])
{
MacroMatch match = MacroMatch.Create(m, fxns, nLastMatchPos, nPos, nMaxSubExpr);
if (match != null)
{
nLastMatchPos = nPos;
matches.Add(match);
}
}
}
}
// Replace matches
for (int i = matches.Count - 1; i >= 0; --i)
{
MacroMatch m = matches[i];
List <AstMacroTerm> pattern = m.mMacro.mDest.mPattern;
m.Replace(names, fxns, pattern);
}
}
public static Function ValueToFunction(Object o)
{
if (o is Int32)
{
return(new PushInt((int)o));
}
else if (o is Double)
{
return(new PushValue <double>((double)o));
}
else if (o is String)
{
return(new PushValue <string>((string)o));
}
else if (o is Boolean)
{
bool b = (bool)o;
if (b)
{
return(new Primitives.True());
}
else
{
return(new Primitives.False());
}
}
else if (o is CatList)
{
return(new PushValue <CatList>(o as CatList));
}
else if (o is QuotedFunction)
{
QuotedFunction qf = o as QuotedFunction;
CatExpr fxns = qf.GetSubFxns();
PushFunction q = new PushFunction(fxns);
return(q);
}
else
{
throw new Exception("Partial evaluator does not yet handle objects of type " + o);
}
}
public bool DoesTokenMatch(AstMacroTerm tkn, CatExpr x, out bool bRecoverable)
{
bRecoverable = true;
if (tkn is AstMacroName)
{
bRecoverable = false;
if (x.Count != 1)
{
return(false);
}
Function f = x[0];
string sName = f.GetName();
return(sName == tkn.ToString());
}
else if (tkn is AstMacroTypeVar)
{
if (x.GetFxnType() == null)
{
return(false);
}
if (!CatFxnType.CompareFxnTypes(x.GetFxnType(), CatFxnType.PushSomethingType))
{
return(false);
}
mCapturedVars.Add(tkn.ToString(), x);
return(true);
}
else if (tkn is AstMacroQuote)
{
AstMacroQuote macroQuote = tkn as AstMacroQuote;
if (x.Count != 1)
{
return(false);
}
PushFunction quote = x[0] as PushFunction;
if (quote == null)
{
return(false);
}
for (int i = 0; i < macroQuote.mTerms.Count; ++i)
{
// Are we are at a stack variable in the matching pattern
// if so it must be the last token in the pattern
// e.g. [1 2 $A] is legal [1 $A 2] is not.
if (macroQuote.mTerms[i] is AstMacroStackVar)
{
if (i != macroQuote.mTerms.Count - 1)
{
throw new Exception("within a quotation, expression variables can only be used in the right-most postition");
}
AstMacroStackVar v = macroQuote.mTerms[0] as AstMacroStackVar;
CatExpr expr = quote.GetChildren().GetRangeFrom(i);
mCapturedVars.Add(v.msName, expr);
return(true);
}
else if (macroQuote.mTerms[i] is AstMacroName)
{
// Well this is just an ordinary name pattern
AstMacroName name = macroQuote.mTerms[i] as AstMacroName;
if (quote.GetChildren().Count <= i)
{
return(false);
}
Function f = quote.GetChildren()[i];
if (!f.GetName().Equals(name.ToString()))
{
return(false);
}
}
else
{
return(false);
}
}
// No stack variable was encountered in the pattern
// therefore the match must have been perfect, which means there are no
// more terms in the input
if (quote.GetChildren().Count != macroQuote.mTerms.Count)
{
return(false);
}
return(true);
}
else if (tkn is AstMacroStackVar)
{
AstMacroStackVar v = tkn as AstMacroStackVar;
if (v.mType == null)
{
return(false);
}
if (x.GetFxnType() == null)
{
return(false);
}
if (!CatFxnType.CompareFxnTypes(x.GetFxnType(), v.mType))
{
return(false);
}
mCapturedVars.Add(v.msName, x);
return(true);
}
else
{
throw new Exception("unrecognized macro term " + tkn.ToString());
}
}
public CatExpr PatternToFxns(INameLookup names, List <AstMacroTerm> pattern)
{
CatExpr ret = new CatExpr();
foreach (AstMacroTerm t in pattern)
{
if (t is AstMacroTypeVar)
{
string s = t.ToString();
if (!mCapturedVars.ContainsKey(s))
{
throw new Exception("macro variable " + s + " was not captured");
}
CatExpr expr = mCapturedVars[s];
ret.AddRange(expr);
}
else if (t is AstMacroStackVar)
{
string s = (t as AstMacroStackVar).msName;
if (!mCapturedVars.ContainsKey(s))
{
throw new Exception("macro variable " + s + " was not captured");
}
CatExpr expr = mCapturedVars[s];
ret.AddRange(expr);
}
else if (t is AstMacroName)
{
string s = t.ToString();
if (s.Length < 1)
{
throw new Exception("internal error: macro name is empty string");
}
Function f = names.ThrowingLookup(s);
if (f == null)
{
if (Char.IsDigit(s[0]))
{
f = new PushInt(int.Parse(s));
}
else
{
throw new Exception("Could not find function " + s);
}
}
ret.Add(f);
}
else if (t is AstMacroQuote)
{
// TODO: handle typed terms within a quotation.
AstMacroQuote macroQuote = t as AstMacroQuote;
List <AstMacroTerm> localPattern = macroQuote.mTerms;
PushFunction q = new PushFunction(PatternToFxns(names, localPattern));
ret.Add(q);
}
else
{
throw new Exception("unrecognized macro term " + t.ToString());
}
}
return(ret);
}
/// <summary>
/// We attempt to execute an expression (list of functions) on an empty stack.
/// When no exception is raised we know that the subexpression can be replaced with anything
/// that generates the values.
/// </summary>
static CatExpr PartialEval(Executor exec, CatExpr fxns)
{
// Recursively partially evaluate all quotations
for (int i = 0; i < fxns.Count; ++i)
{
Function f = fxns[i];
if (f is PushFunction)
{
PushFunction q = f as PushFunction;
CatExpr tmp = PartialEval(new Executor(), q.GetSubFxns());
fxns[i] = new PushFunction(tmp);
}
}
CatExpr ret = new CatExpr();
object[] values = null;
int j = 0;
while (j < fxns.Count)
{
try {
Function f = fxns[j];
if (f is DefinedFunction)
{
f.Eval(exec);
}
else
{
if (f.GetFxnType() == null)
{
throw new Exception("no type availables");
}
if (f.GetFxnType().HasSideEffects())
{
throw new Exception("can't perform partial execution when an expression has side-effects");
}
f.Eval(exec);
}
// at each step, we have to get the values stored so far
// since they could keep changing and any exception
// will obliterate the old values.
values = exec.GetStackAsArray();
} catch {
if (values != null)
{
// Copy all of the values from the previous good execution
for (int k = values.Length - 1; k >= 0; --k)
{
ret.Add(ValueToFunction(values[k]));
}
}
ret.Add(fxns[j]);
exec.Clear();
values = null;
}
j++;
}
if (values != null)
{
for (int l = values.Length - 1; l >= 0; --l)
{
ret.Add(ValueToFunction(values[l]));
}
}
return(ret);
}