public void TestRebalanceAddString() { // "A" + B - C => "A" + (B - C) var str = new StringConstantExpression("ban"); var exprLeft = new IntegerConstantExpression(6); var exprRight = new IntegerConstantExpression(2); var clause = new MathematicExpression(exprLeft, MathematicOperation.Subtract, exprRight); var expr = new MathematicExpression(str, MathematicOperation.Add, clause); var result = expr.Rebalance() as MathematicExpression; Assert.That(result, Is.Not.Null); Assert.That(result.Left, Is.EqualTo(str)); Assert.That(result.Operation, Is.EqualTo(MathematicOperation.Add)); Assert.That(result.Right, Is.EqualTo(clause)); // A - B + "C" => (A - B) + "C" clause = new MathematicExpression(exprRight, MathematicOperation.Add, str); expr = new MathematicExpression(exprLeft, MathematicOperation.Subtract, clause); result = expr.Rebalance() as MathematicExpression; Assert.That(result, Is.Not.Null); var expectedLeft = new MathematicExpression(exprLeft, MathematicOperation.Subtract, exprRight); Assert.That(result.Left, Is.EqualTo(expectedLeft)); Assert.That(result.Operation, Is.EqualTo(MathematicOperation.Add)); Assert.That(result.Right, Is.EqualTo(str)); }
public override bool BuildMacro(RichPresenceDisplayFunction.RichPresenceDisplayContext context, InterpreterScope scope, out ExpressionBase result) { var macro = GetStringParameter(scope, "macro", out result); if (macro == null) { return(false); } var expression = GetParameter(scope, "expression", out result); if (expression == null) { return(false); } var value = TriggerBuilderContext.GetValueString(expression, scope, out result); if (value == null) { return(false); } var functionCall = scope.GetContext <FunctionCallExpression>(); var valueFormat = GetValueFormat(macro.Value); context.RichPresence.AddValueField(functionCall, macro.Value, valueFormat); result = new StringConstantExpression(String.Format("@{0}({1})", macro.Value, value)); return(true); }
public void InstantiationAndProperties() { FieldValueEqualsStringOperator ee = new FieldValueEqualsStringOperator(); Assert.IsNull(ee.ValueExpression); Assert.IsNull(ee.MessageExpression); StringConstantExpression sce = new StringConstantExpression("202030302020"); MessageExpression me = new MessageExpression(3); ee = new FieldValueEqualsStringOperator(me, sce); Assert.IsTrue(ee.ValueExpression == sce); Assert.IsTrue(ee.MessageExpression == me); ee.ValueExpression = null; ee.MessageExpression = null; Assert.IsNull(ee.ValueExpression); Assert.IsNull(ee.MessageExpression); try { ee.ValueExpression = new BinaryConstantExpression("30313233"); Assert.Fail(); } catch (ArgumentException) { } }
public void TestReplaceTwoDimensional() { var variable = new VariableExpression("variable"); var key = new StringConstantExpression("key"); var value = new IntegerConstantExpression(99); var dict2 = new DictionaryExpression(); dict2.Entries.Add(new DictionaryExpression.DictionaryEntry { Key = key, Value = value }); var dict1 = new DictionaryExpression(); dict1.Entries.Add(new DictionaryExpression.DictionaryEntry { Key = key, Value = dict2 }); var expr2 = new IndexedVariableExpression(variable, key); var expr = new IndexedVariableExpression(expr2, key); var scope = new InterpreterScope(); scope.AssignVariable(variable, dict1); ExpressionBase result; Assert.That(expr.ReplaceVariables(scope, out result), Is.True); Assert.That(result, Is.InstanceOf <IntegerConstantExpression>()); Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(99)); }
public RichPresenceValueFunction() : base("rich_presence_value") { Parameters.Add(new VariableDefinitionExpression("name")); Parameters.Add(new VariableDefinitionExpression("expression")); Parameters.Add(new VariableDefinitionExpression("format")); DefaultParameters["format"] = new StringConstantExpression("value"); }
public virtual bool Action(StringConstantExpression child) { if (child.Value != null) { Scan(child.Value); } return(false); }
public MeasuredFunction() : base("measured", RequirementType.Measured) { Parameters.Add(new VariableDefinitionExpression("when")); Parameters.Add(new VariableDefinitionExpression("format")); DefaultParameters["when"] = AlwaysTrueFunction.CreateAlwaysTrueFunctionCall(); DefaultParameters["format"] = new StringConstantExpression("raw"); }
public void TestAppendString() { var expr = new StringConstantExpression("test"); var builder = new StringBuilder(); expr.AppendString(builder); Assert.That(builder.ToString(), Is.EqualTo("\"test\"")); }
public RichPresenceLookupFunction() : base("rich_presence_lookup") { Parameters.Add(new VariableDefinitionExpression("name")); Parameters.Add(new VariableDefinitionExpression("expression")); Parameters.Add(new VariableDefinitionExpression("dictionary")); Parameters.Add(new VariableDefinitionExpression("fallback")); DefaultParameters["fallback"] = new StringConstantExpression(""); }
public LeaderboardFunction() : base("leaderboard") { Parameters.Add(new VariableDefinitionExpression("title")); Parameters.Add(new VariableDefinitionExpression("description")); Parameters.Add(new VariableDefinitionExpression("start")); Parameters.Add(new VariableDefinitionExpression("cancel")); Parameters.Add(new VariableDefinitionExpression("submit")); Parameters.Add(new VariableDefinitionExpression("value")); Parameters.Add(new VariableDefinitionExpression("format")); DefaultParameters["format"] = new StringConstantExpression("value"); }
public void TestAddStrings() { var left = new StringConstantExpression("ban"); var right = new StringConstantExpression("ana"); var expr = new MathematicExpression(left, MathematicOperation.Add, right); var scope = new InterpreterScope(); ExpressionBase result; Assert.That(expr.ReplaceVariables(scope, out result), Is.True); Assert.That(result, Is.InstanceOf <StringConstantExpression>()); Assert.That(((StringConstantExpression)result).Value, Is.EqualTo("banana")); }
public override bool BuildMacro(RichPresenceDisplayFunction.RichPresenceDisplayContext context, InterpreterScope scope, out ExpressionBase result) { var name = GetStringParameter(scope, "name", out result); if (name == null) { return(false); } var expression = GetParameter(scope, "expression", out result); if (expression == null) { return(false); } var dictionary = GetDictionaryParameter(scope, "dictionary", out result); if (dictionary == null) { return(false); } var fallback = GetStringParameter(scope, "fallback", out result); if (fallback == null) { return(false); } var value = TriggerBuilderContext.GetValueString(expression, scope, out result); if (value == null) { return(false); } var functionCall = scope.GetContext <FunctionCallExpression>(); var error = context.RichPresence.AddLookupField(functionCall, name.Value, dictionary, fallback); if (error != null) { result = error; return(false); } result = new StringConstantExpression(String.Format("@{0}({1})", name.Value, value)); return(true); }
public void InstantiationAndProperties() { StringConstantExpression sve = new StringConstantExpression(); Assert.IsTrue(sve.Constant == null); sve = new StringConstantExpression("Test"); Assert.IsTrue(sve.Constant == "Test"); sve.Constant = null; Assert.IsTrue(sve.Constant == null); sve.Constant = "Another test"; Assert.IsTrue(sve.Constant == "Another test"); }
public void TestReplaceVariablesNonDictionary() { var variable = new VariableExpression("variable"); var key = new StringConstantExpression("key"); var value = new IntegerConstantExpression(99); var expr = new IndexedVariableExpression(variable, key); var scope = new InterpreterScope(); scope.AssignVariable(variable, value); ExpressionBase result; Assert.That(expr.ReplaceVariables(scope, out result), Is.False); Assert.That(result, Is.InstanceOf <ParseErrorExpression>()); Assert.That(((ParseErrorExpression)result).Message, Is.EqualTo("Cannot index: variable (IntegerConstant)")); }
public void TestGetParametersByIndex() { var functionDefinition = Parse("function func(i,j) { }"); var scope = new InterpreterScope(); var value1 = new IntegerConstantExpression(6); var value2 = new StringConstantExpression("a"); var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { value1, value2 }); ExpressionBase error; var innerScope = functionCall.GetParameters(functionDefinition, scope, out error); Assert.That(innerScope, Is.Not.Null); Assert.That(error, Is.Null); Assert.That(innerScope.VariableCount, Is.EqualTo(2)); Assert.That(innerScope.GetVariable("i"), Is.EqualTo(value1)); Assert.That(innerScope.GetVariable("j"), Is.EqualTo(value2)); }
public void TestGetParametersByNameRepeated() { var functionDefinition = Parse("function func(i,j) { }"); var scope = new InterpreterScope(); var value2 = new StringConstantExpression("a"); var assign2 = new AssignmentExpression(new VariableExpression("i"), value2); var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { assign2, assign2 }); ExpressionBase error; var innerScope = functionCall.GetParameters(functionDefinition, scope, out error); Assert.That(innerScope, Is.Null); Assert.That(error, Is.Not.Null); var parseError = (ParseErrorExpression)error; Assert.That(parseError.Message, Is.EqualTo("'i' already has a value")); }
public void TestGetModifications() { var key1 = new VariableExpression("key1"); var value1 = new IntegerConstantExpression(99); var key2 = new StringConstantExpression("key2"); var value2 = new VariableExpression("value2"); var expr = new DictionaryExpression(); expr.Add(key1, value1); expr.Add(key2, value2); var modifications = new HashSet <string>(); ((INestedExpressions)expr).GetModifications(modifications); Assert.That(modifications.Count, Is.EqualTo(0)); }
public void TestReplaceVariablesInvalidKey() { var variable = new VariableExpression("variable"); var key = new StringConstantExpression("key"); var dict = new DictionaryExpression(); var expr = new IndexedVariableExpression(variable, key); var scope = new InterpreterScope(); scope.AssignVariable(variable, dict); ExpressionBase result; Assert.That(expr.ReplaceVariables(scope, out result), Is.False); Assert.That(result, Is.InstanceOf <ParseErrorExpression>()); Assert.That(((ParseErrorExpression)result).Message, Is.EqualTo("No entry in dictionary for key: \"key\"")); }
public void TestGetParametersByNameBeforeIndex() { var functionDefinition = Parse("function func(i,j) { }"); var scope = new InterpreterScope(); var value1 = new IntegerConstantExpression(6); var value2 = new StringConstantExpression("a"); var assign1 = new AssignmentExpression(new VariableExpression("i"), value1); var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { assign1, value2 }); ExpressionBase error; var innerScope = functionCall.GetParameters(functionDefinition, scope, out error); Assert.That(innerScope, Is.Null); Assert.That(error, Is.Not.Null); var parseError = (ParseErrorExpression)error; Assert.That(parseError.Message, Is.EqualTo("Non-named parameter following named parameter")); }
public LeaderboardFunction() : base("leaderboard") { Parameters.Add(new VariableDefinitionExpression("title")); Parameters.Add(new VariableDefinitionExpression("description")); Parameters.Add(new VariableDefinitionExpression("start")); Parameters.Add(new VariableDefinitionExpression("cancel")); Parameters.Add(new VariableDefinitionExpression("submit")); Parameters.Add(new VariableDefinitionExpression("value")); Parameters.Add(new VariableDefinitionExpression("format")); Parameters.Add(new VariableDefinitionExpression("lower_is_better")); DefaultParameters["format"] = new StringConstantExpression("value"); DefaultParameters["lower_is_better"] = new BooleanConstantExpression(false); // additional parameters generated by dumper Parameters.Add(new VariableDefinitionExpression("id")); DefaultParameters["id"] = new IntegerConstantExpression(0); }
public void TestNestedExpressions() { var key1 = new VariableExpression("key1"); var value1 = new IntegerConstantExpression(99); var key2 = new StringConstantExpression("key2"); var value2 = new VariableExpression("value2"); var expr = new DictionaryExpression(); expr.Add(key1, value1); expr.Add(key2, value2); var nested = ((INestedExpressions)expr).NestedExpressions; Assert.That(nested.Count(), Is.EqualTo(4)); Assert.That(nested.Contains(key1)); Assert.That(nested.Contains(value1)); Assert.That(nested.Contains(key2)); Assert.That(nested.Contains(value2)); }
public void TestGetDependencies() { var key1 = new VariableExpression("key1"); var value1 = new IntegerConstantExpression(99); var key2 = new StringConstantExpression("key2"); var value2 = new VariableExpression("value2"); var expr = new DictionaryExpression(); expr.Add(key1, value1); expr.Add(key2, value2); var dependencies = new HashSet <string>(); ((INestedExpressions)expr).GetDependencies(dependencies); Assert.That(dependencies.Count, Is.EqualTo(2)); Assert.That(dependencies.Contains("key1")); Assert.That(dependencies.Contains("value2")); }
public AchievementFunction() : base("achievement") { // required parameters Parameters.Add(new VariableDefinitionExpression("title")); Parameters.Add(new VariableDefinitionExpression("description")); Parameters.Add(new VariableDefinitionExpression("points")); Parameters.Add(new VariableDefinitionExpression("trigger")); // additional parameters generated by dumper Parameters.Add(new VariableDefinitionExpression("id")); DefaultParameters["id"] = new IntegerConstantExpression(0); Parameters.Add(new VariableDefinitionExpression("published")); DefaultParameters["published"] = new StringConstantExpression(""); Parameters.Add(new VariableDefinitionExpression("modified")); DefaultParameters["modified"] = new StringConstantExpression(""); Parameters.Add(new VariableDefinitionExpression("badge")); DefaultParameters["badge"] = new StringConstantExpression("0"); }
public void TestReplaceVariablesCreatesCopy() { var key1 = new IntegerConstantExpression(1); var key2 = new IntegerConstantExpression(2); var value1 = new StringConstantExpression("One"); var value2 = new StringConstantExpression("Two"); var dict1 = new DictionaryExpression(); dict1.Add(key1, value1); dict1.Add(key2, value2); var scope = new InterpreterScope(); ExpressionBase result; Assert.That(dict1.ReplaceVariables(scope, out result), Is.True); Assert.That(result, Is.InstanceOf <DictionaryExpression>()); var dict2 = (DictionaryExpression)result; Assert.That(dict2.Count, Is.EqualTo(2)); // item added to original dictionary does not appear in evaluated dictionary var key3 = new IntegerConstantExpression(3); var value3 = new StringConstantExpression("Three"); dict1.Add(key3, value3); Assert.That(dict1.Count, Is.EqualTo(3)); Assert.That(dict2.Count, Is.EqualTo(2)); // item added to evaluated dictionary does not appear in original dictionary var key4 = new IntegerConstantExpression(4); var value4 = new StringConstantExpression("Four"); dict2.Add(key4, value4); Assert.That(dict1.Count, Is.EqualTo(3)); Assert.That(dict2.Count, Is.EqualTo(3)); Assert.That(dict1.Keys.Contains(key3)); Assert.That(!dict2.Keys.Contains(key3)); Assert.That(!dict1.Keys.Contains(key4)); Assert.That(dict2.Keys.Contains(key4)); }
public void TestReplaceVariablesArrayIndexString() { var variable = new VariableExpression("variable"); var index = new StringConstantExpression("str"); var value = new IntegerConstantExpression(99); var array = new ArrayExpression(); array.Entries.Add(value); var expr = new IndexedVariableExpression(variable, index); var scope = new InterpreterScope(); scope.AssignVariable(variable, array); ExpressionBase result; Assert.That(expr.ReplaceVariables(scope, out result), Is.False); Assert.That(result, Is.InstanceOf <ParseErrorExpression>()); Assert.That(((ParseErrorExpression)result).Message, Is.EqualTo("Index does not evaluate to an integer constant")); }
public void TestReplaceVariables() { var variable = new VariableExpression("variable"); var key = new StringConstantExpression("key"); var value = new IntegerConstantExpression(99); var dict = new DictionaryExpression(); dict.Add(key, value); var expr = new IndexedVariableExpression(variable, key); var scope = new InterpreterScope(); scope.AssignVariable(variable, dict); ExpressionBase result; Assert.That(expr.ReplaceVariables(scope, out result), Is.True); Assert.That(result, Is.InstanceOf <IntegerConstantExpression>()); Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(99)); }
public LuaExpression Parse(INextAwareEnumerator <Token> reader, IParserContext context) { var tableName = reader.Current.Value; LuaExpression indexerExpression; reader.MoveNext(); if (reader.Current.Value == LuaToken.Dot) { reader.MoveNext(); indexerExpression = new StringConstantExpression(reader.Current.Value); } else if (reader.Current.Value == LuaToken.LeftSquareBracket) { reader.MoveNext(); indexerExpression = SyntaxParser.ReadExpression(reader, context); reader.VerifyExpectedTokenAndMoveNext(LuaToken.RightSquareBracket); } else { throw new UnexpectedTokenException(reader.Current, LuaToken.Dot, LuaToken.LeftSquareBracket); } return(new TableIndexExpression(new Variable(tableName), indexerExpression)); }
public ParseErrorExpression AddLookupField(ExpressionBase func, string name, DictionaryExpression dict, StringConstantExpression fallback) { var tinyDict = new TinyDictionary <int, string>(); foreach (var entry in dict.Entries) { var key = entry.Key as IntegerConstantExpression; if (key == null) { return(new ParseErrorExpression("key is not an integer", entry.Key)); } var value = entry.Value as StringConstantExpression; if (value == null) { return(new ParseErrorExpression("value is not a string", entry.Value)); } tinyDict[key.Value] = value.Value; } _lookupFields[name] = new Lookup { Func = func, Entries = tinyDict, Fallback = fallback }; return(null); }
private ParseErrorExpression ProcessRichPresenceDisplay(StringConstantExpression stringExpression, InterpreterScope scope, out string displayString) { displayString = null; ExpressionBase result; var varargs = GetParameter(scope, "varargs", out result) as ArrayExpression; if (varargs == null) { var error = result as ParseErrorExpression; if (error == null) { error = new ParseErrorExpression("unexpected varargs", stringExpression); } return(error); } var context = scope.GetContext <RichPresenceDisplayContext>(); var builder = context.DisplayString; var tokenizer = new PositionalTokenizer(Tokenizer.CreateTokenizer(stringExpression.Value)); while (tokenizer.NextChar != '\0') { var token = tokenizer.ReadTo('{'); builder.Append(token.ToString()); if (tokenizer.NextChar == '\0') { break; } var positionalTokenColumn = tokenizer.Column; tokenizer.Advance(); var index = tokenizer.ReadNumber(); if (tokenizer.NextChar != '}') { return(new ParseErrorExpression("Invalid positional token", stringExpression.Line, stringExpression.Column + positionalTokenColumn, stringExpression.Line, stringExpression.Column + tokenizer.Column - 1)); } tokenizer.Advance(); var parameterIndex = Int32.Parse(index.ToString()); if (parameterIndex >= varargs.Entries.Count) { return(new ParseErrorExpression("Invalid parameter index: " + parameterIndex, stringExpression.Line, stringExpression.Column + positionalTokenColumn, stringExpression.Line, stringExpression.Column + tokenizer.Column - 1)); } var functionCall = varargs.Entries[parameterIndex] as FunctionCallExpression; var functionDefinition = scope.GetFunction(functionCall.FunctionName.Name); if (functionDefinition == null) { return(new ParseErrorExpression("Unknown function: " + functionCall.FunctionName.Name)); } var richPresenceFunction = functionDefinition as FunctionDefinition; if (richPresenceFunction == null) { return(new ParseErrorExpression(functionCall.FunctionName.Name + " cannot be called as a rich_presence_display parameter", functionCall)); } var error = richPresenceFunction.BuildMacro(context, scope, functionCall); if (error != null) { return(new ParseErrorExpression(error, functionCall)); } } displayString = builder.ToString(); return(null); }
public override ParseErrorExpression BuildTrigger(TriggerBuilderContext context, InterpreterScope scope, FunctionCallExpression functionCall) { var error = base.BuildTrigger(context, scope, functionCall); if (error != null) { return(error); } ExpressionBase result; var format = functionCall.Parameters.ElementAt(2); if (!format.ReplaceVariables(scope, out result)) { return((ParseErrorExpression)result); } StringConstantExpression formatStr = result as StringConstantExpression; if (formatStr == null) { return(new ParseErrorExpression("format is not a string", format)); } if (formatStr.Value != "raw") { if (scope.GetContext <ValueBuilderContext>() != null) { return(new ParseErrorExpression("Value fields only support raw measured values", format)); } if (formatStr.Value == "percent") { context.LastRequirement.Type = RequirementType.MeasuredPercent; } else { return(new ParseErrorExpression("Unknown format: " + formatStr.Value, format)); } } var when = functionCall.Parameters.ElementAt(1); var builder = new ScriptInterpreterAchievementBuilder(); if (!TriggerBuilderContext.ProcessAchievementConditions(builder, when, scope, out result)) { return new ParseErrorExpression("when did not evaluate to a valid comparison", when) { InnerError = (ParseErrorExpression)result } } ; error = builder.CollapseForSubClause(); if (error != null) { return(error); } if (builder.CoreRequirements.Count != 1 || builder.CoreRequirements.First().Evaluate() != true) { foreach (var requirement in builder.CoreRequirements) { if (requirement.Type == RequirementType.None || requirement.Type == RequirementType.AndNext) { requirement.Type = RequirementType.MeasuredIf; } context.Trigger.Add(requirement); } } return(null); } }