private bool BuildConfigurationAttribute(Expression node, Expression value, HashLiteralExpression configuration) { ArrayLiteralExpression attributes; if (MacroHelper.IsCompoundAssignment(value, out attributes)) { // @attrib1=value1, attrib2=value2: Multiple attributes foreach (var attribute in attributes.Items) { if (attribute == attributes.Items[0]) { configuration.Items.Add(new ExpressionPair(node, attribute)); } else if (BuildAttribute(attribute, configuration) == false) { return(false); } } } else { // @attrib=value: Single attribute configuration.Items.Add(new ExpressionPair(node, value)); } return(true); }
private bool BuildConfigurationChild(Expression child, Expression value, ICollection <Expression> attributes) { child = EnsureUniqueChild(child); if (attributes != null && attributes.Count > 0) { var childAttributes = new HashLiteralExpression(); if (value != null) { childAttributes.Items.Add(new ExpressionPair(new StringLiteralExpression("value"), value)); } // child=value, attrib2=value2: Child with attributes foreach (var attribute in attributes) { if (BuildAttribute(attribute, childAttributes) == false) { return(false); } } _configuration.Items.Add(new ExpressionPair(child, childAttributes)); } else { // child=value: Child without attributes _configuration.Items.Add(new ExpressionPair(child, value ?? new StringLiteralExpression(""))); } return(true); }
private HashLiteralExpression ObtainListeners(MacroStatement macro) { var listeners = new HashLiteralExpression(); var componentMethod = new ComponentMethodVisitor(); foreach (var statement in macro.Body.Statements) { var expression = statement as ExpressionStatement; if (expression == null || !(expression.Expression is MethodInvocationExpression)) { AddSubscriberSyntaxError(statement); return(null); } var mie = (MethodInvocationExpression)expression.Expression; var to = mie.Target as ReferenceExpression; if (to == null || mie.Arguments.Count != 1 || "to".Equals(to.Name, StringComparison.InvariantCultureIgnoreCase) == false) { AddSubscriberSyntaxError(statement); return(null); } var listener = mie.Arguments[0] as MemberReferenceExpression; if (listener == null || componentMethod.ExtractMethod(listener) == false) { AddSubscriberSyntaxError(statement); return(null); } listeners.Items.Add(new ExpressionPair(componentMethod.Component, componentMethod.Method)); } return(listeners); }
public override void OnHashLiteralExpression(HashLiteralExpression node) { BoundSpillSequenceBuilder builder = null; node.Items = VisitExpressionPairList(ref builder, node.Items); ReplaceCurrentNode(UpdateExpression(builder, node)); }
public override void Switch(IAstTransformer transformer, out Node resultingNode) { HashLiteralExpression thisNode = (HashLiteralExpression)this; Expression resultingTypedNode = thisNode; transformer.OnHashLiteralExpression(thisNode, ref resultingTypedNode); resultingNode = resultingTypedNode; }
private bool Build(Block block, bool attributesOnly, CompilerErrorCollection compileErrors) { _attributesOnly = attributesOnly; _compileErrors = compileErrors; _configuration = new HashLiteralExpression(); _childContext = new Dictionary <string, object>(); return(BuildHashConfiguration(block)); }
public override void LeaveHashLiteralExpression(HashLiteralExpression node) { foreach (ExpressionPair pair in node.Items) { CheckExpressionType(pair.First); CheckExpressionType(pair.Second); } }
public override void OnHashLiteralExpression(HashLiteralExpression node) { Write("{"); if (node.Items.Count > 0) { Write(" "); WriteCommaSeparatedList(node.Items); Write(" "); } Write("}"); }
private bool BuildAttribute(Expression expression, HashLiteralExpression configuration) { BinaryExpression attribute; if (MacroHelper.IsAssignment(expression, out attribute)) { BuildConfigurationNode(attribute, true, configuration); } else { _compileErrors.Add(CompilerErrorFactory.CustomError(expression.LexicalInfo, "Attributes must be in the format @attrib1=value1, attrib2=value2,...")); return(false); } return(true); }
private bool BuildConfigurationNode(BinaryExpression node, bool asAttribute, HashLiteralExpression configuration) { var nodeVisitor = new ConfigurationNodeVisitor(); if (!nodeVisitor.GetNode(node.Left, asAttribute, _compileErrors)) { return(false); } if (nodeVisitor.IsAttribute || asAttribute) { return(BuildConfigurationAttribute(nodeVisitor.Node, node.Right, configuration)); } if ((_skip = _attributesOnly) == false) { return(BuildConfigurationChild(nodeVisitor.Node, node.Right)); } return(true); }
protected override bool ExpandExtension(ref MethodInvocationExpression extension, MacroStatement macro, MacroStatement parent, ref Statement expansion) { Expression eventName = ObtainEventName(macro); if (eventName == null) { AddCompilerError(macro.LexicalInfo, "A wireEvent statement must be in the form wireEvent eventName"); return(false); } HashLiteralExpression listeners = ObtainListeners(macro); if (listeners != null && listeners.Items.Count > 0) { extension.Arguments.Add(eventName); extension.Arguments.Add(listeners); return(true); } return(false); }
public override void OnHashLiteralExpression(HashLiteralExpression node) { throw new NotImplementedException(); }
override public void LeaveHashLiteralExpression(HashLiteralExpression node) { OnExpression(node); }
public override void OnHashLiteralExpression(HashLiteralExpression node) { MakeLiteralResult("Boo.Lang.Hash"); }
public override void OnHashLiteralExpression(HashLiteralExpression node) { base.OnHashLiteralExpression(node); Check(node); }