/// <summary> /// array[index1][index2][...][indexN] = value, and /// indices = {index1, index2, ..., indexN} /// /// Note this function doesn't support the replication of array indexing. /// </summary> /// <param name="array"></param> /// <param name="indices"></param> /// <param name="value"></param> /// <param name="core"></param> /// <returns></returns> public static StackValue SetValueForIndices(StackValue array, StackValue[] indices, StackValue value, Core core) { Validity.Assert(array.IsArray || array.IsString); for (int i = 0; i < indices.Length - 1; ++i) { StackValue index = indices[i]; HeapElement he = GetHeapElement(array, core); StackValue subArray; if (index.IsNumeric) { index = index.ToInteger(); int absIndex = he.ExpandByAcessingAt((int)index.opdata); subArray = he.Stack[absIndex]; } else { subArray = GetValueFromIndex(array, index, core); } // auto-promotion if (!subArray.IsArray) { subArray = core.Heap.AllocateArray(new StackValue[] { subArray }, null); GCUtils.GCRetain(subArray, core); SetValueForIndex(array, index, subArray, core); } array = subArray; } return(SetValueForIndex(array, indices[indices.Length - 1], value, core)); }
public static StackValue SetDataAtIndices(StackValue array, int[] indices, StackValue data, Core core) { Validity.Assert(array.optype == AddressType.ArrayPointer || array.optype == AddressType.String); StackValue arrayItem = array; for (int i = 0; i < indices.Length - 1; ++i) { HeapElement arrayHeap = core.Heap.Heaplist[(int)arrayItem.opdata]; int index = arrayHeap.ExpandByAcessingAt(indices[i]); arrayItem = arrayHeap.Stack[index]; if (arrayItem.optype == AddressType.String) { core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kOverIndexing, ProtoCore.RuntimeData.WarningMessage.kStringOverIndexed); return(StackUtils.BuildNull()); } else if (arrayItem.optype != AddressType.ArrayPointer) { StackValue sv = HeapUtils.StoreArray(new StackValue[] { arrayItem }, core); GCUtils.GCRetain(sv, core); arrayHeap.Stack[index] = sv; arrayItem = arrayHeap.Stack[index]; } } return(ArrayUtils.SetDataAtIndex(arrayItem, indices[indices.Length - 1], data, core)); }
/// <summary> /// array[index] = value. The array will be expanded if necessary. /// </summary> /// <param name="array"></param> /// <param name="index"></param> /// <param name="value"></param> /// <param name="core"></param> /// <returns></returns> public static StackValue SetValueForIndex(StackValue array, int index, StackValue value, RuntimeCore runtimeCore) { Validity.Assert(array.IsArray); HeapElement arrayHeap = GetHeapElement(array, runtimeCore); index = arrayHeap.ExpandByAcessingAt(index); StackValue oldValue = arrayHeap.SetValue(index, value); return(oldValue); }
/// <summary> /// array[index] = value. The array will be expanded if necessary. /// </summary> /// <param name="array"></param> /// <param name="index"></param> /// <param name="value"></param> /// <param name="core"></param> /// <returns></returns> public static StackValue SetValueForIndex(StackValue array, int index, StackValue value, Core core) { Validity.Assert(array.IsArray || array.IsString); if (array.IsString && !value.IsChar) { core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, RuntimeData.WarningMessage.kAssignNonCharacterToString); return(StackValue.Null); } HeapElement arrayHeap = GetHeapElement(array, core); index = arrayHeap.ExpandByAcessingAt(index); StackValue oldValue = arrayHeap.SetValue(index, value); return(oldValue); }
/// <summary> /// array[index] = value. The array will be expanded if necessary. /// </summary> /// <param name="array"></param> /// <param name="index"></param> /// <param name="value"></param> /// <param name="core"></param> /// <returns></returns> public static StackValue SetValueForIndex(StackValue array, int index, StackValue value, Core core) { Validity.Assert(StackUtils.IsArray(array) || StackUtils.IsString(array)); if (StackUtils.IsString(array) && value.optype != AddressType.Char) { core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, RuntimeData.WarningMessage.kAssignNonCharacterToString); return(StackUtils.BuildNull()); } lock (core.Heap.cslock) { HeapElement arrayHeap = GetHeapElement(array, core); index = arrayHeap.ExpandByAcessingAt(index); StackValue oldValue = arrayHeap.SetValue(index, value); return(oldValue); } }
public static StackValue SetDataAtIndex(StackValue svArray, int index, StackValue svData, Core core) { Validity.Assert(svArray.optype == AddressType.ArrayPointer || svArray.optype == AddressType.String); if (svArray.optype == AddressType.String && svData.optype != AddressType.Char) { core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, RuntimeData.WarningMessage.kAssignNonCharacterToString); return(StackUtils.BuildNull()); } lock (core.Heap.cslock) { HeapElement arrayHeap = core.Heap.Heaplist[(int)svArray.opdata]; index = arrayHeap.ExpandByAcessingAt(index); StackValue oldValue = arrayHeap.SetValue(index, svData); return(oldValue); } }