public ObjectValue[] GetChildren (ObjectPath path, int index, int count, EvaluationOptions options)
		{
			EvaluationContext cctx = ctx.WithOptions (options);
			var names = new ObjectValueNameTracker (cctx);
			object tdataType = null;
			TypeDisplayData tdata = null;
			List<ObjectValue> list = new List<ObjectValue> ();
			foreach (ValueReference val in cctx.Adapter.GetMembersSorted (cctx, objectSource, type, obj, bindingFlags)) {
				object decType = val.DeclaringType;
				if (decType != null && decType != tdataType) {
					tdataType = decType;
					tdata = cctx.Adapter.GetTypeDisplayData (cctx, decType);
				}
				DebuggerBrowsableState state = tdata.GetMemberBrowsableState (val.Name);
				if (state == DebuggerBrowsableState.Never)
					continue;
				ObjectValue oval = val.CreateObjectValue (options);
				names.FixName (val, oval);
				list.Add (oval);
			}
			if ((bindingFlags & BindingFlags.NonPublic) == 0) {
				BindingFlags newFlags = bindingFlags | BindingFlags.NonPublic;
				newFlags &= ~BindingFlags.Public;
				list.Add (CreateNonPublicsNode (cctx, objectSource, type, obj, newFlags));
			}
			return list.ToArray ();
		}

		public ObjectValue[] GetLocalVariables(int frameIndex, EvaluationOptions options)
		{
			List<ObjectValue> values = new List<ObjectValue>();
			if (Engine.Symbols.ScopeLocalSymbols == null)
				return values.ToArray();

			for (uint i = 0; i < Engine.Symbols.ScopeLocalSymbols.Count; i++)
			{
				if (Engine.Symbols.ScopeLocalSymbols.Symbols[i].Parent != null)
					continue;

				string name = Engine.Symbols.ScopeLocalSymbols.Symbols[i].Name;
				string typename = Engine.Symbols.ScopeLocalSymbols.Symbols[i].TypeName;
				string val = Engine.Symbols.ScopeLocalSymbols.Symbols[i].TextValue;
				ulong offset = Engine.Symbols.ScopeLocalSymbols.Symbols[i].Offset;
				DEW.DebugScopedSymbol parentSymbol = Engine.Symbols.ScopeLocalSymbols.Symbols[i].Parent;

				ObjectValue ov = symbolResolver.Resolve(offset, name, typename, val, parentSymbol);
				if (ov == null)
				{
					ObjectValueFlags flags = ObjectValueFlags.Variable;
					ov = ObjectValue.CreatePrimitive(this, new ObjectPath(name), typename, new EvaluationResult(val), flags);
				}

				if (ov != null)
					values.Add(ov);
			}
			return values.ToArray();
		}

		public object CallMethod (string name, object[] parameters, out object[] outArgs, EvaluationOptions options)
		{
			object[] tempOutArgs = null;
			var result = MtaThread.Run (() => source.CallMethod (name, parameters, out tempOutArgs, options));
			outArgs = tempOutArgs;
			return result;
		}

 public ObjectValue[] GetAllLocals(int frameIndex, EvaluationOptions options)
 {
     List<ObjectValue> locals = new List<ObjectValue> ();
     locals.AddRange (GetParameters (frameIndex, options));
     locals.AddRange (GetLocalVariables (frameIndex, options));
     return locals.ToArray ();
 }

		public ObjectValue[] GetParameters(int frameIndex, EvaluationOptions options)
		{
			List<ObjectValue> values = new List<ObjectValue>();

			SelectFrame(frameIndex);

			return values.ToArray();
		}

        public override ExceptionInfo GetException(int frameIndex, EvaluationOptions options)
        {

            ObjectValue val = CreateExceptionObject(exceptionRecord);
            ExceptionInfo result = new ExceptionInfo(val);

            return result;
        }

		public void SetMemberValue (string name, object value, EvaluationOptions options)
		{
			EvaluationContext localContext = ctx.WithOptions (options);
			object type = localContext.Adapter.GetValueType (localContext, targetObject);
			ValueReference val = localContext.Adapter.GetMember (localContext, source, type, targetObject, name);
			if (val == null)
				throw new EvaluatorException ("Member '{0}' not found", name);
			val.Value = localContext.Adapter.FromRawValue (localContext, value);
		}

		public ObjectValue[] GetExpressionValues(int frameIndex, string[] expressions, EvaluationOptions options)
		{
			List<ObjectValue> values = new List<ObjectValue>();

			SelectFrame(frameIndex);
			foreach (string exp in expressions)
				values.Add(CreateVarObject(exp));
			return values.ToArray();
		}

		public EvaluationContext WithOptions (EvaluationOptions options)
		{
			if (options == null || Options == options)
				return this;

			EvaluationContext clone = Clone ();
			clone.Options = options;
			return clone;
		}

		public ObjectValue[] GetLocalVariables (int frameIndex, EvaluationOptions options)
		{
			List<ObjectValue> values = new List<ObjectValue> ();
			SelectFrame (frameIndex);
			
			GdbCommandResult res = session.RunCommand ("-stack-list-locals", "0");
			foreach (ResultData data in res.GetObject ("locals"))
				values.Add (CreateVarObject (data.GetValue ("name")));
			
			return values.ToArray ();
		}

		public ObjectValue CreateObjectValue (bool withTimeout, EvaluationOptions options)
		{
			if (!CanEvaluate (options))
				return DC.ObjectValue.CreateImplicitNotSupported (this, new ObjectPath (Name), ctx.Adapter.GetTypeName (GetContext (options), Type), Flags);
			if (withTimeout) {
				return ctx.Adapter.CreateObjectValueAsync (Name, Flags, delegate {
					return CreateObjectValue (options);
				});
			} else
				return CreateObjectValue (options);
		}

        public object GetMemberValue(string name, EvaluationOptions options)
        {
            var localContext = ctx.WithOptions (options);
            var type = localContext.Adapter.GetValueType (localContext, targetObject);
            var val = localContext.Adapter.GetMember (localContext, source, type, targetObject, name);

            if (val == null)
                throw new EvaluatorException ("Member '{0}' not found", name);

            return localContext.Adapter.ToRawValue (localContext, val, val.Value);
        }

		public override ValueReference GetChild (string name, EvaluationOptions options)
		{
			string newNs = namspace + "." + name;

			var ctx = GetContext (options);
			var type = ctx.Adapter.GetType (ctx, newNs);

			if (type != null)
				return new TypeValueReference (ctx, type);
			
			return new NamespaceValueReference (ctx, newNs);
		}

		public object CallMethod (string name, object[] parameters, EvaluationOptions options)
		{
			EvaluationContext localContext = ctx.WithOptions (options);
			
			object[] argValues = new object [parameters.Length];
			object[] argTypes = new object [parameters.Length];
			for (int n=0; n<argValues.Length; n++) {
				argValues[n] = localContext.Adapter.FromRawValue (localContext, parameters[n]);
				argTypes[n] = localContext.Adapter.GetValueType (localContext, argValues[n]);
			}
			object type = localContext.Adapter.GetValueType (localContext, targetObject);
			object res = localContext.Adapter.RuntimeInvoke (localContext, type, targetObject, name, argTypes, argValues);
			return localContext.Adapter.ToRawValue (localContext, null, res);
		}

        public ObjectValue[] GetAllLocals(int frameIndex, EvaluationOptions options)
        {
            session.RunCommand (true, "vars");
            List<ObjectValue> locals = new List<ObjectValue> ();
            lock (syncLock) {
                foreach (string varName in session.lastResult.vars) {
                    ObjectValue val;
                    ObjectValueFlags flags = ObjectValueFlags.Variable;
                    val = ObjectValue.CreatePrimitive (this, new ObjectPath (varName), "dummyInt", new EvaluationResult ("test_val"), flags);
                    val.Name = varName;
                    locals.Add (val);
                }
            }

            return locals.ToArray ();
        }

        public ObjectValue[] GetChildren(ObjectPath path, int index, int count, EvaluationOptions options)
        {
            List<ObjectValue> children = new List<ObjectValue>();
            session.SelectThread(threadId);

            if (Engine.Symbols.ScopeLocalSymbols == null)
                return children.ToArray();

            DEW.DebugScopedSymbol parent = null;

            for (uint i = 0; i < Engine.Symbols.ScopeLocalSymbols.Symbols.Length; i++)
            {
                DEW.DebugScopedSymbol symbol = Engine.Symbols.ScopeLocalSymbols.Symbols[i];
                if (symbol.Name == path.LastName)
                {
                    parent = symbol;
                    break;
                }
            }

            if (parent == null || parent.ChildrenCount == 0)
                return children.ToArray();

            for (uint i = 0; i < parent.ChildrenCount; i++)
            {

                DEW.DebugScopedSymbol child = parent.Children[i];

                string name = child.Name;
                string typename = child.TypeName;
                string val = child.TextValue;
                ulong offset = child.Offset;

                ObjectValue ov = symbolResolver.Resolve(offset, name, typename, val, child.Parent);
                if (ov == null)
                {
                    ObjectValueFlags flags = ObjectValueFlags.Variable;
                    ov = ObjectValue.CreatePrimitive(this, new ObjectPath(name), typename, new EvaluationResult(val), flags);
                }

                if (ov != null)
                    children.Add(ov);
            }

            return children.ToArray();
        }

		public virtual ObjectValue[] GetParameters (int frameIndex, EvaluationOptions options)
		{
			List<ObjectValue> vars = new List<ObjectValue> ();
			
			FrameInfo frame = GetFrameInfo (frameIndex, options, false);
			if (frame == null) {
				ObjectValue val = Adaptor.CreateObjectValueAsync ("Parameters", ObjectValueFlags.EvaluatingGroup, delegate {
					frame = GetFrameInfo (frameIndex, options, true);
					foreach (ValueReference var in frame.Parameters)
						vars.Add (var.CreateObjectValue (false, options));
					return ObjectValue.CreateArray (null, new ObjectPath ("Parameters"), "", vars.Count, ObjectValueFlags.EvaluatingGroup, vars.ToArray ());
				});
				return new ObjectValue [] { val };
			}
			
			foreach (ValueReference var in frame.Parameters)
				vars.Add (var.CreateObjectValue (true, options));
			return vars.ToArray ();
		}

		public virtual ObjectValue[] GetLocalVariables (int frameIndex, EvaluationOptions options)
		{
			FrameInfo frame = GetFrameInfo (frameIndex, options, false);
			List<ObjectValue> list = new List<ObjectValue> ();
			
			if (frame == null) {
				ObjectValue val = Adaptor.CreateObjectValueAsync ("Local Variables", ObjectValueFlags.EvaluatingGroup, delegate {
					frame = GetFrameInfo (frameIndex, options, true);
					foreach (ValueReference var in frame.LocalVariables)
						list.Add (var.CreateObjectValue (false, options));
					return ObjectValue.CreateArray (null, new ObjectPath ("Local Variables"), "", list.Count, ObjectValueFlags.EvaluatingGroup, list.ToArray ());
				});
				return new ObjectValue [] { val };
			}
			
			foreach (ValueReference var in frame.LocalVariables)
				list.Add (var.CreateObjectValue (true, options));
			return list.ToArray ();
		}

		public ObjectValue[] GetChildren (ObjectPath path, int index, int count, EvaluationOptions options)
		{
			var node = cacheRoot [path];

			if(node == null)
				return Backtrace.GetChildren(path, index, count, options);

			ObjectValue[] children;
			var t = node.NodeType;

			if (t is ArrayType)
				children = GetArrayChildren (node, path, index, count, options);
			else if (t is ClassType || t is StructType)
				children = GetClassInstanceChildren (node, path, options);
			else
				children = new ObjectValue[0];

			return children;
		}

        public virtual ObjectValue[] GetAllLocals(int frameIndex, EvaluationOptions options)
        {
            var locals = new List<ObjectValue> ();

            var excObj = GetExceptionInstance (frameIndex, options);
            if (excObj != null)
                locals.Insert (0, excObj);

            locals.AddRange (GetLocalVariables (frameIndex, options));
            locals.AddRange (GetParameters (frameIndex, options));

            locals.Sort ((v1, v2) => StringComparer.InvariantCulture.Compare (v1.Name, v2.Name));

            var thisObj = GetThisReference (frameIndex, options);
            if (thisObj != null)
                locals.Insert (0, thisObj);

            return locals.ToArray ();
        }