private void TestReferenceTypeVariables()
{
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("a", "string");
variables.Add("b", 100);
var e = new DynamicExpression <string>("a + b + a.tostring()", ExpressionLanguage.Flee);
string result = e.Invoke(context);
Assert.AreEqual("string" + 100 + "string", result);
variables["a"].Value = "test";
variables["b"].Value = 1;
result = e.Invoke(context);
Assert.AreEqual("test" + 1 + "test", result);
// Test null value
variables.Add("nullvar", null);
var e2 = new DynamicExpression <bool>("nullvar = null", ExpressionLanguage.Flee);
Assert.IsTrue(e2.Invoke(context));
}
static void Main(string[] args)
{
//Sample Scenario 1
ExpressionContext context = new ExpressionContext();
context.ParserOptions.DecimalSeparator = '.';
context.ParserOptions.FunctionArgumentSeparator = ',';
VariableCollection variables = context.Variables;
variables.Add("a", 1);
variables.Add("b", 1);
IGenericExpression <bool> e = context.CompileGeneric <bool>("a=1 AND b=0");
bool result = e.Evaluate();
//Sample Scenario 2
ExpressionContext context2 = new ExpressionContext();
VariableCollection variables2 = context2.Variables;
variables2.Add("a", 100);
variables2.Add("b", 1);
variables2.Add("c", 24);
IGenericExpression <bool> ge = context2.CompileGeneric <bool>("(a = 100 OR b > 0) AND c <> 2");
bool result2 = ge.Evaluate();
IGenericExpression <decimal> ge1 = context2.CompileGeneric <decimal>("1/2");
decimal result3 = ge1.Evaluate();
System.Console.ReadKey();
}
private void TestValueTypeVariables()
{
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("a", 100);
variables.Add("b", -100);
variables.Add("c", DateTime.Now);
var e1 = new DynamicExpression <int>("a+b", ExpressionLanguage.Flee);
int result = e1.Invoke(context);
Assert.AreEqual(100 + -100, result);
variables["B"].Value = 1000;
result = e1.Invoke(context);
Assert.AreEqual(100 + 1000, result);
var e2 = new DynamicExpression <string>("c.tolongdatestring() + c.Year.tostring()", ExpressionLanguage.Flee);
Assert.AreEqual(DateTime.Now.ToLongDateString() + DateTime.Now.Year, e2.Invoke(context));
// Test null value
//variables["a"].Value = null;
//e1 = new DynamicExpression<int>("a", ExpressionLanguage.Flee);
//Assert.AreEqual(0, e1.Invoke(context));
}
public void ShouldBeAbleToClearVariablesOfCurrentScope()
{
_variables = new VariableCollection();
_variables.Scopes.SetCurrent("Test Scenario 1");
_variables.Add(_globalVariableName, _globalVariableValue);
_variables.Count().Should().Be(1);
_variables.Contains(_globalVariableName).Should().BeTrue();
_variables.GetValue(_globalVariableName).Should().Be(_globalVariableValue);
_variables.Scopes.SetCurrent("Function 1");
_variables.Add(_localVariableName, _localVariableValue);
_variables.Count().Should().Be(2);
_variables.CountCurrentScopeKeys().Should().Be(1);
_variables.Contains(_globalVariableName).Should().BeTrue();
_variables.GetValue(_globalVariableName).Should().Be(_globalVariableValue);
_variables.Contains(_localVariableName).Should().BeTrue();
_variables.GetValue(_localVariableName).Should().Be(_localVariableValue);
_variables.RemoveCurrentScopedValues();
_variables.Count().Should().Be(1);
_variables.CountCurrentScopeKeys().Should().Be(0);
_variables.Contains(_globalVariableName).Should().BeTrue();
_variables.GetValue(_globalVariableName).Should().Be(_globalVariableValue);
_variables.Contains(_localVariableName).Should().BeFalse();
_variables.GetValue(_localVariableName).Should().Be(null);
}
static void Main(string[] args)
{
//Sample Scenario 1
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("a", 1);
variables.Add("b", 1);
IGenericExpression <bool> e = context.CompileGeneric <bool>("a=1 AND b=0");
bool result = e.Evaluate();
//Sample Scenario 2
ExpressionContext context2 = new ExpressionContext();
VariableCollection variables2 = context2.Variables;
variables2.Add("a", 100);
variables2.Add("b", 1);
variables2.Add("c", 24);
IGenericExpression <bool> ge = context2.CompileGeneric <bool>("(a = 100 OR b > 0) AND c <> 2");
bool result2 = ge.Evaluate();
System.Console.ReadKey();
}
//*************************************************************************
//* Private *
//*************************************************************************
//*************************************************************************
//* Protected *
//*************************************************************************
//*************************************************************************
//* Public *
//*************************************************************************
//*-----------------------------------------------------------------------*
//* GetCollection *
//*-----------------------------------------------------------------------*
/// <summary>
/// Return the first collection matching the specified expression.
/// </summary>
/// <param name="expression">
/// Basic expression to parse. Any attribute names are square bracketed.
/// For example, to find a collection where the datatype attribute value
/// is equal to 'object', use [datatype] = object
/// </param>
/// <returns>
/// Reference to the first matching collection, if found. Otherwise, null.
/// </returns>
public AttributeCollection GetCollection(string expression)
{
string content = "";
ExpressionContext context = null;
IGenericExpression <bool> evaluator = null;
string expressionText = "";
StringCollection fieldNames = new StringCollection();
string keyword = "";
MatchCollection matches = null;
//double nValue = 0d;
AttributeCollection result = null;
VariableCollection variables = null;
if (expression?.Length > 0)
{
expressionText = expression;
context = new ExpressionContext();
variables = context.Variables;
matches = Regex.Matches(expression,
ResourceMain.AttributeKeywordPattern);
foreach (Match match in matches)
{
keyword = Tools.GetValue(match, "keyword");
content = Tools.GetValue(match, "content");
if (content.Length > 0)
{
// This value is either a field name or a match value.
if (keyword.Length > 0)
{
// Field name found.
fieldNames.AddUnique(content);
expressionText = expressionText.Replace(keyword, "F" + content);
variables.Add("F" + content, content);
}
else
{
// Normal value.
variables.Add(content, content);
}
}
}
foreach (AttributeCollection collection in this)
{
// Prepare the local variables.
foreach (string field in fieldNames)
{
variables["F" + field] = collection.GetValue(field);
}
evaluator = context.CompileGeneric <bool>(expressionText);
if (evaluator.Evaluate())
{
result = collection;
break;
}
}
}
return(result);
}
public override VariableCollection GetVariables()
{
VariableCollection res = base.GetVariables();
res.Add(Type);
res.Add(Target);
res.Add(Workspace);
return(res);
}
public void NoExist()
{
var c = new VariableCollection();
c.Add("int", "x ints");
Assert.IsFalse(c.Exists("x ints a"));
}
public void Simple()
{
var c = new VariableCollection();
c.Add("int", "x");
Assert.IsTrue(c.Exists("x"));
}
public void NestedCapital()
{
var c = new VariableCollection();
c.Add("int", "x Y z");
Assert.IsTrue(c.Exists("x y Z"));
}
public void BagInt()
{
var c = new VariableCollection();
c.Add("int*", "x ints");
Assert.IsTrue(c.Exists("x ints a"));
}
public void ShouldBeAbleToAddVariables()
{
_variables = new VariableCollection();
_variables.Scopes.SetCurrent("Test Scenario 1");
_variables.Add(_globalVariableName, _globalVariableValue);
_variables.Add(_localVariableName, _localVariableValue);
_variables.Count().Should().Be(2);
_variables.Contains(_globalVariableName).Should().BeTrue();
_variables.GetValue(_globalVariableName).Should().Be(_globalVariableValue);
_variables.Contains(_localVariableName).Should().BeTrue();
_variables.GetValue(_localVariableName).Should().Be(_localVariableValue);
}
public void Close(string message)
{
VariableCollection vars = new VariableCollection();
vars.Add("message", message);
var obj = new JukeboxMessage { Type = "close", Variables = vars, MessageId = -1 };
WriteMessage(obj);
Context.Disconnect();
}
/// <summary>
/// 每次构造ExpressionContext
/// </summary>
/// <returns></returns>
public static double Test3()
{
Stopwatch stopwatch2 = new Stopwatch();
stopwatch2.Start();
for (int i = 0; i < 1000000; i++)
{
//Sample Scenario 1
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("a", 1);
variables.Add("b", 1);
IGenericExpression <bool> e = context.CompileGeneric <bool>("a=1 AND b=0");
bool result = e.Evaluate();
}
stopwatch2.Stop();
return(stopwatch2.ElapsedMilliseconds);
}
/// <summary>
/// Evaluates an expression to an object like <see cref="bool"/> or <see cref="int"/> bases on a set of variables that should be used when evaluating
/// For example evaluating to bool:
/// Expression: a > 6 AND b = true
/// With variables: a = 7 and b = false (these values will come from user input for parameters in the projectmodel)
/// Will result in: false
/// Uses https://github.com/mparlak/Flee for evaluation
/// </summary>
/// <param name="expression">The expression to be evaluated like a > 6 AND b = true</param>
/// <param name="variables">A dictionary with the values for the variables and the letters they should replace in the evaluation</param>
/// <returns></returns>
public static T Evaluate(string expression, Dictionary <string, object> variables)
{
var context = new ExpressionContext();
VariableCollection vars = context.Variables;
foreach (KeyValuePair <string, object> variable in variables)
{
vars.Add(variable.Key, variable.Value);
}
return(context.CompileGeneric <T>(expression).Evaluate());
}
public static void SetVariable(string name, Variable value)
{
if (_variables.ContainsKey(name))
{
_variables[name] = value;
}
else
{
_variables.Add(name, value);
}
}
public void SetVariable(string name, Variable value)
{
if (_variables.ContainsKey(name))
{
_variables[name] = value;
}
else
{
value.OnValueChange += DataChange;
_variables.Add(name, value);
}
}
public bool SatisfiesFormula(Formula formula)
{
VariableCollection variable = _expressionContext.Variables;
foreach (var statu in _status)
{
variable.Add(statu.Key.ToString(), statu.Value);
}
bool eval = _expressionContext.CompileGeneric <bool>(formula.Expression).Evaluate();
variable.Clear();
return(eval);
}
/// <summary>
/// 构建一次ExpressionContext，CalculationEngine
/// </summary>
/// <returns></returns>
public static double Test2()
{
Stopwatch stopwatch2 = new Stopwatch();
stopwatch2.Start();
CalculationEngine calculationEngine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
variables.Add("x", 100);
variables.Add("y", 200);
calculationEngine.Add("a", "x+y", context);
for (int i = 0; i < 1000000; i++)
{
variables["x"] = i;
calculationEngine.Recalculate("a");
int j = calculationEngine.GetResult <int>("a");
}
stopwatch2.Stop();
return(stopwatch2.ElapsedMilliseconds);
}
public virtual void Add(IVariable variable)
{
Contract.Requires <ArgumentException>(!Contains(variable));
variable.Owner = this;
if (variable.Semantic != string.Empty)
{
var semanticVars = variables.Where(kvp => kvp.Value.Semantic == variable.Semantic).ToArray();
if (semanticVars.Length > 0)
{
variable.Index = semanticVars.Length;
semanticVars[0].Value.Index = 0;
}
}
variables.Add(variable.Name, variable);
}
public IVariableCollection ResolveLocalVariables(IMethod method, int sig, out bool hasGenericVars)
{
hasGenericVars = false;
var list = new VariableCollection();
if (sig == 0)
{
return(list);
}
var context = new Context(method);
SimpleIndex idx = sig;
var row = Metadata.GetRow(TableId.StandAloneSig, idx.Index - 1);
var reader = row[Schema.StandAloneSig.Signature].Blob;
int prolog = reader.ReadPackedInt();
if (prolog != 0x07)
{
throw new BadSignatureException("Invalid local variable signature.");
}
int varCount = reader.ReadPackedInt();
for (int i = 0; i < varCount; ++i)
{
var typeSig = TypeSignature.Decode(reader);
var type = ResolveType(typeSig, context);
if (!hasGenericVars && type.IsGenericContext())
{
hasGenericVars = true;
}
var v = new Variable
{
Index = i,
Type = type,
Name = string.Format("v{0}", i)
};
list.Add(v);
}
return(list);
}
public static void Map(ref ParametersCollection parameters, VariableCollection variables)
{
if (parameters is null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (variables is null)
{
throw new ArgumentNullException(nameof(variables));
}
foreach (var parameter in parameters)
{
if (variables.ContainsKey(parameter.Name))
{
variables.Remove(parameter.Name);
}
variables.Add(parameter.Name, parameter.Value.Infer());
}
}
private static void smethod_6(VariableCollection A_0, Class394 A_1)
{
int num = 0x12;
while (A_1.method_9(BookmarkStart.b("尷唹弻栽ℿぁ㝃", num)))
{
if (A_1.method_1() == BookmarkStart.b("尷唹弻栽ℿぁ", num))
{
string name = null;
string str2 = null;
while (A_1.method_19())
{
string str3 = A_1.method_1();
if (str3 != null)
{
if (!(str3 == BookmarkStart.b("嘷嬹儻嬽", num)))
{
if (str3 == BookmarkStart.b("丷嬹倻", num))
{
str2 = A_1.method_3();
}
}
else
{
name = A_1.method_3();
}
}
}
if (name != null)
{
A_0.Add(name, str2);
}
}
else
{
A_1.vmethod_1();
}
}
}
protected override void PerformMove()
{
PotvinCustomerRelocationMove move = CustomerRelocationMoveParameter.ActualValue;
PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;
Apply(newSolution, move, ProblemInstance);
newSolution.Repair();
VRPToursParameter.ActualValue = newSolution;
//reset move quality
VRPEvaluation eval = ProblemInstance.Evaluate(newSolution);
MoveQualityParameter.ActualValue.Value = eval.Quality;
//update memory
VariableCollection memory = MemoriesParameter.ActualValue;
string key = AdditionFrequencyMemoryKeyParameter.Value.Value;
if (memory != null)
{
if (!memory.ContainsKey(key))
{
memory.Add(new Variable(key,
new ItemDictionary <PotvinCustomerRelocationMoveAttribute, IntValue>()));
}
ItemDictionary <PotvinCustomerRelocationMoveAttribute, IntValue> additionFrequency =
memory[key].Value as ItemDictionary <PotvinCustomerRelocationMoveAttribute, IntValue>;
PotvinCustomerRelocationMoveAttribute attr = new PotvinCustomerRelocationMoveAttribute(0, move.Tour, move.City);
if (!additionFrequency.ContainsKey(attr))
{
additionFrequency[attr] = new IntValue(0);
}
additionFrequency[attr].Value++;
}
}
/// <summary>Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1" />.</summary>
/// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>
/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1" /> is read-only.</exception>
public void Add(KeyValuePair <string, object> item)
{
_collection.Add(item.Key, item.Value);
}
/// <summary>
/// Reads the next variable declaration statement from the file and returns it.
/// </summary>
/// <param name="parentReference">The parent code unit.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <param name="variables">Returns the list of variables defined in the statement.</param>
/// <returns>Returns the statement.</returns>
private VariableDeclarationStatement ParseVariableDeclarationStatement(
Reference<ICodePart> parentReference, bool unsafeCode, VariableCollection variables)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Param.Ignore(variables);
bool constant = false;
// Get the first symbol and make sure it is an unknown word or a const.
Symbol symbol = this.GetNextSymbol(parentReference);
CsToken firstToken = null;
Node<CsToken> firstTokenNode = null;
var statementReference = new Reference<ICodePart>();
if (symbol.SymbolType == SymbolType.Const)
{
constant = true;
firstToken = new CsToken(symbol.Text, CsTokenType.Const, symbol.Location, statementReference, this.symbols.Generated);
firstTokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Const, SymbolType.Const, statementReference));
symbol = this.GetNextSymbol(statementReference);
}
if (symbol.SymbolType != SymbolType.Other)
{
throw this.CreateSyntaxException();
}
// Get the expression representing the type.
LiteralExpression type = this.GetTypeTokenExpression(statementReference, unsafeCode, true);
if (type == null || type.Tokens.First == null)
{
throw new SyntaxException(this.document.SourceCode, firstToken.LineNumber);
}
if (firstTokenNode == null)
{
firstTokenNode = type.Tokens.First;
}
// Get the rest of the declaration.
VariableDeclarationExpression expression = this.GetVariableDeclarationExpression(type, ExpressionPrecedence.None, unsafeCode);
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, statementReference));
// Add each of the variables defined in this statement to the variable list being returned.
if (variables != null)
{
VariableModifiers modifiers = constant ? VariableModifiers.Const : VariableModifiers.None;
foreach (VariableDeclaratorExpression declarator in expression.Declarators)
{
Variable variable = new Variable(
expression.Type,
declarator.Identifier.Token.Text,
modifiers,
CodeLocation.Join(expression.Type.Location, declarator.Identifier.Token.Location),
statementReference,
expression.Tokens.First.Value.Generated || declarator.Identifier.Token.Generated);
// There might already be a variable in this scope with the same name. This can happen
// in valid situation when there are ifdef's surrounding portions of the code.
// Just accept the first variable and ignore others.
if (!variables.Contains(declarator.Identifier.Token.Text))
{
variables.Add(variable);
}
}
}
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
var statement = new VariableDeclarationStatement(partialTokens, constant, expression);
statementReference.Target = statement;
return statement;
}
public void TestLongBranchLogical1()
{
string expressionText = this.GetIndividualTest("LongBranch1");
ExpressionContext context = new ExpressionContext();
VariableCollection vc = context.Variables;
vc.Add("M0100_ASSMT_REASON", "0");
vc.Add("M0220_PRIOR_NOCHG_14D", "1");
vc.Add("M0220_PRIOR_UNKNOWN", "1");
vc.Add("M0220_PRIOR_UR_INCON", "1");
vc.Add("M0220_PRIOR_CATH", "1");
vc.Add("M0220_PRIOR_INTRACT_PAIN", "1");
vc.Add("M0220_PRIOR_IMPR_DECSN", "1");
vc.Add("M0220_PRIOR_DISRUPTIVE", "1");
vc.Add("M0220_PRIOR_MEM_LOSS", "1");
vc.Add("M0220_PRIOR_NONE", "1");
vc.Add("M0220_PRIOR_UR_INCON_bool", true);
vc.Add("M0220_PRIOR_CATH_bool", true);
vc.Add("M0220_PRIOR_INTRACT_PAIN_bool", true);
vc.Add("M0220_PRIOR_IMPR_DECSN_bool", true);
vc.Add("M0220_PRIOR_DISRUPTIVE_bool", true);
vc.Add("M0220_PRIOR_MEM_LOSS_bool", true);
vc.Add("M0220_PRIOR_NONE_bool", true);
vc.Add("M0220_PRIOR_NOCHG_14D_bool", true);
vc.Add("M0220_PRIOR_UNKNOWN_bool", true);
var e = new DynamicExpression(expressionText, ExpressionLanguage.Flee);
// We only care that the expression is valid and can be evaluated
object result = e.Invoke(context);
}
public override AstNode VisitMethodDecl(MethodDecl ast)
{
m_currentMethod = ast.MethodInfo;
m_currentMethodParameters = new VariableCollection<Parameter>();
foreach (var param in m_currentMethod.Parameters)
{
m_currentMethodParameters.Add(param);
}
m_currentMethodVariables = new VariableCollection<VariableInfo>();
foreach (var statement in ast.Statements)
{
Visit(statement);
}
Visit(ast.ReturnExpression);
return ast;
}
public void CalcEngine_Returns_Same_Values_As_VB()
{
variables.Add("x", 100);
ce.Add("a", "x * 2", context);
variables.Add("y", 1);
ce.Add("b", "a + y", context);
ce.Add("c", "b * 2", context);
ce.Recalculate("a");
var result = ce.GetResult("c");
Assert.AreEqual(result, ((100 * 2) + 1) * 2);
variables["x"] = 345;
ce.Recalculate("a");
result = ce.GetResult("c");
Assert.AreEqual(((345 * 2) + 1) * 2, result);
}
public void Primer()
{
//ExStart
//ExFor:Document.Variables
//ExFor:VariableCollection
//ExFor:VariableCollection.Add
//ExFor:VariableCollection.Clear
//ExFor:VariableCollection.Contains
//ExFor:VariableCollection.Count
//ExFor:VariableCollection.GetEnumerator
//ExFor:VariableCollection.IndexOfKey
//ExFor:VariableCollection.Remove
//ExFor:VariableCollection.RemoveAt
//ExSummary:Shows how to work with a document's variable collection.
Document doc = new Document();
VariableCollection variables = doc.Variables;
// Every document has a collection of key/value pair variables, which we can add items to.
variables.Add("Home address", "123 Main St.");
variables.Add("City", "London");
variables.Add("Bedrooms", "3");
Assert.AreEqual(3, variables.Count);
// We can display the values of variables in the document body using DOCVARIABLE fields.
DocumentBuilder builder = new DocumentBuilder(doc);
FieldDocVariable field = (FieldDocVariable)builder.InsertField(FieldType.FieldDocVariable, true);
field.VariableName = "Home address";
field.Update();
Assert.AreEqual("123 Main St.", field.Result);
// Assigning values to existing keys will update them.
variables.Add("Home address", "456 Queen St.");
// We will then have to update DOCVARIABLE fields to ensure they display an up-to-date value.
Assert.AreEqual("123 Main St.", field.Result);
field.Update();
Assert.AreEqual("456 Queen St.", field.Result);
// Verify that the document variables with a certain name or value exist.
Assert.True(variables.Contains("City"));
Assert.True(variables.Any(v => v.Value == "London"));
// The collection of variables automatically sorts variables alphabetically by name.
Assert.AreEqual(0, variables.IndexOfKey("Bedrooms"));
Assert.AreEqual(1, variables.IndexOfKey("City"));
Assert.AreEqual(2, variables.IndexOfKey("Home address"));
// Enumerate over the collection of variables.
using (IEnumerator <KeyValuePair <string, string> > enumerator = doc.Variables.GetEnumerator())
while (enumerator.MoveNext())
{
Console.WriteLine($"Name: {enumerator.Current.Key}, Value: {enumerator.Current.Value}");
}
// Below are three ways of removing document variables from a collection.
// 1 - By name:
variables.Remove("City");
Assert.False(variables.Contains("City"));
// 2 - By index:
variables.RemoveAt(1);
Assert.False(variables.Contains("Home address"));
// 3 - Clear the whole collection at once:
variables.Clear();
Assert.That(variables, Is.Empty);
//ExEnd
}
public void Primer()
{
//ExStart
//ExFor:Document.Variables
//ExFor:VariableCollection
//ExFor:VariableCollection.Add
//ExFor:VariableCollection.Clear
//ExFor:VariableCollection.Contains
//ExFor:VariableCollection.Count
//ExFor:VariableCollection.GetEnumerator
//ExFor:VariableCollection.IndexOfKey
//ExFor:VariableCollection.Remove
//ExFor:VariableCollection.RemoveAt
//ExSummary:Shows how to work with a document's variable collection.
Document doc = new Document();
VariableCollection variables = doc.Variables;
// Documents have a variable collection to which name/value pairs can be added
variables.Add("Home address", "123 Main St.");
variables.Add("City", "London");
variables.Add("Bedrooms", "3");
Assert.AreEqual(3, variables.Count);
// Variables can be referenced and have their values presented in the document by DOCVARIABLE fields
DocumentBuilder builder = new DocumentBuilder(doc);
FieldDocVariable field = (FieldDocVariable)builder.InsertField(FieldType.FieldDocVariable, true);
field.VariableName = "Home address";
field.Update();
Assert.AreEqual("123 Main St.", field.Result);
// Assigning values to existing keys will update them
variables.Add("Home address", "456 Queen St.");
// DOCVARIABLE fields also need to be updated in order to show an accurate up to date value
field.Update();
Assert.AreEqual("456 Queen St.", field.Result);
// The existence of variables can be looked up either by name or value like this
Assert.True(variables.Contains("City"));
Assert.True(variables.Any(v => v.Value == "London"));
// Variables are automatically sorted in alphabetical order
Assert.AreEqual(0, variables.IndexOfKey("Bedrooms"));
Assert.AreEqual(1, variables.IndexOfKey("City"));
Assert.AreEqual(2, variables.IndexOfKey("Home address"));
// Enumerate over the collection of variables
using (IEnumerator <KeyValuePair <string, string> > enumerator = doc.Variables.GetEnumerator())
while (enumerator.MoveNext())
{
Console.WriteLine($"Name: {enumerator.Current.Key}, Value: {enumerator.Current.Value}");
}
// Variables can be removed either by name or index, or the entire collection can be cleared at once
variables.Remove("City");
Assert.False(variables.Contains("City"));
variables.RemoveAt(1);
Assert.False(variables.Contains("Home address"));
variables.Clear();
Assert.That(variables, Is.Empty);
//ExEnd
}
private VariableDeclarationStatement ParseVariableDeclarationStatement(bool unsafeCode, VariableCollection variables)
{
bool constant = false;
Symbol nextSymbol = this.GetNextSymbol();
CsToken token = null;
Microsoft.StyleCop.Node<CsToken> firstItemNode = null;
if (nextSymbol.SymbolType == SymbolType.Const)
{
constant = true;
token = new CsToken(nextSymbol.Text, CsTokenType.Const, nextSymbol.Location, this.symbols.Generated);
firstItemNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Const, SymbolType.Const));
nextSymbol = this.GetNextSymbol();
}
if (nextSymbol.SymbolType != SymbolType.Other)
{
throw this.CreateSyntaxException();
}
LiteralExpression typeTokenExpression = this.GetTypeTokenExpression(unsafeCode, true);
if ((typeTokenExpression == null) || (typeTokenExpression.Tokens.First == null))
{
throw new SyntaxException(this.document.SourceCode, token.LineNumber);
}
if (firstItemNode == null)
{
firstItemNode = typeTokenExpression.Tokens.First;
}
VariableDeclarationExpression expression = this.GetVariableDeclarationExpression(typeTokenExpression, ExpressionPrecedence.None, unsafeCode);
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon));
if (variables != null)
{
VariableModifiers modifiers = constant ? VariableModifiers.Const : VariableModifiers.None;
foreach (VariableDeclaratorExpression expression3 in expression.Declarators)
{
Variable variable = new Variable(expression.Type, expression3.Identifier.Token.Text, modifiers, expression3.Tokens.First.Value.Location.StartPoint, expression.Tokens.First.Value.Generated || expression3.Identifier.Token.Generated);
if (!variables.Contains(expression3.Identifier.Token.Text))
{
variables.Add(variable);
}
}
}
return new VariableDeclarationStatement(new CsTokenList(this.tokens, firstItemNode, this.tokens.Last), constant, expression);
}
public override AstNode VisitMethodDecl(MethodDecl ast)
{
m_currentMethod = ast.MethodInfo;
m_currentVariableIndex = 0;
m_currentMethodParameters = new VariableCollection<Parameter>();
foreach (var param in m_currentMethod.Parameters)
{
m_currentMethodParameters.Add(param);
}
m_currentMethodVariables = new VariableCollection<VariableInfo>();
if (ast.Statements == null || ast.ReturnExpression == null)
{
m_errorManager.AddError(c_SE_NotSupported, ast.Name.Span, "A method must have body defined");
return ast;
}
foreach (var statement in ast.Statements)
{
Visit(statement);
}
Visit(ast.ReturnExpression);
return ast;
}
