public static CatchBlock Catch(SourceSpan span, SourceLocation header, Type type, Variable target, Statement body)
{
Contract.RequiresNotNull(type, "type");
Contract.Requires(target == null || TypeUtils.CanAssign(target.Type, type), "target");
Contract.RequiresNotNull(body, "body");
return new CatchBlock(span, header, type, target, body);
}
static Expression MakeCallBack(Variable proc, Expression[] a)
{
var procr = Ast.ConvertHelper(Ast.Read(proc), typeof(Callable));
MethodInfo call = GetCallable(a.Length);
var expr = Ast.Call(procr, call, a);
return expr;
}
/// <summary>
/// Performs an assignment variable = value
/// </summary>
public static BoundAssignment Assign(Variable variable, Expression value)
{
Contract.RequiresNotNull(variable, "variable");
Contract.RequiresNotNull(value, "value");
Contract.Requires(TypeUtils.CanAssign(variable.Type, value.Type));
return new BoundAssignment(variable, value);
}
internal WriteStatement(Variable var, Expression value) : base(AstNodeType.WriteStatement, SourceSpan.None)
{
_value = value;
_variable = var;
if (!value.IsConstant(null))
{
_variable.AssumedValue = _variable.AssumedValue == null ? GetReference(value) : null;
}
}
private bool _yield; // The catch block contains a yield
#endregion Fields
#region Constructors
internal CatchBlock(SourceSpan span, SourceLocation header, Type /*!*/ test, Variable target, Statement /*!*/ body)
: base(AstNodeType.CatchBlock)
{
_test = test;
_var = target;
_body = body;
_start = span.Start;
_header = header;
_end = span.End;
}
private VariableReference GetOrMakeRef(Variable variable) {
Debug.Assert(variable != null);
if (_refs == null) {
_refs = new Dictionary<Variable, VariableReference>();
}
VariableReference reference;
if (!_refs.TryGetValue(variable, out reference)) {
_refs[variable] = reference = new VariableReference(variable);
}
return reference;
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
#if FULL
if (_tmp == null) {
_tmp = context.GetTemporary(Type, "outParam");
}
#endif
return Ast.Comma(Ast.Assign(_tmp, base.ToExpression(context, parameters)), Ast.Read(_tmp));
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
#if FULL
if (_isRef) {
if (_tmp == null) {
_tmp = context.GetTemporary(_parameterType, "outParam");
}
return Ast.Read(_tmp);
}
#endif
return GetDefaultValue();
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
#if FULL
if (_tmp == null) {
_tmp = context.GetTemporary(_elementType, "outParam");
}
#endif
// Ideally we'd pass in Ast.ReadField(parameters[Index], "Value") but due to
// a bug in partial trust we can't access the generic field.
// arg is boxType ? &_tmp : throw new ArgumentTypeException()
// IncorrectBoxType throws the exception to avoid stack imbalance issues.
return Ast.Condition(
Ast.TypeIs(parameters[Index], BoxType),
Ast.Comma(
Ast.Assign(
_tmp,
Ast.Call(
typeof(BinderOps).GetMethod("GetBox").MakeGenericMethod(_elementType),
Ast.ConvertHelper(parameters[Index], typeof(StrongBox<>).MakeGenericType(_elementType))
)
),
Ast.Read(_tmp)
),
// Condition requires types of both expressions to be identical.
// Putting the cast here is a temporary workaround until the
// emit address and reference argument passing is finished.
Ast.Convert(
Ast.Call(
typeof(BinderOps).GetMethod("IncorrectBoxType"),
Ast.Constant(BoxType),
Ast.ConvertHelper(parameters[Index], typeof(object))
),
_elementType
)
);
}
internal DeleteStatement(SourceSpan span, Variable /*!*/ var)
: base(AstNodeType.DeleteStatement, span) {
_var = var;
}
private bool TryGetIndex(Variable variable, out int index)
{
if (variable != null) {
if (_indices.TryGetValue(variable, out index)) {
index *= 2;
return true;
}
}
index = -1;
return false;
}
private bool TryCheckVariable(Variable variable, out bool defined)
{
int index;
if (TryGetIndex(variable, out index)) {
Debug.Assert(index < _bits.Count);
//defined = _bits.Get(index);
//if (!defined) {
// variable.UninitializedUse();
//}
//if (!_bits.Get(index + 1)) {
// // Found an unbound use of the name => need to initialize to Uninitialized.instance
// variable.UnassignedUse();
//}
defined = true;
return true;
} else {
// TODO: Report unbound name - error
defined = false;
return false;
}
}
/// <summary>
/// Performs an assignment variable = value
/// </summary>
public static Statement Write(Variable variable, Variable value)
{
//return Statement(Assign(variable, Ast.Read(value)));
return new WriteStatement(variable, Ast.Read(value));
}
/// <summary>
/// Create a context for keeping track of allocated temporary variables inside of TemporaryStorage.
/// When this function is called, the variables given by paramVars will be set to the values given by paramValues;
/// when the returned object is disposed of, the supplied paramVars and tempVars variables will be removed from temporary storage.
/// </summary>
internal CodeContext GetTemporaryVariableContext(CodeContext context, Variable[] paramVars, object[] paramValues) {
Debug.Assert(paramVars.Length == paramValues.Length);
Scope scope = CloneForTemporaries();
context = new CodeContext(scope, context.LanguageContext, context.ModuleContext);
for (int i = 0; i < paramValues.Length; i++) {
scope.TemporaryStorage[paramVars[i]] = paramValues[i];
}
return context;
}
public AbstractValue Lookup(Variable variable) {
Variable newVar = _variableMap[variable];
return AbstractValue.LimitType(newVar.Type, Ast.ReadDefined(newVar));
}
internal VariableReference Reference(Variable variable)
{
if (_references == null) {
_references = new Dictionary<Variable, VariableReference>();
}
if (variable.Block == null)
{
return null;
}
VariableReference reference;
if (!_references.TryGetValue(variable, out reference)) {
_references[variable] = reference = new VariableReference(variable);
}
return reference;
}
public static CatchBlock Catch(Type type, Variable target, Statement body)
{
return Catch(SourceSpan.None, SourceLocation.None, type, target, body);
}
/// <summary>
/// Performs an assignment variable.leftField = right.rightField
/// </summary>
public static Statement Write(Variable variable, FieldInfo leftField, Variable right, FieldInfo rightField)
{
return Statement(AssignField(Read(variable), leftField, ReadField(Read(right), rightField)));
}
/// <summary>
/// Performs an assignment variable = right.field
/// </summary>
public static Statement Write(Variable variable, Variable right, FieldInfo field)
{
return Statement(Assign(variable, ReadField(Read(right), field)));
}
/// <summary>
/// Performs an assignment variable.field = value
/// </summary>
public static Statement Write(Variable variable, FieldInfo field, Variable value)
{
return Statement(AssignField(Read(variable), field, Read(value)));
}
/// <summary>
/// Performs an assignment variable = value
/// </summary>
public static Statement Write(Variable variable, Expression value)
{
//return Statement(Assign(variable, value));
return new WriteStatement(variable, value);
}
public static DeleteStatement Delete(SourceSpan span, Variable variable) {
Contract.RequiresNotNull(variable, "variable");
return new DeleteStatement(span, variable);
}
private VariableReference Reference(Variable variable)
{
Debug.Assert(variable != null);
return _stack.Peek().Reference(variable);
}
internal static object EvaluateAssign(CodeContext context, Variable var, object value) {
switch (var.Kind) {
case Variable.VariableKind.Temporary:
case Variable.VariableKind.GeneratorTemporary:
context.Scope.TemporaryStorage[var] = value;
break;
case Variable.VariableKind.Global:
RuntimeHelpers.SetGlobalName(context, var.Name, value);
break;
default:
RuntimeHelpers.SetName(context, var.Name, value);
break;
}
return value;
}
static bool CanAlias(Variable here, Variable there)
{
var sameblock = here.Block == there.Block;
var assigned = Generator.assigns.ContainsKey(there.Name);
return here.Type == there.Type && sameblock && !assigned && !there.Lift;
}
public VariableReference(Variable variable)
{
Debug.Assert(variable != null);
_variable = variable;
}
static Expression MakePointerCall(Variable ptr, Type returntype, List<Type> paramtypes, Expression[] a)
{
Type sig = MakeDelegateType(returntype, paramtypes);
var gm = FFIDelegate.MakeGenericMethod(sig);
var expr = Ast.Call(gm, MakeConvertTo(Ast.Read(ptr), typeof(IntPtr)));
return Ast.Call(expr, sig.GetMethod("Invoke"), a);
}
public void Define(Variable variable)
{
int index;
if (TryGetIndex(variable, out index)) {
_bits.Set(index, true); // is assigned
_bits.Set(index + 1, true); // cannot be unassigned
}
}
public void Delete(Variable variable)
{
int index;
if (TryGetIndex(variable, out index)) {
_bits.Set(index, false); // is not initialized
_bits.Set(index + 1, true); // is assigned (to Uninitialized.instance)
}
}
internal BoundAssignment(Variable /*!*/ variable, Expression /*!*/ value)
: base(AstNodeType.BoundAssignment)
{
_variable = variable;
_value = value;
if (value.IsConstant(null))
{
#warning See if this is problematic, gets invoked by pfds tests
//Debugger.Break();
}
_variable.AssumedValue = _variable.AssumedValue == null ? GetReference(value) : null;
}
