public override Expression Compile() { var left = LeftNode.Accept(Compiler); var right = RightNode.Accept(Compiler); if (left.NodeType == ExpressionType.Constant) { var value = (iObject)((ConstantExpression)left).Value; return(SelectBody(Object.ToBool(value), left, right)); } if (left.NodeType == ExpressionType.Parameter) { return(MakeCondition(CompilerUtils.ToBool(left), left, right)); } var leftVar = Variable(typeof(iObject)); return(Block( typeof(iObject), new[] { leftVar }, Assign(leftVar, left), MakeCondition(CompilerUtils.ToBool(leftVar), leftVar, right) )); }
public override Expression Compile() { var operand = Operand.Accept(Compiler); var visibility = Operand.GetVisibility(); return(CompilerUtils.Call(operand, Operator, visibility)); }
public override Expression Compile() { if (Node.List.Count == 0) { return(Array.Expressions.New()); } var words = new List <Expression>(); var contents = new List <Expression>(); foreach (var child in Node) { if (child.Token.Type == tSPACE) { var word = CreateWord(contents); words.Add(word); contents = new List <Expression>(); continue; } var content = child.Accept(Compiler); contents.Add(content); } return(CompilerUtils.NewArray(words.ToArray())); }
public override Expression Compile() { var instance = Operand.Accept(Compiler); var visibility = Operand.GetVisibility(); return(CompilerUtils.Call(instance, Symbol.NOT_OP, visibility)); }
public override Expression Compile() { var left = LeftNode.Accept(Compiler); var right = RightNode.Accept(Compiler); return(CompilerUtils.NewArray(left, right)); }
public override Expression Compile() { var left = LeftNode.Accept(Compiler); var right = RightNode.Accept(Compiler); left = ConvertToSymbol(left); return(CompilerUtils.NewArray(left.Cast <iObject>(), right)); }
public override Expression Compile() { var left = LeftNode.Accept(Compiler); var arguments = CompileArguments(); var visibility = LeftNode.GetVisibility(); return(CompilerUtils.Call(left, Symbol.AREF, visibility, arguments)); }
private Expression CreateWord(IEnumerable <Expression> contents) { Expression word = String.Expressions.New(); word = CompilerUtils.StringConcat(word, contents); word = word.StripConversions(); word = Wrap(word); return(word.Cast <iObject>()); }
public Expression Compile(AssignCompiler component) { var instance = component.Getter; var methodName = component.Operator; var argument = new InvocationArgument(ArgumentKind.Simple, component.Right); var call = CompilerUtils.Call(instance, methodName, component.Visibility, argument); return(component.Setter(call)); }
private void PreloadLibraries(IEnumerable <string> preloadLibraries) { importedLibraries.AddRange(preloadLibraries); foreach (var library in importedLibraries) { CompilerUtils.TryLoadAssemblyIntoCore(LibraryManagementCore, library); } }
private void PreloadLibraries() { importedLibraries.AddRange(DynamoPathManager.Instance.PreloadLibraries); foreach (var library in importedLibraries) { CompilerUtils.TryLoadAssemblyIntoCore(libraryManagementCore, library); } }
public override Expression Compile() { var left = LeftNode.Accept(Compiler); var right = RightNode.Accept(Compiler); var visibility = LeftNode.GetVisibility(); var argument = new InvocationArgument(ArgumentKind.Simple, right); return(CompilerUtils.Call(left, Operator, visibility, argument)); }
private SwitchCase CompileWhen(SyntaxNode node) { var condition = node[0].Accept(Compiler); condition = CompilerUtils.ToBool(condition); var body = node[1].Accept(Compiler); return(SwitchCase(body, condition)); }
private Expression ToBool(Expression condition) { condition = CompilerUtils.ToBool(condition); if (Node.Token.Type == kUNTIL || Node.Token.Type == kUNTIL_MOD) { condition = CompilerUtils.Negate(condition); } return(condition); }
public void ReproMAGN3603() { string code = @"a = 1 + (2 * 3); b = (1 + 2) * 3; c = 1 + 2 * 3;"; ElementResolver elementResolver = new ElementResolver(); ParseParam parseParam = new ParseParam(Guid.NewGuid(), code, elementResolver); Assert.IsTrue(CompilerUtils.PreCompileCodeBlock(thisTest.CreateTestCore(), ref parseParam)); Assert.IsTrue(parseParam.ParsedNodes != null && parseParam.ParsedNodes.Count() > 0); var parsedNode = parseParam.ParsedNodes.ElementAt(0); BinaryExpressionNode n = parsedNode as BinaryExpressionNode; FunctionCallNode funcCall = n.RightNode as FunctionCallNode; Assert.IsTrue(n != null && funcCall != null); IdentifierNode identNode = funcCall.Function as IdentifierNode; Assert.IsTrue(identNode != null && identNode.Value == "%add"); var args = funcCall.FormalArguments; Assert.IsTrue(args.Count == 2); Assert.IsTrue(args[0] is IntNode); FunctionCallNode nestedFuncCall = args[1] as FunctionCallNode; Assert.IsTrue(nestedFuncCall != null && (nestedFuncCall.Function as IdentifierNode).Value == "%mul"); parsedNode = parseParam.ParsedNodes.ElementAt(1); n = parsedNode as BinaryExpressionNode; funcCall = n.RightNode as FunctionCallNode; Assert.IsTrue(n != null && funcCall != null); identNode = funcCall.Function as IdentifierNode; Assert.IsTrue(identNode != null && identNode.Value == "%mul"); args = funcCall.FormalArguments; Assert.IsTrue(args.Count == 2); Assert.IsTrue(args[1] is IntNode); nestedFuncCall = args[0] as FunctionCallNode; Assert.IsTrue(nestedFuncCall != null && (nestedFuncCall.Function as IdentifierNode).Value == "%add"); parsedNode = parseParam.ParsedNodes.ElementAt(2); n = parsedNode as BinaryExpressionNode; funcCall = n.RightNode as FunctionCallNode; Assert.IsTrue(n != null && funcCall != null); identNode = funcCall.Function as IdentifierNode; Assert.IsTrue(identNode != null && identNode.Value == "%add"); args = funcCall.FormalArguments; Assert.IsTrue(args.Count == 2); Assert.IsTrue(args[0] is IntNode); nestedFuncCall = args[1] as FunctionCallNode; Assert.IsTrue(nestedFuncCall != null && (nestedFuncCall.Function as IdentifierNode).Value == "%mul"); }
public override Expression Compile() { var left = Label; left = left.Remove(left.Length - 1); var label = Constant(new Symbol(left), typeof(iObject)); var value = Value.Accept(Compiler); return(CompilerUtils.NewArray(label, value)); }
private Expression MakeCondition(Expression condition, Expression trueBody, Expression elseBody) { condition = CompilerUtils.ToBool(condition); if (Node.Token.Type == kUNLESS || Node.Token.Type == kUNLESS_MOD) { condition = CompilerUtils.Negate(condition); } return(Condition(condition, trueBody, elseBody, typeof(iObject))); }
public override Expression Compile() { var operand = Operand.Accept(Compiler); var convertCall = CompilerUtils.Call(operand, MethodName, Visibility.Private); return(Condition( TypeIs(operand, ElementType), operand, convertCall, typeof(iObject) )); }
private SwitchCase CompileWhen(SyntaxNode node, Expression caseValue, CallSite callSite) { var instance = node[0].Accept(Compiler); var arguments = NewArrayInit(typeof(iObject), caseValue); Expression condition = CallSite.Expressions.Call(Constant(callSite), instance, arguments); condition = CompilerUtils.ToBool(condition); var body = node[1].Accept(Compiler); return(SwitchCase(body, condition)); }
public void Case0_Should_RemoveBaseTypes2() { //Given var types = CompilerUtils.GetLinks(typeof(Class2)); Assume.That(types, Has.Exactly(2).Items); //When var interfaces = AssemblyAnalizer <object> .RemoveBaseTypes(types); //Then Assert.That(interfaces, Has.Exactly(1).Items); }
public Expression Compile(AssignCompiler component) { var getter = Variable(typeof(iObject), "getter"); var setter = component.Setter(component.Right); var condition = CompilerUtils.ToBool(getter); return(Block( typeof(iObject), new[] { getter }, Assign(getter, component.Getter), MakeCondition(condition, getter, setter) )); }
public override Expression Setter(Expression rightHandSide) { var rightVar = Variable(typeof(iObject), "right"); var rightArgument = new InvocationArgument(ArgumentKind.Simple, rightVar); return(Block( typeof(iObject), new[] { rightVar }, Assign(rightVar, rightHandSide), CompilerUtils.Call(instance, SetterMethodName, Visibility, rightArgument), rightVar )); }
/// <summary> /// Loads zero touch library module from given assembly. /// </summary> /// <param name="assembly"></param> public ZeroTouchModule(string assembly) { var core = CreateCore(); if (!CompilerUtils.TryLoadAssemblyIntoCore(core, assembly)) { throw new InvalidOperationException("Failed to load : " + assembly); } var library = new LibraryMirror(core, assembly, core.ClassTable.ClassNodes); types = library.GetClasses(); }
private void OnMenuStripClickBuild(object sender, EventArgs e) { TabPage tab = GetCurrentTabPage(); if (tab != null) { string pathToFile = ProjectUtils.GetFilePathForTreeNodeItem(tab.Name, tab.Text); if (!string.IsNullOrEmpty(pathToFile)) { CompilerUtils.AddToQueue(pathToFile); } } }
public void Init() { string libraryPath = "FFITarget.dll"; var options = new ProtoCore.Options(); options.RootModulePathName = string.Empty; libraryServicesCore = new ProtoCore.Core(options); libraryServicesCore.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(libraryServicesCore)); libraryServicesCore.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(libraryServicesCore)); CompilerUtils.TryLoadAssemblyIntoCore(libraryServicesCore, libraryPath); }
public override Expression Compile() { var first = String.Expressions.New(); var contents = Node.Select(_ => _.Accept(Compiler)); var body = CompilerUtils.StringConcat(first, contents); body = ((UnaryExpression)body).Operand; body = body.Cast <string>(); var symbol = Symbol.Expressions.New(body); return(symbol.Cast <iObject>()); }
public void TestUnboundIdentifierInUnnamedSignedExpression() { string code = @"a*-1;"; ElementResolver elementResolver = new ElementResolver(); ParseParam parseParam = new ParseParam(Guid.NewGuid(), code, elementResolver); Assert.IsTrue(CompilerUtils.PreCompileCodeBlock(thisTest.CreateTestCore(), ref parseParam)); Assert.IsTrue(parseParam.ParsedNodes != null && parseParam.ParsedNodes.Any()); var inputIdentifier = parseParam.UnboundIdentifiers; Assert.AreEqual(1, inputIdentifier.Count); Assert.AreEqual("a", inputIdentifier.ElementAt(0).Value); }
public static NodeRule <MessageInfo, DefaultLinkStyle> GetRule() { return(new NodeRule <MessageInfo, DefaultLinkStyle>((node, nodeRules, map) => { var attr = node.Info.Node.Attributes.FirstOrDefault(x => CompilerUtils.AttributeIs(x, typeof(ServiceNameAttribute))); if (attr != null) { var a = (ServiceNameAttribute)attr; var rank = (string)a._groupName; DefaultTheme.ServiceNames.SetValueIfNotExists(rank, new List <string>()); DefaultTheme.ServiceNames[rank].Add(node.Name); } })); }
public override Expression Compile() { var first = base.Compile(); var count = Node.List.Count; if (count == 0) { return(first); } var contents = Node.Select(_ => _.Accept(Compiler)); first = first.StripConversions(); return(CompilerUtils.StringConcat(first, contents)); }
public override Expression Compile() { var name = new Symbol(Identifier); var variable = Compiler.CurrentScope.FindVariable(name); if (variable != null) { return(variable.ValueExpression()); } var instance = Compiler.CurrentScope.Instance; var arguments = System.Array.Empty <InvocationArgument>(); return(CompilerUtils.Call(instance, name, Visibility.Private, arguments)); }