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