private bool CheckSimpleStatement() { if (this.LookAheadFirst.TokenType != TokenType.OpenBraces) { return(false); } this.DiscardToken(TokenType.OpenBraces); bool flag = false; while (!flag) { flag = !this.DoExpressionRules(); } if (this.IsArithmeticExpression(this.LookAheadFirst.TokenType)) { TextExpression token = (TextExpression) new SimpleExpression(this.LookAheadFirst); this.DiscardToken(); this.DiscardToken(TokenType.CloseBraces); this.PushToken(token); } else { this.DiscardToken(TokenType.CloseBraces); } return(true); }
private bool CheckFieldStatement() { if (this.LookAheadFirst.TokenType != TokenType.FieldStarter) { return(false); } this.DiscardToken(TokenType.FieldStarter); bool flag = false; while (!flag) { flag = !this.DoExpressionRules(); } if (this.LookAheadFirst.TokenType != TokenType.Identifier) { return(false); } TextExpression lookAheadFirst = this.LookAheadFirst; this.DiscardToken(TokenType.Identifier); this.DiscardToken(TokenType.CloseBraces); TextExpression textExpression = this.GetRootExpressions() ?? (TextExpression) new SimpleToken(TokenType.Text, ""); this.DiscardToken(TokenType.FieldFinalizer); TextExpression part2 = textExpression; this.PushToken((TextExpression) new FieldExpression(lookAheadFirst, part2)); return(true); }
private bool CollapseStatements() { if (!this.IsRootExpression(this.LookAheadFirst.TokenType) || this.LookAheadFirst.TokenType == TokenType.MultiStatement) { return(false); } List <TextExpression> textExpressionList = new List <TextExpression>(); TextExpression lookAheadFirst1 = this.LookAheadFirst; this.DiscardToken(); textExpressionList.Add(lookAheadFirst1); bool flag = false; while (!flag) { do { ; }while (this.RunRootGrammarRulesExceptCollapse()); if (this.IsRootExpression(this.LookAheadFirst.TokenType)) { TextExpression lookAheadFirst2 = this.LookAheadFirst; this.DiscardToken(); textExpressionList.Add(lookAheadFirst2); } else { flag = true; } } this.PushToken((TextExpression) new MultiStatement((IEnumerable <TextExpression>)textExpressionList)); return(true); }
public static void CompileExpressions(DynamicActivity dynamicActivity, params Assembly[] references) { // See https://docs.microsoft.com/en-us/dotnet/framework/windows-workflow-foundation/csharp-expressions string activityName = dynamicActivity.Name; string activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot"; string activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse()); TextExpressionCompilerSettings settings = new TextExpressionCompilerSettings { Activity = dynamicActivity, Language = "C#", ActivityName = activityType, ActivityNamespace = activityNamespace, RootNamespace = null, GenerateAsPartialClass = false, AlwaysGenerateSource = true, ForImplementation = true }; // add assembly references TextExpression.SetReferencesForImplementation(dynamicActivity, references.Select(a => (AssemblyReference)a).ToList()); // Compile the C# expression. var results = new TextExpressionCompiler(settings).Compile(); if (results.HasErrors) { throw new Exception("Compilation failed."); } // attach compilation result to live activity var compiledExpression = (ICompiledExpressionRoot)Activator.CreateInstance(results.ResultType, new object[] { dynamicActivity }); CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpression); }
private Object evalAssignExpression(Object context, AssignExpression expression) { // 取得父对象和键 TextExpression text = expression.Left; Object parentContext = null; IdentifierExpression key = null; if (text is PathExpression path) { parentContext = Eval(context, path.SubPath(0, path.Length - 1)); if (path.SubPath(path.Length - 1).Path[0] is IdentifierExpression identifier) { key = identifier; } else { throw new System.Exception("You can only assign it to a key."); } } else if (text is IdentifierExpression identifier) { parentContext = context; key = identifier; } // 取得右值 Object value = Eval(context, expression.Right); parentContext[key.Literal] = value; return(value); }
private void UpdateLookAheads() { this._lookaheadFirst = this._symbolSequence.Count != 0 ? this._symbolSequence.Peek() : (TextExpression)SimpleToken.SequenceTerminator; if (this._symbolSequence.Count < 2) { this._lookaheadSecond = (TextExpression)SimpleToken.SequenceTerminator; } else { TextExpression textExpression = this._symbolSequence.Pop(); this._lookaheadSecond = this._symbolSequence.Peek(); this._symbolSequence.Push(textExpression); } if (this._symbolSequence.Count < 3) { this._lookaheadThird = (TextExpression)SimpleToken.SequenceTerminator; } else { TextExpression textExpression1 = this._symbolSequence.Pop(); TextExpression textExpression2 = this._symbolSequence.Pop(); this._lookaheadThird = this._symbolSequence.Peek(); this._symbolSequence.Push(textExpression2); this._symbolSequence.Push(textExpression1); } }
private bool ConsumeComparisonExpression() { TokenType tokenType1 = this.LookAheadFirst.TokenType; TokenType tokenType2 = this.LookAheadSecond.TokenType; if (!this.IsArithmeticExpression(tokenType1) || !this.IsComparisonOperator(tokenType2)) { return(false); } TextExpression lookAheadFirst1 = this.LookAheadFirst; this.DiscardToken(); ComparisonOperation comparisonOp = this.GetComparisonOp(tokenType2); this.DiscardToken(); do { ; }while (this.DoExpressionRules()); if (!this.IsArithmeticExpression(this.LookAheadFirst.TokenType)) { return(false); } TextExpression lookAheadFirst2 = this.LookAheadFirst; this.DiscardToken(); this.PushToken((TextExpression) new ComparisonExpression(comparisonOp, lookAheadFirst1, lookAheadFirst2)); return(true); }
private bool ConsumeInnerAritmeticExpression() { TokenType tokenType1 = this.LookAheadFirst.TokenType; TokenType tokenType2 = this.LookAheadSecond.TokenType; int tokenType3 = (int)this.LookAheadThird.TokenType; if (!this.IsArithmeticExpression(tokenType1) || tokenType2 != TokenType.Multiply && tokenType2 != TokenType.Divide) { return(false); } TextExpression lookAheadFirst1 = this.LookAheadFirst; this.DiscardToken(); ArithmeticOperation op = this.ConsumeAritmeticOperation(); if (!this.IsArithmeticExpression(this.LookAheadFirst.TokenType)) { while (this.DoExpressionRules()) { ; } } TextExpression lookAheadFirst2 = this.LookAheadFirst; this.DiscardToken(); this.PushToken((TextExpression) new ArithmeticExpression(op, lookAheadFirst1, lookAheadFirst2)); return(true); }
internal static Text Text(TextExpression expression) { return(new Text() { QuoteChar = expression.QuoteChar, SourceText = expression.SourceText, }.Apply(n => n.TypeHint = expression.TryType().Null(t => TypeRef.Serialize(t)))); }
/// <summary> /// Parse an TextExpression /// </summary> /// <returns>Parsed TextExpression</returns> public TextExpression ParseTextExpression() { TextExpression textExpression = new TextExpression(); CurrentToken = TokenStream.NextToken(); textExpression.SetText(CurrentToken.GetValue().ToString()); return(textExpression); }
public void ParseTextExpressionTest() { //Create parser and parse tokens ExpressionParser expressionParser = new ExpressionParser(Init("text")); TextExpression expression = expressionParser.ParseTextExpression(); //Test variable identifier Assert.AreEqual("text", expression.GetText()); }
public void EmptyInput() { // Given var expression = new TextExpression("foo"); // When var result = expression.Transform(""); // Then Assert.Null(result); }
public void PartialMatch() { // Given var expression = new TextExpression("foo"); // When var result = expression.Transform("foobar"); // Then Assert.Null(result); }
public void Match() { // Given var expression = new TextExpression("foo"); // When var result = expression.Transform("foo"); // Then Assert.Equal("foo", result); }
public void SetNamespaces(object target) { var dev2ActivitiesAssembly = typeof(WorkflowHelper).Assembly; var dev2CommonAssembly = typeof(GlobalConstants).Assembly; var dev2DataAssembly = typeof(Dev2DataListDecisionHandler).Assembly; var namespaces = new Dictionary <string, Assembly> { { "Dev2.Common", dev2CommonAssembly }, { "Dev2.Data.Decisions.Operations", dev2DataAssembly }, { "Dev2.Data.SystemTemplates.Models", dev2DataAssembly }, { "Dev2.DataList.Contract", dev2DataAssembly }, { "Dev2.DataList.Contract.Binary_Objects", dev2DataAssembly }, { "Unlimited.Applications.BusinessDesignStudio.Activities", dev2ActivitiesAssembly } }; #region Set C# assembly references // http://stackoverflow.com/questions/16086612/wf-4-5-using-c-sharp-expressions-with-external-class-references // http://blogs.msdn.com/b/tilovell/archive/2012/05/25/wf4-5-using-csharpvalue-lt-t-gt-and-csharpreference-lt-t-gt-in-net-4-5-compiling-expressions-and-changes-in-visual-studio-generated-xaml.aspx TextExpression.SetReferencesForImplementation(target, namespaces.Values.Distinct().Select(a => new AssemblyReference { Assembly = a }).ToArray()); var impl = new AttachableMemberIdentifier(typeof(TextExpression), "NamespacesForImplementation"); AttachablePropertyServices.SetProperty(target, impl, namespaces.Keys.ToList()); #endregion #region Set VB assembly references // var vbSettings = VisualBasic.GetSettings(target) ?? new VisualBasicSettings(); // vbSettings.ImportReferences.Clear(); // // foreach(var ns in namespaces.Keys) // { // try // { // vbSettings.ImportReferences.Add(new VisualBasicImportReference { Assembly = namespaces[ns].GetName().Name, Import = ns }); // } // catch(Exception e) // { // Dev2Logger.Error(e.Message,e); // } // } // // VisualBasic.SetSettings(target, vbSettings); #endregion }
internal static void SetTextExpressionNamespaces(object root, IList <string> namespaces, IList <AssemblyReference> references) { if (NamespaceHelper.ShouldUsePropertiesForImplementation(root)) { TextExpression.SetNamespacesForImplementation(root, namespaces); TextExpression.SetReferencesForImplementation(root, references); } else { TextExpression.SetNamespaces(root, namespaces); TextExpression.SetReferences(root, references); } }
internal static IList <string> GetTextExpressionNamespaces(object root, out IList <AssemblyReference> references) { if (NamespaceHelper.ShouldUsePropertiesForImplementation(root)) { references = TextExpression.GetReferencesForImplementation(root); return(TextExpression.GetNamespacesForImplementation(root)); } else { references = TextExpression.GetReferences(root); return(TextExpression.GetNamespaces(root)); } }
private static object?Evaluate(Expression expression, IDictionary <string, object> properties) { return(expression switch { TextExpression text => text.Value, ConstantExpression constant => constant.Value, PipeExpression pipe => PipeValue(pipe, properties), TemplateExpression part => EvaluateTemplate(part, properties), PropertyExpression property => GetProperty(property, properties), FunctionCallExpression function => CallFunction(function, properties), MultiTemplateExpression => throw new NotSupportedException("Multi-template expressions are top-level expressions only."), _ => throw new NotImplementedException(string.Format(Strings.EvaluationNotImplemented, expression)), });
private bool ConsumeMarkerOccuranceExpression() { if (this.LookAheadFirst.TokenType != TokenType.Identifier || this.LookAheadSecond.TokenType != TokenType.MarkerOccuranceIdentifier) { return(false); } VariableExpression lookAheadFirst = this.LookAheadFirst as VariableExpression; TextExpression lookAheadSecond = this.LookAheadSecond; this.DiscardToken(); this.DiscardToken(); this.PushToken((TextExpression) new MarkerOccuranceTextExpression(lookAheadSecond.RawValue.Substring(2), lookAheadFirst)); return(true); }
private IExpression ParseInterpolation() { var nextToken = PeekToken(); if (nextToken.GetType() != typeof(OpenBraceToken)) { return(new TextExpression("$")); } ConsumeToken(); nextToken = PeekToken(); if (nextToken.GetType() != typeof(TextDataToken)) { throw new InvalidOperationException("Function ID expected."); } var idToken = ConsumeToken(); nextToken = PeekToken(); if (nextToken.GetType() == typeof(CloseBraceToken)) { ConsumeToken(); return(new InterpolateExpression(idToken.Text)); } if (nextToken.GetType() != typeof(ColonToken)) { throw new InvalidOperationException("Function parameter list or closing brace expected."); } ConsumeToken(); var expression = new InterpolateExpression(idToken.Text); while (true) { var paramExpression = ParseInside(false, typeof(CloseBraceToken), typeof(CommaToken)); nextToken = PeekToken(); if (paramExpression == null) { paramExpression = new TextExpression(""); } expression.Parameters.Add(paramExpression); if (nextToken.GetType() == typeof(CloseBraceToken)) { break; } ConsumeToken(); } ConsumeToken(); return(expression); }
public void ParseKeyValuePairTest() { //Create parser and parse tokens ExpressionParser expressionParser = new ExpressionParser(Init("token1:\"value1\"")); KeyValuePair keyValuePair = expressionParser.ParseKeyValuePair(); //Check key Assert.AreEqual("token1", keyValuePair.GetKey()); //Check value Assert.AreEqual(typeof(TextExpression), keyValuePair.GetValue().GetType()); TextExpression textExpression = (TextExpression)keyValuePair.GetValue(); Assert.AreEqual("value1", textExpression.GetText()); }
private bool CheckConditionalStatement() { if (this.LookAheadFirst.TokenType != TokenType.ConditionStarter) { return(false); } bool flag = false; List <TextExpression> conditionExpressions = new List <TextExpression>(); List <TextExpression> resultExpressions2 = new List <TextExpression>(); while (!flag) { TokenType tokenType = this.LookAheadFirst.TokenType; if (this.LookAheadFirst.TokenType == TokenType.ConditionStarter || this.LookAheadFirst.TokenType == TokenType.ConditionFollowUp) { this.DiscardToken(); do { ; }while (this.DoExpressionRules()); if (!this.IsArithmeticExpression(this.LookAheadFirst.TokenType)) { return(false); } conditionExpressions.Add(this.LookAheadFirst); this.DiscardToken(); this.DiscardToken(TokenType.CloseBraces); } else { if (tokenType != TokenType.ConditionSeperator && tokenType != TokenType.Seperator) { return(false); } this.DiscardToken(); flag = true; } TextExpression textExpression = this.GetRootExpressions() ?? (TextExpression) new SimpleToken(TokenType.Text, ""); resultExpressions2.Add(textExpression); } do { ; }while (!flag); this.DiscardToken(TokenType.ConditionFinalizer); this.PushToken((TextExpression) new ConditionExpression(conditionExpressions, resultExpressions2)); return(true); }
private static DynamicActivity GetDynamicActivity(ActivityBuilder activityDefinition) { var result = new DynamicActivity { Name = activityDefinition.Name }; foreach (var property in activityDefinition.Properties) { result.Properties.Add(property); } foreach (var attrib in activityDefinition.Attributes) { result.Attributes.Add(attrib); } foreach (var constraint in activityDefinition.Constraints) { result.Constraints.Add(constraint); } result.Implementation = () => activityDefinition.Implementation; var vbsettings = VisualBasic.GetSettings(activityDefinition); if (vbsettings != null) { VisualBasic.SetSettings(result, vbsettings); } var namespacesForImplementation = TextExpression.GetNamespacesForImplementation(activityDefinition); if (namespacesForImplementation.Count > 0) { TextExpression.SetNamespacesForImplementation(result, namespacesForImplementation); } var referencesForImplementation = TextExpression.GetReferencesForImplementation(activityDefinition); if (referencesForImplementation.Count > 0) { TextExpression.SetReferencesForImplementation(result, referencesForImplementation); } return(result); }
static DynamicActivity GetDynamicActivity(ActivityBuilder activityDefinition) { DynamicActivity result = new DynamicActivity { Name = activityDefinition.Name }; foreach (DynamicActivityProperty property in activityDefinition.Properties) { result.Properties.Add(property); } foreach (Attribute attrib in activityDefinition.Attributes) { result.Attributes.Add(attrib); } foreach (Constraint constraint in activityDefinition.Constraints) { result.Constraints.Add(constraint); } result.Implementation = () => activityDefinition.Implementation; VisualBasicSettings vbsettings = VisualBasic.GetSettings(activityDefinition); if (vbsettings != null) { VisualBasic.SetSettings(result, vbsettings); } IList <string> namespacesForImplementation = TextExpression.GetNamespacesForImplementation(activityDefinition); if (namespacesForImplementation.Count > 0) { TextExpression.SetNamespacesForImplementation(result, namespacesForImplementation); } IList <AssemblyReference> referencesForImplementation = TextExpression.GetReferencesForImplementation(activityDefinition); if (referencesForImplementation.Count > 0) { TextExpression.SetReferencesForImplementation(result, referencesForImplementation); } return(result); }
private bool CheckSelectionStatement() { if (this.LookAheadFirst.TokenType != TokenType.SelectionStarter) { return(false); } this.DiscardToken(TokenType.SelectionStarter); do { ; }while (this.DoExpressionRules()); if (!this.IsArithmeticExpression(this.LookAheadFirst.TokenType)) { return(false); } TextExpression lookAheadFirst = this.LookAheadFirst; this.DiscardToken(); this.DiscardToken(TokenType.CloseBraces); bool flag = false; List <TextExpression> selectionExpressions = new List <TextExpression>(); do { TextExpression textExpression = this.GetRootExpressions() ?? (TextExpression) new SimpleToken(TokenType.Text, ""); selectionExpressions.Add(textExpression); switch (this.LookAheadFirst.TokenType) { case TokenType.SelectionSeperator: this.DiscardToken(); break; case TokenType.SelectionFinalizer: flag = true; this.DiscardToken(); break; default: return(false); } }while (!flag); this.PushToken((TextExpression) new SelectionExpression(lookAheadFirst, selectionExpressions)); return(true); }
public static TextExpression Create( AphidExpressionContext context_aphidExpressionContext, string text_s, int value_i, int value_i1 ) { TextExpression textExpression = new TextExpression(context_aphidExpressionContext, text_s); ((AphidExpression)textExpression).Index = value_i; ((AphidExpression)textExpression).Length = value_i1; return(textExpression); // TODO: Edit factory method of TextExpression // This method should be able to configure the object in all possible ways. // Add as many parameters as needed, // and assign their values to each field by using the API. }
private void GetRootExpressionsImp(List <TextExpression> expList) { while (true) { do { ; }while (this.RunRootGrammarRulesExceptCollapse()); if (this.IsRootExpression(this.LookAheadFirst.TokenType)) { TextExpression lookAheadFirst = this.LookAheadFirst; this.DiscardToken(); expList.Add(lookAheadFirst); } else { break; } } }
public static IEnumerable <string> EnumerateImports(EditingContext context, ModelItem modelItem) { IEnumerable <string> enumerable = context?.Services.GetService(typeof(HashSet <string>)) as HashSet <string>; IEnumerable <string> first = enumerable ?? Enumerable.Empty <string>(); object obj = modelItem?.Root?.GetCurrentValue(); object enumerable2; if (obj == null) { enumerable2 = Enumerable.Empty <string>(); } else { enumerable = TextExpression.GetNamespacesForImplementation(obj); enumerable2 = enumerable; } IEnumerable <string> second = (IEnumerable <string>)enumerable2; return(first.Union(second).Distinct()); }
/// <summary> /// Visit FunctionDefinition to check declarations /// </summary> /// <param name="functionDefinition">FunctionDefinition to check</param> public override void Visit(FunctionDefinition functionDefinition) { CreateChildSymbolTable(); //Check Formals foreach (Formal formal in functionDefinition.GetFormals()) { //Add variable, but with nullvalue, because value is undefined in definition TextExpression textExpression = new TextExpression(); SymbolTable.AddVariableDefinition(formal.GetIdentifier(), textExpression); } //Check Statements of function foreach (Statement statement in functionDefinition.GetStatements()) { statement.AcceptVisitor(this); } MoveToParentSymbolTable(); }
static void Main() { var errorCodeWorkflow = new DynamicActivity { Name = "MyScenario.MyDynamicActivity3", Properties = { new DynamicActivityProperty { Name = "Address", Type = typeof(InArgument <MailAddress>), }, }, Implementation = () => new WriteLine { Text = new CSharpValue <String> { ExpressionText = "\"MyDynamicActivity \" + Address.DisplayName" } } }; var impl = new AttachableMemberIdentifier(typeof(TextExpression), "NamespacesForImplementation"); var namespaces = new List <string> { typeof(MailAddress).Namespace }; TextExpression.SetReferencesForImplementation(errorCodeWorkflow, new AssemblyReference { Assembly = typeof(MailAddress).Assembly }); AttachablePropertyServices.SetProperty(errorCodeWorkflow, impl, namespaces); CompileExpressions(errorCodeWorkflow); WorkflowInvoker.Invoke(errorCodeWorkflow, new Dictionary <String, Object> { { "Address", new MailAddress { DisplayName = "TestDisplayName" } } }); }