public static Delegate CompileLambda(Node n)
{
var compiler = new SchemeExpressionCompiler();
var expr = (LambdaExpression)compiler.ToExpr(n);
if (expr == null) return null;
return expr.Compile();
}
Node ToAssignment(Node left, string op, Node right)
{
var assignOp = new Node("AssignOp", "=");
var binOp = new Node("Binaryop", op);
var binExpr = new Node("BinaryExpr", left, binOp, right);
return new Node("AssignExpr", left, assignOp, binExpr);
}
public static Delegate CompileLambda(Node n)
{
var compiler = new CSharpFunctionCompiler();
var expr = compiler.ToExpr(n) as LambdaExpression;
if (expr == null) return null;
return expr.Compile();
}
public Printer PrintLine(Node n)
{
Print(n);
sb.AppendLine();
sb.Append(LineBeginning);
return this;
}
public dynamic GetOperand(Node n)
{
Debug.Assert(n.Count == 2);
string type = n[0].Text;
string value = n[1].Text;
switch (type.ToLower())
{
case "byte": return Byte.Parse(value);
case "int16": return Int16.Parse(value);
case "int32": return Int32.Parse(value);
case "int64": return Int64.Parse(value);
case "uint16": return UInt16.Parse(value);
case "uint32": return UInt32.Parse(value);
case "uint64": return UInt64.Parse(value);
case "float": return float.Parse(value);
case "double": return double.Parse(value);
case "decimal": return decimal.Parse(value);
case "string": return value.Substring(1, value.Length - 2);
case "char": return char.Parse(value.Substring(1, value.Length - 2));
case "function": return GetMethodFromNode(n[1]);
case "type": return GetTypeFromNode(n[1]);
case "var": return vars[value];
case "label": return GetOrCreateLabel(value);
default: throw new Exception("Unreocognized operand type " + type);
}
}
public Expression ToExpr(Node node)
{
switch (node.Label)
{
case "Integer":
return Expression.Constant(int.Parse(node.Text));
case "Float":
return Expression.Constant(double.Parse(node.Text));
case "String":
return Expression.Constant(node.Text.Substring(1, node.Text.Length - 2));
case "SExpr":
return SExprToExpr(node);
case "Symbol":
return Lookup(node.Text);
case "Param":
return Expression.Parameter(typeof(Object), node[0].Text);
case "Term":
return ToExpr(node[0]);
case "Atom":
return ToExpr(node[0]);
case "Lambda":
return CreateExpressionLambda(node["ParamList"].Nodes.Select(ToExpr)
.OfType<ParameterExpression>().ToArray(), () => ToExpr(node["Term"]));
case "Begin":
return Expression.Block(node.Nodes.Select(n => ToExpr(n)));
case "Let":
return LetToExpr(node);
case "If":
return node.Count == 3
? Expression.IfThenElse(ToExpr(node[0]), ToExpr(node[1]), ToExpr(node[2]))
: Expression.IfThen(ToExpr(node[0]), ToExpr(node[1]));
default:
throw new Exception("Unrecognized node type " + node.Label);
}
}
/// <summary>
/// Возвращает новый экземпляр <see cref="T" />, построенный по заданному AST-дереву.
/// </summary>
/// <param name="node">Корень AST-дерева.</param>
/// <returns>
/// Возвращает новый экземпляр <see cref="T" />, построенный по заданному AST-дереву.
/// </returns>
public ILogicalQuery Build(Diggins.Jigsaw.Node node)
{
Node actionList = node[ProductionActionGrammar.ProductionActionList.Name];
List <IKnowledgeBaseAction> actions = new List <IKnowledgeBaseAction>();
List <ProductionFact> queriedFacts = new List <ProductionFact>();
foreach (var n in node.Nodes)
{
if (n.Label == ProductionActionGrammar.ProductionActionList.Name)
{
foreach (var action in n.Nodes)
{
actions.Add(actionBuilders[action.Label].Build(action));
}
}
else if (n.Label == ProductionQueryGrammar.FactName.Name)
{
queriedFacts.Add(new ProductionFact(n.Text, null));
}
else if (n.Label == ProductionQueryGrammar.Property.Name)
{
queriedFacts[queriedFacts.Count - 1].Value = n.Text;
}
}
return(new ProductionFactQuery(actions, queriedFacts));
}
public void CacheResult(Rule rule, int pos, Node node)
{
if (!cache.ContainsKey(pos))
cache.Add(pos, new Dictionary<Rule, Node>());
var tmp = cache[pos];
if (!tmp.ContainsKey(rule))
tmp.Add(rule, node);
}
public static Delegate CompileLambda(Node n)
{
n = JavaScriptTransformer.Transform(n);
var compiler = new JavaScriptExpressionCompiler();
var expr = (LambdaExpression)compiler.ToExpr(n);
if (expr == null) return null;
return expr.Compile();
}
/// <summary>
/// По заданному дереву строит <see cref="ExpertSystemShell.KnowledgeBases.ProductionModel.IKnowledgeBaseAction" />.
/// </summary>
/// <param name="node">Корень дерева разбора..</param>
/// <returns>
/// Возвращает построенный экземпляр <see cref="ExpertSystemShell.KnowledgeBases.ProductionModel.IKnowledgeBaseAction" />.
/// </returns>
public KnowledgeBases.IKnowledgeBaseAction Build(Diggins.Jigsaw.Node node)
{
Node fact = node[0];
string name = fact[ProductionFactGrammar.Property.Name].Text;
string value = fact[ProductionFactGrammar.Value.Name].Text;
return(new AddFactAction(new ProductionFact(name, value)));
}
public Expression SExprToExpr(Node node)
{
var terms = node["Terms"];
var head = terms[0];
var mi = typeof(Primitives).GetMethod(head.Text);
if (mi == null) throw new Exception("Could not find primitive named " + head.Text);
var args = terms.Nodes.Skip(1).Select(n => ToExpr(n));
return Expression.Call(mi, args);
}
public bool GetCachedResult(NodeRule rule, out Node node)
{
node = null;
if (!cache.ContainsKey(pos))
return false;
if (cache[pos].ContainsKey(rule))
{
node = cache[pos][rule];
return true;
}
return false;
}
public Expression LetToExpr(Node node)
{
var exprs = new List<Expression>();
foreach (var binding in node[0].Nodes) {
var name = binding[0].Text;
var param = AddBinding(Expression.Parameter(typeof(Object), name));
exprs.Add(param);
exprs.Add(Expression.Assign(Lookup(name), ToExpr(binding[1])));
}
exprs.Add(ToExpr(node["Term"]));
return Expression.Block(exprs);
}
public static object Parse(Node node)
{
switch (node.Label)
{
case "Integer": return Int32.Parse(node.Text);
case "String": return node.Text;
case "Atom": return Parse(node[0]);
case "Term": return Parse(node[0]);
case "SExpr": return Build(node["Terms"].Nodes.Select(Parse));
case "Symbol": return node.Text;
default: throw new Exception("Unrecognized node type " + node.Label);
}
}
public static dynamic Eval(Node n)
{
switch (n.Label)
{
case "Number": return Eval(n[0]);
case "Integer": return Int64.Parse(n.Text);
case "Float": return Double.Parse(n.Text);
case "PrefixExpr":
switch (n[0].Text)
{
case "-": return -Eval(n[1]);
case "!": return !Eval(n[1]);
case "~": return ~Eval(n[1]);
default: throw new Exception(n[0].Text);
}
case "ParanExpr": return Eval(n[0]);
case "Expression":
switch (n.Count)
{
case 1:
return Eval(n[0]);
case 3:
switch (n[1].Text)
{
case "+": return Eval(n[0]) + Eval(n[2]);
case "-": return Eval(n[0]) - Eval(n[2]);
case "*": return Eval(n[0]) * Eval(n[2]);
case "/": return Eval(n[0]) / Eval(n[2]);
case "%": return Eval(n[0]) % Eval(n[2]);
case "<<": return Eval(n[0]) << Eval(n[2]);
case ">>": return Eval(n[0]) >> Eval(n[2]);
case "==": return Eval(n[0]) == Eval(n[2]);
case "!=": return Eval(n[0]) != Eval(n[2]);
case "<=": return Eval(n[0]) <= Eval(n[2]);
case ">=": return Eval(n[0]) >= Eval(n[2]);
case "<": return Eval(n[0]) < Eval(n[2]);
case ">": return Eval(n[0]) > Eval(n[2]);
case "&&": return Eval(n[0]) && Eval(n[2]);
case "||": return Eval(n[0]) || Eval(n[2]);
case "&": return Eval(n[0]) & Eval(n[2]);
case "|": return Eval(n[0]) | Eval(n[2]);
default: throw new Exception("Unreocognized operator " + n[1].Text);
}
default:
throw new Exception(String.Format("Unexpected number of nodes {0} in expression", n.Count));
}
default:
throw new Exception("Unexpected type of node " + n.Label);
}
}
public void Eval(Node n)
{
switch (n.Label)
{
case "Integer": Push(Int32.Parse(n.Text)); break;
case "String": Push(n.Text.Substring(1, n.Text.Length - 2)); break;
case "Quotation": Push(n); break;
case "Terms": foreach (var t in n.Nodes) Eval(t); break;
case "Term": Eval(n.Nodes[0]); break;
case "Atom": Eval(n.Nodes[0]); break;
case "Symbol": Eval(Functions[n.Text]); break;
case "Define": Functions.Add(n.GetNode("Symbol").Text, n.GetNode("Terms")); break;
default: throw new Exception("Can't evaluate node of type " + n.Label);
}
}
public JSFunction(VarBindings c, Node n) {
capture = c;
node = n;
if (n.Count == 3)
{
name = n[0].Text;
parms = n[1];
body = n[2];
}
else
{
parms = n[0];
body = n[1];
}
}
public void EmitTerm(Node n)
{
switch (n.Label)
{
case "Label":
{
var name = n["Name"].Text;
g.MarkLabel(GetOrCreateLabel(name));
}
break;
case "Statement":
{
EmitTerm(n[0]);
}
break;
case "Block":
{
foreach (var n2 in n.Nodes)
EmitTerm(n2);
}
break;
case "VarDecl":
{
var name = n["Name"].Text;
var type = GetTypeFromNode(n["DotName"]);
var decl = g.DeclareLocal(type);
vars.Add(name, decl);
}
break;
case "OpStatement":
{
var opcode = GetOpCode(n[0].Text);
if (n.Count > 1)
{
dynamic d = GetOperand(n[1]);
g.Emit(opcode, d);
}
else
{
g.Emit(opcode);
}
}
break;
default:
throw new Exception("Unrecognized node type " + n.Label);
}
}
/// <summary>
/// По заданному дереву строит экземпляр <see cref="ExpertSystemShell.KnowledgeBases.ILogicalStatement" />.
/// </summary>
/// <param name="node">Корень дерева разбора.</param>
/// <returns>
/// Возвращает построенный экземпляр <see cref="ExpertSystemShell.KnowledgeBases.ILogicalStatement" />.
/// </returns>
public KnowledgeBases.ILogicalStatement Build(Diggins.Jigsaw.Node node)
{
Node condition = node[ProductionExprGrammar.Expression.Name];
Node name = node.Nodes.FirstOrDefault((a) =>
{ return(a.Label == ProductionRuleGrammar.Name.Name); });
Node actionList = node.Nodes.FirstOrDefault((a) =>
{ return(a.Label == ProductionActionGrammar.ProductionActionList.Name); });
Expression expression = eh.CreateExpression(condition);
string ruleName = name == null ? null : name.Text;
List <IKnowledgeBaseAction> actions = new List <IKnowledgeBaseAction>();
foreach (var n in actionList.Nodes)
{
actions.Add(builders[n.Label].Build(n));
}
return(new ProductionRule(ruleName, expression, actions));
}
public abstract Printer Print(Node n);
public override Printer Print(Node n)
{
switch (n.Label)
{
case "Script":
return Print(n.Nodes);
case "Statement":
return Print(n[0]);
case "Empty":
return Print(";");
case "Return":
return (n.Count > 0)
? Print("return ").Print(n[0]).Print(";")
: Print("return;");
case "ExprStatement":
return Print(n[0]).Print(";");
case "If":
Print("if (").Print(n[0]).Print(")").Indent().Print(n[1]).Unindent();
return n.Count > 2
? Print(n[2])
: this;
case "Else":
return Print("else").Indent().Print(n[0]).Unindent();
case "For":
return Print("for (").Print(n[0]).Print(";").Print(n[1]).Print(";").Print(n[2]).Print(") ").Indent().Print(n[3]).Unindent();
case "While":
return Print("while (").Print(n[0]).Print(") ") .Indent().Print(n[1]).Unindent();
case "VarDecl":
return (n.Count > 1)
? Print("var ").Print(n[0]).Print(" = ").Print(n[1]).Print(";")
: Print("var ").Print(n[0]).Print(";");
case "Block":
if (n.Count > 0)
{
Print("{").Indent();
foreach (var n2 in n.Nodes.Take(n.Count - 1))
PrintLine(n2);
return Print(n[n.Count - 1]).Unindent().Print("}");
}
else
{
return Print("{}");
}
case "Expr":
return Print(n[0]);
case "TertiaryExpr":
return (n.Count == 3)
? Print(n[0]).Print(" ? ").Print(n[1]).Print(" : ").Print(n[2])
: Print(n[0]);
case "AssignOp":
case "BinaryOp":
return Print(" ").Print(n.Text).Print(" ");
case "PostfixOp":
case "PrefixOp":
return Print(n.Text);
case "BinaryExpr":
case "AssignExpr":
case "PostfixExpr":
return Print(n.Nodes);
case "NewExpr":
return Print("new ").Print(n.Nodes);
case "ParenExpr":
return Print("(").Print(n[0]).Print(")");
case "Field":
return Print(".").Print(n.Nodes);
case "Index":
return Print("[").Print(n.Nodes).Print("]");
case "ArgList":
return Print("(").Print(n.Nodes, ", ").Print(")");
case "NamedFunc":
return Print("function ").Print(n[0]).Print(n[1]).Print(" ").Indent().Print(n[2]).Unindent();
case "AnonFunc":
return Print("function ").Print(n[0]).Print(" ").Indent().Print(n[1]).Unindent();
case "ParamList":
return Print("(").Print(n.Nodes, ", ").Print(")");
case "Object":
return Print("{").Indent().Print(n.Nodes, ", ").Unindent().Print("}");
case "Array":
return Print("[").Indent().Print(n.Nodes, ", ").Unindent().Print("]");
case "Pair":
return Print(n[0]).Print(" : ").Print(n[1]);
case "PairName":
return Print(n[0]);
case "Literal":
return Print(n[0]);
case "Identifier":
case "String":
case "Integer":
case "Float":
case "True":
case "False":
case "Null":
return Print(n.Text);
default:
throw new Exception("Unrecognized node type " + n.Label);
}
}
protected virtual Node InternalTransform(Node n) { return n; }
protected static bool HasChild(Node n, string label)
{
return n.Nodes.Any(x => x.Label == label);
}
protected static bool IsFirstChild(Node n, string label)
{
return IsNthChild(n, 0, label);
}
protected static bool IsLastChild(Node n, string label)
{
if (n.Count == 0) return false;
return IsNthChild(n, n.Count - 1, label);
}
public static Stack<dynamic> Eval(Node node)
{
var cat = new CatEvaluator();
cat.Eval(node);
return cat.Values;
}
protected Node TransformAlNodes(Node n)
{
n.Nodes = n.Nodes.Select(TransformAlNodes).ToList();
return InternalTransform(n);
}
public static string ToString(Node n)
{
return new JavaScriptSourcePrinter().Print(n).GetStringBuilder().ToString();
}
public Expression ToExpr(Node n)
{
switch (n.Label)
{
case "Expr":
return ToExpr(n[0]);
case "TertiaryExpr":
if (n.Count > 1)
return Expression.Condition(ToExpr(n[0]), ToExpr(n[1]), ToExpr(n[2]));
else
return ToExpr(n[0]);
case "AssignExpr":
throw new NotImplementedException();
case "BinaryExpr":
if (n.Count > 1)
return CreateBinaryExpression(n[1].Text, ToExpr(n[0]), ToExpr(n[2]));
else
return ToExpr(n[0]);
case "UnaryExpr":
{
var x = ToExpr(n[0]);
for (int i = 1; i < n.Count; ++i)
{
switch (n[i].Label)
{
case "Inc":
x = Expression.Increment(x);
break;
case "Dec":
x = Expression.Decrement(x);
break;
case "Indexer":
x = Expression.ArrayIndex(x, ToExpr(n[i][0]));
break;
case "ArgList":
x = Expression.Invoke(x, n[1].Nodes.Select(ToExpr));
break;
case "Selector":
x = Expression.Field(x, n[i][0].Text);
break;
default:
throw new Exception("Unrecognized postfix operator " + n[i].Label);
}
}
return x;
}
case "PrefixExpr":
if (n[0].Label == "LeafExpr")
return ToExpr(n[0]);
switch (n[0].Text)
{
case "++":
return Expression.PreIncrementAssign(ToExpr(n[1]));
case "--":
return Expression.PreDecrementAssign(ToExpr(n[1]));
case "!":
return Expression.Not(ToExpr(n[1]));
case "-":
return Expression.Negate(ToExpr(n[1]));
case "~":
return Expression.OnesComplement(ToExpr(n[1]));
default:
throw new Exception("Unrecognized prefix operator " + n[0].Text);
}
case "LeafExpr":
return ToExpr(n[0]);
case "ParenthesizedExpr":
return ToExpr(n[0]);
case "NewExpr":
throw new NotImplementedException();
case "Identifier":
return Lookup(n.Text);
case "Integer":
return Expression.Constant(Int32.Parse(n.Text));
case "Float":
return Expression.Constant(Double.Parse(n.Text));
case "String":
return Expression.Constant(n.Text.StripQuotes());
case "UntypedLambdaParam":
return Expression.Parameter(typeof(Object), n[0].Text);
case "TypedLambdaParam":
return Expression.Parameter(Utilities.GetType(n[0].Text), n[1].Text);
case "LambdaExpr":
var ps = n[0].Nodes.Select(ToExpr).OfType<ParameterExpression>();
if (n[1].Label == "Block")
return CreateStatementLambda(ps, () => ToExpr(n[1]));
else
return CreateExpressionLambda(ps, () => ToExpr(n[1]));
case "Block":
return ScopedExpr(() => Expression.Block(n.Nodes.Select(ToExpr)));
case "ExprStatement":
return Expression.Block(ToExpr(n[0]));
case "ReturnStatement":
if (n.Count > 0)
return Expression.Return(GetReturnTarget(), Expression.Constant(null)); else
return Expression.Return(GetReturnTarget(), ToExpr(n[0]));
case "Statement":
return ToExpr(n[0]);
default:
throw new Exception("Node type not handled " + n.Label);
}
}
public Type ToType(Node node)
{
return Utilities.GetType(node.Text.Trim());
}
protected static bool IsNthChild(Node node, int n, string label)
{
if (node.Count <= n) return false;
return node[n].Label == label;
}
protected Node LeftGroup(Node n, string leftLabel)
{
var leftChild = InternalTransform(new Node(n.Label, n.Nodes.Take(n.Count - 1)));
return new Node(leftLabel, leftChild, n.Nodes.Last());
}
/// <summary>
/// The node has to be transformed before being passed
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public Expression ToExpr(Node n)
{
switch (n.Label)
{
case "Empty":
return Noop;
case "Return":
return (n.Count > 0)
? Expression.Return(GetReturnTarget(), ToExpr(n[0]), typeof(Object))
: Expression.Return(GetReturnTarget(), Expression.Constant(typeof(Object), null));
case "If":
return n.Count > 2
? Expression.IfThenElse(Expression.Convert(ToExpr(n[0]), typeof(Boolean)), ToExpr(n[1]), ToExpr(n[2]))
: Expression.IfThen(Expression.Convert(ToExpr(n[0]), typeof(Boolean)), ToExpr(n[1]));
case "Else":
return ToExpr(n[0]);
case "For":
return CompileForLoop(ToExpr(n[0]), ToExpr(n[1]), ToExpr(n[2]), ToExpr(n[3]));
case "VarDecl":
{
var r = AddBinding(Expression.Variable(typeof(object), n[0].Text));
if (n.Count > 1)
r = Expression.Assign(r, ToExpr(n[1]));
return r;
}
case "Block":
return ScopedExpr(() => Expression.Block(n.Nodes.Select(ToExpr)));
case "TertiaryExpr":
return Expression.Condition(ToExpr(n[0]), ToExpr(n[1]), ToExpr(n[2]));
case "BinaryExpr":
return Expression.Call(null, Primitives.GetMethodFromBinaryOperator(n[1].Text), ToExpr(n[0]), ToExpr(n[2]));
case "AssignExpr":
return Expression.Assign(ToExpr(n[0]), ToExpr(n[2]));
case "FieldExpr":
return Expression.Field(ToExpr(n[0]), n[1].Text);
case "IndexExpr":
return CompileIndexExpr(ToExpr(n[0]), ToExpr(n[2]));
case "CallExpr":
return CompileCallExpr(ToExpr(n[0]), n[1].Nodes.Select(ToExpr));
case "MethodCallExpr":
{
var self = ToExpr(n[0]);
var func = Expression.Field(self, n[1].Text);
var args = new List<Expression>() { self };
args.AddRange(n[2].Nodes.Select(ToExpr));
return CompileCallExpr(func, args);
}
case "PrefixExpr":
switch (n[0].Text)
{
case "!": return Expression.Not(ToExpr(n[1]));
case "~": return Expression.OnesComplement(ToExpr(n[1]));
case "-": return Expression.Negate(ToExpr(n[1]));
default: throw new Exception("Unrecognized prefix operator " + n[0].Text);
}
case "NewExpr":
return ScopedExpr(() =>
{
AddBinding("this", Expression.Constant(new JsonObject()));
return ToExpr(n[0]);
});
case "ParenExpr":
return ToExpr(n[0]);
case "AnonFunc":
{
var ps = n[0].Nodes.Select(x => Expression.Parameter(typeof(Object), x.Text));
return CreateStatementLambda(ps, () => ToExpr(n[1]));
};
case "Object":
throw new NotImplementedException();
case "Array":
return Expression.NewArrayInit(typeof(object), n.Nodes.Select(ToExpr));
case "Identifier":
return Lookup(n.Text);
case "String":
return Expression.Constant(Utilities.Unquote(n.Text));
case "Integer":
return Expression.Convert(Expression.Constant(int.Parse(n.Text)), typeof(Object));
case "Float":
return Expression.Convert(Expression.Constant(float.Parse(n.Text)), typeof(Object));
case "True":
return Expression.Convert(Expression.Constant(true), typeof(Object));
case "False":
return Expression.Convert(Expression.Constant(false), typeof(Object));
case "Null":
return Expression.Constant(null);
default:
throw new Exception("Unrecognized node type " + n.Label);
}
}
