public static final String IMG_OBJS_ARRAY_PARTITION = NAME_PREFIX + "arraypartition_obj.gif"; //$NON-NLS-1$

    public static final ImageDescriptor DESC_OBJS_ARRAY_PARTITION = createManaged(T_OBJ, IMG_OBJS_ARRAY_PARTITION);

import java.util.Arrays;

import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;

	private static final int PARTITION_LENGTH = 100;

        }

    }

    /**

	 * @since 4.1

	 */

    protected static class IndexedPartitionDMC extends MIExpressionDMC implements IIndexedPartitionDMContext {

    	final private ExpressionInfo fParentInfo;

		private final int fIndex;

    	private final int fLength;

		public IndexedPartitionDMC(

				String sessionId, 

				ExpressionInfo parentInfo, 

				IFrameDMContext frameCtx, 

				int index, 

				int length) {

			this(sessionId, parentInfo, (IDMContext)frameCtx, index, length);

		}

    	private IndexedPartitionDMC(

    			String sessionId, 

    			ExpressionInfo parentInfo, 

    			IDMContext parent, 

    			int index, 

    			int length) {

			super(sessionId, createExpressionInfo(parentInfo, index, length), parent);

			fIndex = index;

			fLength = length;

			fParentInfo = parentInfo;

		}

    	public ExpressionInfo getParentInfo() {

    		return fParentInfo;

    	}

		/* (non-Javadoc)

		 * @see org.eclipse.cdt.dsf.debug.service.IExpressions4.IIndexedPartitionDMContext#getParentExpression()

		 */

		@Override

		public String getParentExpression() {

			return getParentInfo().getFullExpr();

		}

		@Override

		public int getIndex() {

			return fIndex;

		}

		@Override

		public int getLength() {

			return fLength;

		}

        @Override

        public boolean equals(Object other) {

            return super.baseEquals(other) &&

                    ((IndexedPartitionDMC) other).getParentInfo().equals(getParentInfo()) &&

                    ((IndexedPartitionDMC) other).getIndex() == getIndex() &&

                    ((IndexedPartitionDMC) other).getLength() == getLength();                

        }

        @Override

        public int hashCode() {

            return super.baseHashCode() + 17*getIndex() + 31*getLength();

        }

        @Override

        public String toString() {

            return String.format( "%s[%d-%d]", baseToString(), Integer.valueOf( getIndex() ), Integer.valueOf( getIndex() + getLength() ) ); //$NON-NLS-1$

        }

        private static ExpressionInfo createExpressionInfo(ExpressionInfo parentInfo, int index, int length) {

        	String expression = String.format(

        			"*((%s)+%d)@%d",  //$NON-NLS-1$

        			parentInfo.getFullExpr(), 

        			Integer.valueOf(index), 

        			Integer.valueOf(length));

        	return new ExpressionInfo(expression, expression);

							return;

			}

	private IndexedPartitionDMC[] getTopLevelIndexedPartitions(

			MIExpressionDMC exprCtx, 

			int realNumChildren, 

			int startIndex, 

			int length) {

		int numChildren = computeNumberOfChildren(realNumChildren);

		if (startIndex >= numChildren)

			return new IndexedPartitionDMC[0];

		int startIndex1 = (startIndex < 0) ? 0 : startIndex;

		int length1 = (length < 0) ? numChildren - startIndex1 : Math.min(length, numChildren - startIndex1);

		IndexedPartitionDMC[] children = new IndexedPartitionDMC[numChildren];

		int index = 0;

		for(int i = 0; i < children.length; ++i) {

			int partLength = computePartitionLength(realNumChildren, i);

			children[i] = createIndexedPartition(

				exprCtx.getParents()[0], 

				exprCtx.getExpressionInfo(), 

				index, 

				partLength);

			index += partLength;

		}

		return Arrays.copyOfRange(children, startIndex1, startIndex1 + length1 );

	}

	private void getIndexedPartitionChildren(

			final IndexedPartitionDMC partDmc, 

			final int startIndex,

			final int length, 

			final DataRequestMonitor<IExpressionDMContext[]> rm) {

		final int startIndex1 = (startIndex < 0) ? 0 : startIndex;

		final int length1 = (length < 0) ? Integer.MAX_VALUE : length;

		final int partStartIndex = partDmc.getIndex();

		final int partLength = partDmc.getLength();

		if (partLength > getArrayPartitionLength()) {

			// create subpartitions

			int numChildren = computeNumberOfChildren(partLength);

			if (startIndex1 >= numChildren) {

				rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, "Invalid range for evaluating sub expressions.", null)); //$NON-NLS-1$

				rm.done();

				return;

			}

			int numPart = Math.min(numChildren, length1);

			IndexedPartitionDMC[] children = new IndexedPartitionDMC[numPart];

			int index = partStartIndex;

			for (int i = 0; i < startIndex1; ++i)

				index += computePartitionLength(partLength, i);

			for (int i = 0; i < children.length; ++i) {

				int childPartLength = computePartitionLength(partLength, i + startIndex1);

				children[i] = createIndexedPartition(

					partDmc, 

					partDmc.getParentInfo(), 

					index, 

					childPartLength);

				index += childPartLength;

			}

			rm.setData(children);

			rm.done();

		}

		else {

			// this is the last partition level, create "real" children

			if (startIndex1 > partLength) {

				rm.setData(new IExpressionDMContext[0]);

				rm.done();

			}

			else {

				getRealSubExpressions(

						createExpression(partDmc.getParents()[0], partDmc.getParentInfo()), 

						partStartIndex + startIndex1, 

						Math.min(length1, partLength - startIndex1), 

						rm);

			}

		}

	}

	void getRealSubExpressions(

			final IExpressionDMContext exprCtx, 

			int startIndex,

			int length, 

			final DataRequestMonitor<IExpressionDMContext[]> rm) {

		ExprMetaGetChildren getChildren = (startIndex < 0 || length < 0) ? 

				new ExprMetaGetChildren(exprCtx) : new ExprMetaGetChildren(exprCtx, startIndex + length);

		final int startIndex1 = (startIndex < 0) ? 0 : startIndex;

		final int length1 = (length < 0) ? Integer.MAX_VALUE : length;

		fExpressionCache.execute(

				getChildren,				

				new DataRequestMonitor<ExprMetaGetChildrenInfo>(getExecutor(), rm) {

					@Override

					protected void handleSuccess() {

						ExpressionInfo[] childrenExpr = getData().getChildrenExpressions();

						if (startIndex1 >= childrenExpr.length) {

							rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, "Invalid range for evaluating sub expressions.", null)); //$NON-NLS-1$

							rm.done();

							return;

						}

						int numChildren = childrenExpr.length - startIndex1;

						numChildren = Math.min(length1, numChildren);

						IExpressionDMContext[] childrenArray = new IExpressionDMContext[numChildren];

						for (int i=0; i < numChildren; i++) {

							childrenArray[i] = createExpression(exprCtx.getParents()[0], childrenExpr[startIndex1 + i]);

						}

						rm.setData(childrenArray);

						rm.done();

					}

				});

	}

	/**

	 * Returns the number of "real" children if it is less or equal to the partition size, 

	 * otherwise returns the number of partitions. 

	 */

	private int computeNumberOfChildren(int realNumberOfChildren) {

		int childNum = realNumberOfChildren;

		int partLength = getArrayPartitionLength();

		while (childNum > partLength) {

			childNum /= partLength;

		}

		if (childNum*partLength < realNumberOfChildren)

			++childNum;

		return childNum;

	}

	private int computePartitionLength(int realNumberOfChildren, int index) {

		int childNum = realNumberOfChildren;

		int depth = 0;

		int partLength = getArrayPartitionLength();

		int length = partLength;

		while (childNum > partLength) {

			childNum /= partLength;

			if (depth > 0)

				length *= partLength;

			++depth;

		}

		int diff = realNumberOfChildren - length*index;

		return ( diff > length ) ? length : diff ;

	}

	private IndexedPartitionDMC createIndexedPartition(IDMContext ctx, ExpressionInfo info, int index, int length) {

	    IFrameDMContext frameDmc = DMContexts.getAncestorOfType(ctx, IFrameDMContext.class);

	    if (frameDmc != null) {

	        return new IndexedPartitionDMC(getSession().getId(), info, frameDmc, index, length);

	    } 

	    IMIExecutionDMContext execCtx = DMContexts.getAncestorOfType(ctx, IMIExecutionDMContext.class);

	    if (execCtx != null) {

	    	// If we have a thread context but not a frame context, we give the user

	    	// the expression as per the top-most frame of the specified thread.

	    	// To do this, we create our own frame context.

	    	MIStack stackService = getServicesTracker().getService(MIStack.class);

	    	if (stackService != null) {

	    		frameDmc = stackService.createFrameDMContext(execCtx, 0);

	            return new IndexedPartitionDMC(getSession().getId(), info, frameDmc, index, length);

	    	}

        } 

        return new IndexedPartitionDMC(getSession().getId(), info, ctx, index, length);

	}

	private void getRealSubExpressionCount(IExpressionDMContext dmc, int numChildLimit, final DataRequestMonitor<Integer> rm) {

		if (dmc instanceof MIExpressionDMC) {

			fExpressionCache.execute(

					new ExprMetaGetChildCount(dmc, numChildLimit),				

					new DataRequestMonitor<ExprMetaGetChildCountInfo>(getExecutor(), rm) {

						@Override

						protected void handleSuccess() {

							rm.setData(getData().getChildNum());

							rm.done();

						}

					});

		} else if (dmc instanceof InvalidContextExpressionDMC) {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

			rm.done();

		} else {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

			rm.done();

		}

	}

	private int getArrayPartitionLength() {

		// Replace this in case we or the platform decide to add a user preference.

		// See org.eclipse.debug.internal.ui.model.elements.VariableContentProvider.

		return PARTITION_LENGTH;

	}

