public bool VariableIsRemovable(Variable variable) { return !(variable is BoundVariable); }
/// <summary> /// Try to make a new local variable at the localmost scoping level and /// give it a starting value. It errors out of there is already one there /// by the same name.<br/> /// <br/> /// This does NOT scan up the scoping stack like SetValue() does. /// It operates at the local level only.<br/> /// <br/> /// This is the normal way to make a new local variable. You cannot make a /// local variable without attempting to give it a value. /// </summary> /// <param name="identifier">variable name to attempt to store into</param> /// <param name="value">value to put into it</param> public void SetNewLocal(string identifier, object value) { Variable variable; VariableScope localDict = GetNestedDictionary(0); if (!localDict.Variables.TryGetValue(identifier, out variable)) { variable = new Variable { Name = identifier }; AddVariable(variable, identifier, true); } variable.Value = value; }
/// <summary> /// Make a new global variable at the localmost scoping level and /// give it a starting value, or overwrite an existing variable /// at the localmost level with a starting value.<br/> /// <br/> /// This does NOT scan up the scoping stack like SetValue() does. /// It operates at the global level only.<br/> /// </summary> /// <param name="identifier">variable name to attempt to store into</param> /// <param name="value">value to put into it</param> public void SetGlobal(string identifier, object value) { Variable variable; // Attempt to get it as a global. Make a new one if it's not found. // This preserves the "bound-ness" of the variable if it's a // BoundVariable, whereas unconditionally making a new Variable wouldn't: if (!globalVariables.Variables.TryGetValue(identifier, out variable)) { variable = new Variable { Name = identifier }; AddVariable(variable, identifier, false, true); } variable.Value = value; }
/// <summary> /// Make a new variable at either the local depth or the /// global depth depending. /// throws exception if it already exists as a boundvariable at the desired /// scope level, unless overwrite = true. /// </summary> /// <param name="variable">variable to add</param> /// <param name="identifier">name of variable to add</param> /// <param name="local">true if you want to make it at local depth</param> /// <param name="overwrite">true if it's okay to overwrite an existing variable</param> public void AddVariable(Variable variable, string identifier, bool local, bool overwrite = false) { identifier = identifier.ToLower(); if (!identifier.StartsWith("$")) { identifier = "$" + identifier; } VariableScope whichDict = local ? GetNestedDictionary(0) : globalVariables; if (whichDict.Variables.ContainsKey(identifier)) { if (whichDict.Variables[identifier].Value is BoundVariable) if (!overwrite) throw new KOSIdentiferClashException(identifier); whichDict.Variables.Remove(identifier); } whichDict.Variables.Add(identifier, variable); }
/// <summary> /// Get the value of a variable or create it at global scope if not found. /// </summary> /// <param name="identifier"></param> /// <returns></returns> private Variable GetOrCreateVariable(string identifier) { Variable variable = GetVariable(identifier, false, true); if (variable == null) { variable = new Variable { Name = identifier }; AddVariable(variable, identifier, false); } return variable; }
public void AddVariable(Variable variable, string identifier, bool local, bool overwrite = false) { throw new NotImplementedException(); }