/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="check"></param>
/// <returns></returns>
public bool Equals(VariableIdentifier check)
{
if (check != null)
{
// name and id exist
if (!string.IsNullOrEmpty(check.name) && (check.id != null && check.id != 0))
{
if (check.name.Equals(name) && check.id.Equals(id)) return true;
else return false;
}
else
{
// name is empty
if (string.IsNullOrEmpty(check.name) && (check.id != null || check.id != 0))
{
if (check.id.Equals(id)) return true;
else return false;
}
else
{
//id is empty
if (!string.IsNullOrEmpty(check.name) && (check.id == null || check.id == 0))
{
if (check.name.Equals(name)) return true;
else return false;
}
}
return false;
}
}
else return false;
}
/// <summary>
/// Force a variable to have a slot. Returns -1 if the variable has an empty struct type.
/// </summary>
protected int GetOrCreateSlot(Symbol symbol, int containingSlot = 0, bool forceSlotEvenIfEmpty = false)
{
Debug.Assert(containingSlot >= 0);
if (symbol.Kind == SymbolKind.RangeVariable)
{
return(-1);
}
containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: true);
if (containingSlot < 0)
{
// Error case. Diagnostics should already have been produced.
return(-1);
}
VariableIdentifier identifier = new VariableIdentifier(symbol, containingSlot);
int slot;
// Since analysis may proceed in multiple passes, it is possible the slot is already assigned.
if (!_variableSlot.TryGetValue(identifier, out slot))
{
var variableType = symbol.GetTypeOrReturnType().Type;
if (!forceSlotEvenIfEmpty && IsEmptyStructType(variableType))
{
return(-1);
}
if (_maxSlotDepth > 0 && GetSlotDepth(containingSlot) >= _maxSlotDepth)
{
return(-1);
}
slot = nextVariableSlot++;
_variableSlot.Add(identifier, slot);
if (slot >= variableBySlot.Length)
{
Array.Resize(ref this.variableBySlot, slot * 2);
}
variableBySlot[slot] = identifier;
}
if (IsConditionalState)
{
Normalize(ref this.StateWhenTrue);
Normalize(ref this.StateWhenFalse);
}
else
{
Normalize(ref this.State);
}
return(slot);
}
/// <inheritdoc />
protected override void flowThrough()
{
var variables = new VariableIdentifier[_variables.Length];
for (int i = 0; i < _variables.Length; ++i)
{
variables[i] = _variables[i].LValue.GetVariableIdentifier(OutSnapshot);
}
Services.Evaluator.GlobalStatement(variables);
}
public VariableIdentifier ParseVariableName()
{
VariableIdentifier var = TryParseVariable();
if (var == null)
{
Log.LogError("Expected a variable name!", CurrentPosition);
return(null);
}
return(var);
}
protected Symbol GetNonMemberSymbol(int slot)
{
VariableIdentifier variableId = variableBySlot[slot];
while (variableId.ContainingSlot > 0)
{
Debug.Assert(variableId.Symbol.Kind == SymbolKind.Field || variableId.Symbol.Kind == SymbolKind.Property || variableId.Symbol.Kind == SymbolKind.Event);
variableId = variableBySlot[variableId.ContainingSlot];
}
return(variableId.Symbol);
}
/// <summary>
/// Compare Datastructure with Submited Variables
/// And create a Dictionary of ValueValidationmanagers
/// </summary>
/// <remarks></remarks>
/// <param name="row"></param>
/// <returns></returns>
public List <Error> ValidateComparisonWithDatatsructure(List <VariableIdentifier> variableIdentifers)
{
List <Error> errors = new List <Error>();
try
{
List <VariableIdentifier> source = getDatastructureVariableIdentifiers();
DatastructureMatchCheck dmc = new DatastructureMatchCheck();
errors = dmc.Execute(SubmitedVariableIdentifiers, source, this.StructuredDataStructure.Name);
}
catch
{
}
if (errors == null)
{
for (int i = 0; i < variableIdentifers.Count; i++)
{
VariableIdentifier hv = variableIdentifers.ElementAt(i);
if (hv != null)
{
Variable sdvu = getVariableUsage(hv);
if (sdvu != null)
{
string varName = sdvu.Label;
bool optional = sdvu.IsValueOptional;
string dataType = sdvu.DataAttribute.DataType.SystemType;
// change parameters to only sdvu
this.ValueValidationManagerDic.Add(sdvu.Id, createValueValidationManager(varName, dataType, optional, sdvu.DataAttribute));
}
else
{
errors.Add(new Error(ErrorType.Datastructure, "Error with name of Variable"));
}
}
}//for
}
else
{
if (errors.Count > 0)
{
return(errors);
}
else
{
return(null);
}
}
return(null);
}
private void fatalError(FlowController flow, bool removeFlowChildren)
{
var catchedType = new GenericQualifiedName(new QualifiedName(new Name(string.Empty)));
var catchVariable = new VariableIdentifier(string.Empty);
var description = new CatchBlockDescription(flow.ProgramEnd, catchedType, catchVariable);
var info = new ThrowInfo(description, new MemoryEntry());
var throws = new ThrowInfo[] { info };
flow.SetThrowBranching(throws, removeFlowChildren);
}
/// <summary>
/// Create field representation for given field
/// </summary>
/// <param name="field">Field which representation is created</param>
/// <returns>Created field representation</returns>
private string fieldRepresentation(VariableIdentifier field)
{
var name = new StringBuilder();
foreach (var possibleName in field.PossibleNames)
{
name.Append(possibleName);
name.Append(',');
}
return(name.ToString());
}
private static void TestEvaluation(string code, MemoryEntry testInputEntry)
{
var analysis = TestUtils.GenerateForwardAnalysis(code);
var identifier = new VariableIdentifier(inputVariableName);
var snapshotEntry = analysis.EntryInput.GetVariable(identifier, true);
snapshotEntry.WriteMemory(analysis.EntryInput.Snapshot, testInputEntry);
// Do not test results, just test whether all operations are supported
var ppg = TestUtils.GeneratePpg(analysis);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReadFieldVisitor"/> class.
/// </summary>
/// <param name="containingIndex">Index of the containing.</param>
/// <param name="fieldSegment">The field segment.</param>
/// <param name="locations">The locations.</param>
public ReadFieldVisitor(MemoryIndex containingIndex, FieldPathSegment fieldSegment, ICollection <ValueLocation> locations)
{
this.containingIndex = containingIndex;
this.locations = locations;
ContainsUndefinedValue = false;
ContainsDefinedValue = false;
ContainsObjectValue = false;
ContainsAnyValue = false;
index = new VariableIdentifier(fieldSegment.Names);
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="check"></param>
/// <returns></returns>
public bool Equals(VariableIdentifier check)
{
if (check != null)
{
// name and id exist
if (!string.IsNullOrEmpty(check.name) && (check.id != null && check.id != 0))
{
if (check.name.Equals(name) && check.id.Equals(id))
{
return(true);
}
else
{
return(false);
}
}
else
{
// name is empty
if (string.IsNullOrEmpty(check.name) && (check.id != null || check.id != 0))
{
if (check.id.Equals(id))
{
return(true);
}
else
{
return(false);
}
}
else
{
//id is empty
if (!string.IsNullOrEmpty(check.name) && (check.id == null || check.id == 0))
{
if (check.name.Equals(name))
{
return(true);
}
else
{
return(false);
}
}
}
return(false);
}
}
else
{
return(false);
}
}
public List <VariableIdentifier> SetSubmitedVariableIdentifiers(List <string> variableNames)
{
SubmitedVariableIdentifiers = new List <VariableIdentifier>();
foreach (string s in variableNames)
{
VariableIdentifier vi = new VariableIdentifier();
vi.name = s;
SubmitedVariableIdentifiers.Add(vi);
}
return(SubmitedVariableIdentifiers);
}
/// <summary>
/// Force a variable to have a slot. Returns -1 if the variable has an empty struct type.
/// </summary>
protected virtual int GetOrCreateSlot(Symbol symbol, int containingSlot = 0, bool forceSlotEvenIfEmpty = false, bool createIfMissing = true)
{
Debug.Assert(containingSlot >= 0);
Debug.Assert(symbol != null);
if (symbol.Kind == SymbolKind.RangeVariable)
{
return(-1);
}
containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: true);
if (containingSlot < 0)
{
// Error case. Diagnostics should already have been produced.
return(-1);
}
VariableIdentifier identifier = new VariableIdentifier(symbol, containingSlot);
int slot;
// Since analysis may proceed in multiple passes, it is possible the slot is already assigned.
if (!TryGetVariable(identifier, out slot))
{
if (!createIfMissing)
{
return(-1);
}
var variableType = symbol.GetTypeOrReturnType().Type;
if (!forceSlotEvenIfEmpty && IsEmptyStructType(variableType))
{
return(-1);
}
slot = AddVariable(identifier);
}
if (IsConditionalState)
{
Normalize(ref this.StateWhenTrue);
Normalize(ref this.StateWhenFalse);
}
else
{
Normalize(ref this.State);
}
return(slot);
}
private static void _define(FlowController flow)
{
var arg0 = ReadNumberedArgument(flow.InSet, 0);
var arg1 = ReadNumberedArgument(flow.InSet, 1);
foreach (StringValue constName in arg0.PossibleValues)
{
var constVarId = new VariableIdentifier(".constant_" + constName.Value);
var constVar = flow.OutSet.GetVariable(constVarId);
flow.OutSet.FetchFromGlobal(constVarId.DirectName);
constVar.WriteMemory(flow.OutSet.Snapshot, arg1);
}
}
internal IEnumerable <VariableKeyBase> FieldStorages(Value objectValue, VariableIdentifier field)
{
var storages = new List <VariableKeyBase>();
foreach (var fieldName in field.PossibleNames)
{
//TODO refactor ContainerIndex API
var fieldIndex = CreateIndex(fieldName.Value);
var key = getFieldStorage(objectValue, fieldIndex);
storages.Add(key);
}
return(storages);
}
/// <inheritdoc />
protected override ReadWriteSnapshotEntryBase getVariable(VariableIdentifier variable, bool forceGlobalContext)
{
var kind = repairKind(VariableKind.Local, forceGlobalContext);
var storages = new List <VariableKeyBase>();
foreach (var name in variable.PossibleNames)
{
var key = getOrCreateKey(name, kind);
storages.Add(key);
}
return(new SnapshotStorageEntry(variable, false, storages.ToArray()));
}
public override ReadWriteSnapshotEntryBase ResolveIndirectStaticField(MemoryEntry typeNames, VariableIdentifier field)
{
var variables = new List <string>();
foreach (var typeName in TypeNames(typeNames))
{
var varName = string.Format("{0}::{1}", typeName, field.DirectName);
variables.Add(varName);
}
var identifier = new VariableIdentifier(variables.ToArray());
return(OutSet.GetVariable(identifier));
}
private static void TestVariableResults(FlowOutputSet outSet, Value[] results,
Func <int, string> nameGenerator)
{
for (var i = 0; i < results.Length; ++i)
{
var identifier = new VariableIdentifier(nameGenerator(i));
var snapshotEntry = outSet.GetVariable(identifier, true);
var entry = snapshotEntry.ReadMemory(outSet.Snapshot);
var enumerator = entry.PossibleValues.GetEnumerator();
enumerator.MoveNext();
var value = enumerator.Current as Value;
Assert.AreEqual(results[i], value);
}
}
private static void AppendVariablePaths(List <LValueInfo> paths, VariableIdentifier var)
{
ExpressionSyntax varAccess = IdentifierName(var.Name);
AddPathsRecursive(varAccess, var.Type, var.RefEscapeScope);
void AddPathsRecursive(ExpressionSyntax curAccess, FuzzType curType, int curRefEscapeScope)
{
LValueInfo info = new LValueInfo(curAccess, curType, curRefEscapeScope);
paths.Add(info);
if (curType is RefType rt)
{
curType = rt.InnerType;
}
switch (curType)
{
case ArrayType arr:
AddPathsRecursive(
ElementAccessExpression(
curAccess,
BracketedArgumentList(
SeparatedList(
Enumerable.Repeat(
Argument(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))),
arr.Rank)))),
arr.ElementType,
curRefEscapeScope: int.MaxValue);
break;
case AggregateType agg:
foreach (AggregateField field in agg.Fields)
{
AddPathsRecursive(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
curAccess,
IdentifierName(field.Name)),
field.Type,
curRefEscapeScope: agg.IsClass?int.MaxValue: curRefEscapeScope);
}
break;
}
}
}
public List <VariableIdentifier> ParseVariableNames()
{
List <VariableIdentifier> vars = new List <VariableIdentifier>();
do
{
VariableIdentifier variable = TryParseVariable();
if (variable == null)
{
Log.LogError("Expected at least one variable name!", CurrentPosition, CurrentPosition.GetModifiedPosition(0, 1, 1));
return(null);
}
vars.Add(variable);
} while (Tokens.ConsumeToken(TokenType.Comma) != null);
// TODO: This allows a trailing comma before semicolon, intended?
return(vars);
}
private static void SetInputOperands(FlowOutputSet entryInput, Value[] leftOperands,
Value[] rightOperands)
{
Debug.Assert(leftOperands.Length == rightOperands.Length,
"Number of left and right operands is the same");
for (var i = 0; i < leftOperands.Length; ++i)
{
var identifier = new VariableIdentifier(string.Concat("left", i.ToString()));
var snapshotEntry = entryInput.GetVariable(identifier, true);
snapshotEntry.WriteMemoryWithoutCopy(entryInput.Snapshot, new MemoryEntry(leftOperands[i]));
identifier = new VariableIdentifier(string.Concat("right", i.ToString()));
snapshotEntry = entryInput.GetVariable(identifier, true);
snapshotEntry.WriteMemoryWithoutCopy(entryInput.Snapshot, new MemoryEntry(rightOperands[i]));
}
}
/// <summary>
/// Force a variable to have a slot. Returns -1 if the variable has an empty struct type.
/// </summary>
protected int GetOrCreateSlot(Symbol symbol, int containingSlot = 0)
{
if (symbol.Kind == SymbolKind.RangeVariable)
{
return(-1);
}
containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: true);
VariableIdentifier identifier = new VariableIdentifier(symbol, containingSlot);
int slot;
// Since analysis may proceed in multiple passes, it is possible the slot is already assigned.
if (!_variableSlot.TryGetValue(identifier, out slot))
{
var variableType = VariableType(symbol).TypeSymbol;
if (_emptyStructTypeCache.IsEmptyStructType(variableType))
{
return(-1);
}
slot = nextVariableSlot++;
_variableSlot.Add(identifier, slot);
if (slot >= variableBySlot.Length)
{
Array.Resize(ref this.variableBySlot, slot * 2);
}
variableBySlot[slot] = identifier;
}
if (IsConditionalState)
{
Normalize(ref this.StateWhenTrue);
Normalize(ref this.StateWhenFalse);
}
else
{
Normalize(ref this.State);
}
return(slot);
}
/// <inheritdoc />
public override IEnumerable <Value> ReadValueField(Value fielded, VariableIdentifier field)
{
if (fielded is AnyObjectValue)
{
yield return(Context.AnyValue);
}
else if (fielded is UndefinedValue)
{
yield return(Context.UndefinedValue);
}
else
{
SetWarning("Cannot use operator -> on variable other than object", AnalysisWarningCause.CANNOT_ACCESS_OBJECT_OPERATOR_ON_NON_OBJECT);
if (fielded is AnyValue)
{
yield return(Context.AnyValue);
}
yield return(Context.UndefinedValue);
}
}
/// <inheritdoc />
public override MemoryEntry ReadAnyField(AnyValue value, VariableIdentifier field)
{
// TODO: Copy info
if (value is AnyObjectValue)
{
SetWarning("Possibly undefined property");
return(new MemoryEntry(Context.AnyValue));
}
else if ((value is AnyScalarValue) || (value is AnyArrayValue) || (value is AnyResourceValue))
{
SetWarning("Trying to get property of non-object",
AnalysisWarningCause.PROPERTY_OF_NON_OBJECT_VARIABLE);
return(new MemoryEntry(Context.UndefinedValue));
}
else
{
// This is case of AnyValue and possibly others.
return(new MemoryEntry(Context.AnyValue));
}
}
/// <inheritdoc />
protected override void flowThrough()
{
var varNames = Services.Evaluator.VariableNames(VariableName.Value.ReadMemory(OutSnapshot));
if (varNames == null)
{
varNames = new string[0];
}
var variable = new VariableIdentifier(varNames);
if (ThisObj == null)
{
LValue = Services.Evaluator.ResolveVariable(variable);
}
else
{
LValue = Services.Evaluator.ResolveField(ThisObj.Value, variable);
}
}
public override MemoryEntry Constant(GlobalConstUse x)
{
Value result;
switch (x.Name.Name.Value)
{
case "true":
result = OutSet.CreateBool(true);
break;
case "false":
result = OutSet.CreateBool(false);
break;
default:
var constantName = ".constant_" + x.Name;
var constantVar = new VariableIdentifier(constantName);
OutSet.FetchFromGlobal(constantVar.DirectName);
return(OutSet.ReadVariable(constantVar).ReadMemory(OutSnapshot));
}
return(new MemoryEntry(result));
}
public override MemoryEntry ResolveIndexedVariable(VariableIdentifier variable)
{
var snapshotEntry = ResolveVariable(variable);
var entry = snapshotEntry.ReadMemory(OutSnapshot);
Debug.Assert(entry.Count > 0, "Every resolved variable must give at least one value");
// NOTE: there should be precise resolution of multiple values
var arrayValue = entry.PossibleValues.First();
var undefinedValue = arrayValue as UndefinedValue;
if (undefinedValue != null)
{
arrayValue = OutSet.CreateArray();
var newEntry = new MemoryEntry(arrayValue);
snapshotEntry.WriteMemory(OutSnapshot, newEntry);
return(newEntry);
}
else
{
return(entry);
}
}
/// <summary>
/// Validate a row
/// </summary>
/// <seealso cref=""/>
/// <param name="row">List of strings</param>
/// <param name="indexOfRow">Index of row</param>
/// <returns>List of errors or null</returns>
public List <Error> ValidateRow(List <string> row, int indexOfRow)
{
List <Error> errors = new List <Error>();
// number of variables in datastructure
int numOfVariables = this.StructuredDataStructure.Variables.Count();
// number of current row values
int rowCount = row.Count();
// number of is equal
if (numOfVariables.Equals(rowCount))
{
int valuePosition = 0;
foreach (string v in row)
{
try
{
VariableIdentifier hv = SubmitedVariableIdentifiers.ElementAt(row.IndexOf(v));
Variable sdvu = getVariableUsage(hv);
ValueValidationManager validationManager = ValueValidationManagerDic[sdvu.Id];
List <Error> temp = new List <Error>();
// returns the checked value and update the error list if error appears
object value = validationManager.CheckValue(v, indexOfRow, ref temp);
if (temp.Count == 0)
{
temp = validationManager.ValidateValue(v, indexOfRow);
// check Constraints
foreach (Constraint constraint in sdvu.DataAttribute.Constraints)
{
//new Error(ErrorType.Value, "Not in Range", new object[] { name, value, row, dataType });
if (!constraint.IsSatisfied(value))
{
temp.Add(new Error(ErrorType.Value, constraint.ErrorMessage, new object[] { sdvu.Label, value, indexOfRow, sdvu.DataAttribute.DataType.Name }));
}
}
}
if (temp != null)
{
errors = errors.Union(temp).ToList();
}
valuePosition++;
}
catch
{
//test
if (true)
{
}
}
}
}
// different value lenght
else
{
Error e = new Error(ErrorType.Other, "Number of Values different as number of variables");
errors.Add(e);
}
NumberOfRows++;
return(errors);
}
/// <summary>
/// Read Row and convert each value into a variableValue
/// and each row to a Datatuple
/// </summary>
/// <param name="row">List of values in one row</param>
/// <param name="indexOfRow">Currently row index</param>
/// <returns>DataTuple</returns>
public DataTuple ReadRow(List <string> row, int indexOfRow)
{
DataTuple dt = new DataTuple();
string value = "";
// convert row to List<VariableValue>
for (int i = 0; i < row.Count(); i++)
{
VariableIdentifier variableIdentifier = this.SubmitedVariableIdentifiers.ElementAt(i);
long variableId = 0;
if (variableIdentifier.id > 0)
{
variableId = this.SubmitedVariableIdentifiers.ElementAt(i).id;
}
else
{
variableId = getVariableUsage(variableIdentifier).Id;
}
// if variable from systemtype datatime
// maybee needs to convert into the default datetime culture format
if (this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("DateTime"))
{
Dlm.Entities.DataStructure.DataType dataType = this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType;
if (dataType != null && dataType.Extra != null)
{
DataTypeDisplayPattern dp = DataTypeDisplayPattern.Materialize(dataType.Extra);
if (dp != null && !string.IsNullOrEmpty(dp.StringPattern))
{
value = IOUtility.ConvertToDateUS(row[i], dp.StringPattern);
}
else
{
value = IOUtility.ConvertDateToCulture(row[i]);
}
}
else
{
value = IOUtility.ConvertDateToCulture(row[i]);
}
}
else
{
if (this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Double") ||
this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Decimal") ||
this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Float"))
{
value = row[i];
if (Info.Decimal.Equals(DecimalCharacter.comma))
{
if (value.Contains("."))
{
value = value.Replace(".", "");
}
if (value.Contains(","))
{
value = value.Replace(',', '.');
}
}
if (Info.Decimal.Equals(DecimalCharacter.point))
{
if (value.Contains(","))
{
value = value.Remove(',');
}
}
}
else
{
value = row[i];
}
}
dt.VariableValues.Add(DatasetManager.CreateVariableValue(value, "", DateTime.Now, DateTime.Now, new ObtainingMethod(), variableId, new List <ParameterValue>()));
}
return(dt);
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="worksheetPart"></param>
/// <param name="startRow"></param>
/// <param name="endRow"></param>
/// <returns></returns>
private List <VariableIdentifier> getVariableIdentifiers(WorksheetPart worksheetPart, int startRow, int endRow)
{
//NEW OPENXMLREADER
if (this.VariableIdentifiers == null || this.VariableIdentifiers.Count == 0)
{
OpenXmlReader reader = OpenXmlReader.Create(worksheetPart);
int rowNum = 0;
// read variable rows to get name and id from area variable
while (reader.Read())
{
if (reader.ElementType == typeof(Row))
{
do
{
if (reader.HasAttributes)
{
rowNum = Convert.ToInt32(reader.Attributes.First(a => a.LocalName == "r").Value);
}
if (rowNum >= startRow && rowNum <= endRow)
{
Row row = (Row)reader.LoadCurrentElement();
if (row.Hidden == null)
{
VariableIdentifierRows.Add(rowToList(row));
}
else if (row.Hidden != true)
{
VariableIdentifierRows.Add(rowToList(row));
}
}
} while (reader.ReadNextSibling() && rowNum < endRow); // Skip to the next row
break;
}
}
// convert variable rows to VariableIdentifiers
if (VariableIdentifierRows != null)
{
foreach (List <string> l in VariableIdentifierRows)
{
//create headerVariables
if (VariableIdentifiers.Count == 0)
{
foreach (string s in l)
{
VariableIdentifier hv = new VariableIdentifier();
hv.name = s;
VariableIdentifiers.Add(hv);
}
}
else
{
foreach (string s in l)
{
int id = Convert.ToInt32(s);
int index = l.IndexOf(s);
VariableIdentifiers.ElementAt(index).id = id;
}
}
}
}
}
if (this.VariableIdentifiers != null)
{
return(this.VariableIdentifiers);
}
else
{
return(null);
}
}
public DoorScript(VariableIdentifier keyIdentifier, VariableLookup lookup, string doorName)
{
this.keyIdentifier = keyIdentifier;
this.doorStateIdentifier = lookup.Unique("door state");
this.doorName = doorName;
}