import org.eclipse.cdt.dsf.debug.service.IExpressions.IIndexedPartitionDMContext;

	        	if (exprDmc instanceof IIndexedPartitionDMContext) {

	        		castingIndex = ((IIndexedPartitionDMContext)exprDmc).getIndex();

	        	}

int testArrays() {

	int array_simple[10];

	int array_int[24321];

	foo array_foo[1200];

	return 1;

}

    testArrays();

import org.eclipse.cdt.dsf.debug.service.IExpressions.IIndexedPartitionDMContext;

	private IExpressionDMContext[] getChildren(IExpressionDMContext parentDmc, String[] expectedValues) throws Throwable {

    	return getChildren(parentDmc, -1, -1, expectedValues );

    }

    /**

     * This test verifies that large arrays are properly partitioned and 

     * the handling of "small" arrays is not affected.

     */

    @Test

    public void testArrays() throws Throwable {

    	MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testArrays");

        IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);

        // int array_simple[10];

	    IExpressionDMContext arraySimpleExprDMC = SyncUtil.createExpression(frameDmc, "array_simple");

	    getChildrenCount(arraySimpleExprDMC, 10);

	    // get all children

	    String[] expectedValues = new String[10];

	    for (int i = 0; i < expectedValues.length; ++i) {

	    	expectedValues[i] = String.format("array_simple[%d]", i);

	    }

	    IExpressionDMContext[] arraySimpleChildren = getChildren(arraySimpleExprDMC, expectedValues);

	    for (IExpressionDMContext ctx : arraySimpleChildren)

	    	getChildren(ctx, new String[0]);

	    // get some parts of the children array

	    getChildren(arraySimpleExprDMC, 3, 2, new String[] { "array_simple[3]", "array_simple[4]" });

	    getChildren(arraySimpleExprDMC, 9, 3, new String[] { "array_simple[9]" });

	    // int array_int[24321];

	    IExpressionDMContext arrayIntExprDMC = SyncUtil.createExpression(frameDmc, "array_int");

	    getChildrenCount(arrayIntExprDMC, 3);

	    // get top level partitions: [0-9999], [10000-19999], [20000-24321]

	    IExpressionDMContext[] arrayIntPartitions =

		    	getChildren(arrayIntExprDMC, new String[] {"*((array_int)+0)@10000", "*((array_int)+10000)@10000", "*((array_int)+20000)@4321"});

	    assertTrue(String.format("Invalid number of partition: expected 3 got %d", arrayIntPartitions.length), arrayIntPartitions.length == 3);

	    // get children of the last partition: [20000-24321] 

	    expectedValues = new String[44];

	    for(int i = 0; i < expectedValues.length - 1; ++i) {

	    	expectedValues[i] = String.format("*((array_int)+%d)@100", 20000 + i*100);

	    }

	    expectedValues[expectedValues.length - 1] = "*((array_int)+24300)@21";

	    IExpressionDMContext[] arrayIntPartitions1 = getChildren(arrayIntPartitions[2], expectedValues);

	    expectedValues = new String[21];

	    for(int i = 0; i < expectedValues.length; ++i) {

	    	expectedValues[i] = String.format("array_int[%d]", 24300 + i);

	    }

	    getChildren(arrayIntPartitions1[arrayIntPartitions1.length - 1], expectedValues);

	    // foo array_foo[1200];

	    IExpressionDMContext arrayFooExprDMC = SyncUtil.createExpression(frameDmc, "array_foo");	    

	    getChildrenCount(arrayFooExprDMC, 12);

	    expectedValues = new String[12];

	    for (int i = 0; i < expectedValues.length; ++i) {

	    	expectedValues[i] = String.format("*((array_foo)+%d)@%d", i*100, 100);

	    }

	    IExpressionDMContext[] arrayFooPartitions =	getChildren(arrayFooExprDMC, expectedValues);

	    for (int i = 0; i < arrayFooPartitions.length; ++i) {

	    	IExpressionDMContext ctx = arrayFooPartitions[i];

	    	assertTrue(String.format("Invalid DM context type: expected '%s' got '%s'", 

	    			IIndexedPartitionDMContext.class.getName(), ctx.getClass().getName()), 

	    			ctx instanceof IIndexedPartitionDMContext);

		    expectedValues = new String[100];

		    for (int j = 0; j < expectedValues.length; ++j) {

		    	expectedValues[j] = String.format("array_foo[%d]", i*100 + j);

		    }

		    IExpressionDMContext[] arrayFooChildren = getChildren(ctx, expectedValues);

		    for (IExpressionDMContext fooCtx : arrayFooChildren) {

		    	getChildren(fooCtx, new String[] {"bar", "bar2", "a", "b", "c"});

		    }

		    // get parts of the children array

		    expectedValues = new String[] { String.format("array_foo[%d]", i*100 + 3), String.format("array_foo[%d]", i*100 + 4) };

		    getChildren(ctx, 3, 2, expectedValues);

		    getChildren(ctx, 99, 3, new String[] { String.format("array_foo[%d]", i*100 + 99) });

	    }

    }

    private int getChildrenCount(final IExpressionDMContext parentDmc, final int expectedCount) throws Throwable {

        final AsyncCompletionWaitor wait = new AsyncCompletionWaitor();

        fExpService.getExecutor().submit(new Runnable() {

            @Override

			public void run() {

                fExpService.getSubExpressionCount(

                	parentDmc,

                    new DataRequestMonitor<Integer>(fExpService.getExecutor(), null) {

                        @Override

                        protected void handleCompleted() {

                            if (isSuccess()) {

                            	wait.setReturnInfo(getData());

                            	if (getData() != expectedCount) {

	        						wait.waitFinished(

	        							new Status(

		        							IStatus.ERROR, 

		        							TestsPlugin.PLUGIN_ID,

		        							String.format(

		        									"Failed getting count for children.  Got %d instead of %d.", 

		        									getData(), 

		        									expectedCount)));

                            	}

                            	else {

                            		wait.waitFinished(getStatus());

                            	}

                            }

                            else {

                        		wait.waitFinished(getStatus());

                            }

                        }

                    });

            }

        });

        wait.waitUntilDone(AsyncCompletionWaitor.WAIT_FOREVER);

        assertTrue(wait.getMessage(), wait.isOK());

        int count = ((Integer)wait.getReturnInfo()).intValue();

		assertTrue(String.format("Expected %d but got %d", expectedCount, count), count == expectedCount);

        return count;

    }

