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));
}
