public VariableReference (EvaluationContext ctx, TargetVariable var, DC.ObjectValueFlags flags): base (ctx)
{
this.flags = flags;
this.var = var;
if (!var.CanWrite)
flags |= DC.ObjectValueFlags.ReadOnly;
}
public static AbstractVariable Create(TargetVariable variable, StackFrame stackFrame)
{
TargetObject obj;
try {
obj = variable.GetObject(stackFrame);
} catch {
return new ErrorVariable(variable.Name, "Can not get object");
}
return Create(variable.Name, obj, stackFrame);
}
public void FormatVariable(StackFrame frame, TargetVariable variable)
{
TargetObject obj = null;
Append ("{0} = ", variable.Name);
if (!variable.IsAlive (frame.TargetAddress)) {
Append ("<optimized out>");
return;
}
try {
obj = variable.GetObject (frame);
if (obj != null)
Format (frame.Thread, obj);
else
Append ("<cannot display object>");
} catch {
Append ("<cannot display object>");
}
}
public VariableAccessExpression(TargetVariable var)
{
this.var = var;
resolved = true;
}
protected override Expression DoResolve(ScriptingContext context)
{
frame = context.CurrentFrame;
Method method = frame.Method;
if (method == null)
throw new ScriptingException (
"Keyword `this' not allowed: no current method.");
if (!method.HasThis)
throw new ScriptingException (
"Keyword `this' not allowed: current method is " +
"either static or unmanaged.");
var = method.GetThis (context.CurrentThread);
resolved = true;
return this;
}
public override string PrintVariable(TargetVariable variable, StackFrame frame)
{
ObjectFormatter formatter = new ObjectFormatter (DisplayFormat.Default);
formatter.FormatVariable (frame, variable);
return formatter.ToString ();
}
public abstract string PrintVariable(TargetVariable variable, StackFrame frame);
void do_read_variables(TargetMemoryAccess memory)
{
if (!is_loaded)
throw new TargetException (TargetError.MethodNotLoaded);
if (has_variables)
return;
MonoLanguageBackend mono = file.MonoLanguage;
TargetAddress decl_klass = mono.MetadataHelper.MonoMethodGetClass (
memory, address.MonoMethod);
TargetType decl = mono.ReadMonoClass (memory, decl_klass);
if (decl.HasClassType)
decl_type = decl.ClassType;
else
decl_type = (TargetClassType) decl;
do_read_blocks ();
locals = new List<TargetVariable> ();
parameters = new List<TargetVariable> ();
scopes = new Dictionary<int,ScopeInfo> ();
var captured_vars = new Dictionary<string,CapturedVariable> ();
if (address.HasThis)
this_var = new MonoVariable (
"this", decl_type, true, true, this,
address.ThisVariableInfo);
var scope_list = new List<ScopeInfo> ();
C.ScopeVariable[] scope_vars = method.GetScopeVariables ();
int num_scope_vars = scope_vars != null ? scope_vars.Length : 0;
for (int i = 0; i < num_scope_vars; i++) {
C.ScopeVariable sv = scope_vars [i];
VariableInfo var;
if (sv.Index < 0) {
var = address.ThisVariableInfo;
this_is_captured = true;
this_var = null;
} else
var = address.LocalVariableInfo [sv.Index];
try {
TargetClassType type = mono.ReadStructType (memory, var.MonoType);
MonoVariable scope_var = new MonoVariable (
"$__" + sv.Scope, type, true, type.IsByRef, this, var);
ScopeInfo info = new ScopeInfo (sv.Scope, scope_var, type);
scopes.Add (sv.Scope, info);
scope_list.Add (info);
} catch (Exception ex) {
Report.Error ("Cannot read scope variable: {0}\n{1}", var, ex);
}
}
foreach (ScopeInfo scope in scope_list) {
read_scope (scope);
}
foreach (ScopeInfo scope in scopes.Values) {
C.AnonymousScopeEntry entry = file.File.GetAnonymousScope (scope.ID);
foreach (C.CapturedVariable captured in entry.CapturedVariables) {
CapturedVariable cv = new CapturedVariable (
scope, this, captured.Name, captured.CapturedName);
switch (captured.Kind) {
case C.CapturedVariable.CapturedKind.Local:
locals.Add (cv);
break;
case C.CapturedVariable.CapturedKind.Parameter:
parameters.Add (cv);
break;
case C.CapturedVariable.CapturedKind.This:
if (!cv.Resolve (memory))
throw new InternalError ();
if (cv.Type.HasClassType)
decl_type = cv.Type.ClassType;
else
decl_type = (TargetClassType) cv.Type;
this_var = cv;
continue;
default:
throw new InternalError ();
}
captured_vars.Add (captured.Name, cv);
}
}
var param_info = mdef.Parameters;
for (int i = 0; i < param_info.Count; i++) {
if (captured_vars.ContainsKey (param_info [i].Name))
continue;
VariableInfo var = address.ParamVariableInfo [i];
TargetType type = mono.ReadType (memory, var.MonoType);
if (type == null)
type = mono.VoidType;
parameters.Add (new MonoVariable (
param_info [i].Name, type, false, type.IsByRef,
this, var, 0, 0));
}
C.LocalVariableEntry[] symfile_locals = method.GetLocals ();
for (int i = 0; i < symfile_locals.Length; i++) {
C.LocalVariableEntry local = symfile_locals [i];
if (captured_vars.ContainsKey (local.Name))
continue;
VariableInfo var = address.LocalVariableInfo [local.Index];
TargetType type = mono.ReadType (memory, var.MonoType);
if (type == null)
type = mono.VoidType;
if (local.BlockIndex > 0) {
int index = local.BlockIndex - 1;
MonoCodeBlock block = code_blocks [index];
locals.Add (new MonoVariable (
local.Name, type, true, type.IsByRef, this, var,
block.StartAddress, block.EndAddress));
} else {
locals.Add (new MonoVariable (
local.Name, type, true, type.IsByRef, this, var));
}
}
has_variables = true;
}
TargetVariable[] resolve_variables(ArrayList variables)
{
if (variables == null)
return new TargetVariable [0];
ArrayList list = new ArrayList ();
foreach (DieMethodVariable variable in variables) {
TargetVariable resolved = variable.Variable;
if (resolved != null)
list.Add (resolved);
}
TargetVariable[] retval = new TargetVariable [list.Count];
list.CopyTo (retval, 0);
return retval;
}
void DoResolve()
{
if (abstract_origin != 0) {
DieSubprogram aorigin = comp_unit.GetSubprogram (abstract_origin);
if (aorigin == null)
throw new InternalError ();
DoResolveSpecification (aorigin);
}
if (specification != 0) {
DieSubprogram ssubprog = comp_unit.GetSubprogram (specification);
if (ssubprog == null)
throw new InternalError ();
DoResolveSpecification (ssubprog);
}
locals = resolve_variables (local_dies);
parameters = resolve_variables (param_dies);
if (param_dies != null) {
DieMethodVariable first_var = (DieMethodVariable) param_dies [0];
if ((first_var.IsArtificial != null) && (first_var.Name == "this"))
this_var = first_var.Variable;
}
debug ("{0} resolve: {1} {2} {3} {4}", Offset, param_dies != null, local_dies != null,
name != null, this_var != null);
if ((param_dies != null) && (name != null)) {
StringBuilder sb = new StringBuilder ();
if (this_var != null) {
sb.Append (this_var.Type.Name);
sb.Append ("::");
}
sb.Append (name);
sb.Append ("(");
bool first = true;
for (int i = 0; i < param_dies.Count; i++) {
DieMethodVariable the_param = (DieMethodVariable) param_dies [i];
if (!first)
sb.Append (", ");
if (the_param.Type == null)
continue;
sb.Append (the_param.Type.Name);
if (the_param.Name != null) {
sb.Append (" ");
sb.Append (the_param.Name);
}
first = false;
}
sb.Append (")");
full_name = sb.ToString ();
}
}