import org.eclipse.cdt.dsf.debug.service.IExpressions.IIndexedPartitionDMContext;

			if (exprDMC instanceof IIndexedPartitionDMContext)

				return false;

import org.eclipse.cdt.dsf.debug.service.IExpressions.IIndexedPartitionDMContext;

    /**

     * 'PROP_VARIABLE_BASIC_TYPE' property value for indexed partitions

     */

    private static final String INDEXED_PARTITION_TYPE = "indexed_partition_type"; //$NON-NLS-1$

    public final static  LabelImage PARTITION_LABEL_IMAGE = new LabelImage(CDebugImages.DESC_OBJS_ARRAY_PARTITION) {

        { setPropertyNames(new String[] { PROP_VARIABLE_BASIC_TYPE }); }

        @Override

        public boolean isEnabled(IStatus status, java.util.Map<String,Object> properties) {

            String type = (String)properties.get(PROP_VARIABLE_BASIC_TYPE);

            return INDEXED_PARTITION_TYPE.equals(type);

        };

    };

                PARTITION_LABEL_IMAGE,

                PARTITION_LABEL_IMAGE,

                                    if (dmc instanceof IIndexedPartitionDMContext)

                                    	update.setProperty(PROP_VARIABLE_BASIC_TYPE, INDEXED_PARTITION_TYPE);

    /**

     * Returns the label for the element with the given context.

     */

    protected String getExpressionDisplayName(IExpressionDMContext dmc, String name) {

    	if (dmc instanceof IIndexedPartitionDMContext) {

    		IIndexedPartitionDMContext ipDmc = (IIndexedPartitionDMContext)dmc;

    		name = String.format(

    				"[%d...%d]",  //$NON-NLS-1$

    				ipDmc.getIndex(), 

    				ipDmc.getIndex() + ipDmc.getLength() - 1);

    	}

    	return name;

    }

     * To avoid SWT performance issues large arrays are divided into partitions. 

     * This interface represents the context of such a partition.

     * 

     * @since 2.3

     */

    public interface IIndexedPartitionDMContext extends IExpressionDMContext {

		/**

		 * Returns the expression string of the parent array.

		 */

		public String getParentExpression();

		/**

		 * Returns the index of the partition's first element in the parent array. 

		 */

		public int getIndex();

		/**

		 * Returns the number of array's elements in the partition.

		 */

		public int getLength();

	}

    /**