//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilLocal <T> Local <T>(IHappilOperand <T> initialValue)
{
var local = new HappilLocal <T>(this);
local.Assign(initialValue);
return(local);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilOperand <TElement[]> NewArray <TElement>(IHappilOperand <int> length)
{
return(new HappilUnaryExpression <int, TElement[]>(
ownerMethod: null,
@operator: new UnaryOperators.OperatorNewArray <TElement>(),
operand: length));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <TReturn> Func <TArg1, TArg2, TReturn>(
Expression <Func <T, Func <TArg1, TArg2, TReturn> > > member, IHappilOperand <TArg1> arg1, IHappilOperand <TArg2> arg2)
{
var method = ValidateMemberIsMethodOfType(Helpers.ResolveMethodFromLambda(member));
var @operator = new UnaryOperators.OperatorCall <T>(method, arg1, arg2);
return(new HappilUnaryExpression <T, TReturn>(m_OwnerMethod, @operator, this));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <T> OrDefault(IHappilOperand <T> defaultValue)
{
return(new HappilBinaryExpression <T, T>(
OwnerMethod,
@operator: new BinaryOperators.OperatorNullCoalesce <T>(),
left: this,
right: defaultValue));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <TReturn> Func <TArg1, TArg2, TReturn>(
Func <MethodInfo, bool> methodSelector,
IHappilOperand <TArg1> arg1,
IHappilOperand <TArg2> arg2)
{
var method = this.Members.SelectFuncs <TArg1, TArg2, TReturn>(methodSelector).Single();
return(new HappilUnaryExpression <T, TReturn>(m_OwnerMethod, new UnaryOperators.OperatorCall <T>(method, arg1, arg2), this));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void RaiseEvent(IHappilMethodBodyBase m, IHappilOperand args)
{
using (CreateTypeTemplateScope())
{
m.If(m_BackingField.AsOperand <TypeTemplate.TEventHandler>() != m.Const <TypeTemplate.TEventHandler>(null)).Then(() => {
m_BackingField.AsOperand <TypeTemplate.TEventHandler>().Invoke(m.This <TypeTemplate.TBase>(), args);
});
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilForeachDoSyntax <T> ForeachElementIn <T>(IHappilOperand <IEnumerable <T> > collection)
{
var element = this.Local <T>();
var statement = new ForeachStatement <T>(element);
AddStatement(statement);
statement.In(collection);
return(statement);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void Void <TArg1, TArg2, TArg3>(
Func <MethodInfo, bool> methodSelector,
IHappilOperand <TArg1> arg1,
IHappilOperand <TArg2> arg2,
IHappilOperand <TArg3> arg3)
{
var method = this.Members.SelectVoids <TArg1, TArg2>(methodSelector).Single();
StatementScope.Current.AddStatement(new CallStatement(this, method, arg1, arg2));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void Void <TArg1, TArg2, TArg3>(
Expression <Func <T, Action <TArg1, TArg2, TArg3> > > member,
IHappilOperand <TArg1> arg1,
IHappilOperand <TArg2> arg2,
IHappilOperand <TArg3> arg3)
{
var method = ValidateMemberIsMethodOfType(Helpers.ResolveMethodFromLambda(member));
StatementScope.Current.AddStatement(new CallStatement(this, method, arg1, arg2, arg3));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilAssignable <TItem> Item <TIndex1, TIndex2, TItem>(IHappilOperand <TIndex1> indexArg1, IHappilOperand <TIndex2> indexArg2)
{
var indexerProperty = OperandType.GetProperty("Item", typeof(TItem), new[] { typeof(TIndex1), typeof(TIndex2) });
if (indexerProperty == null)
{
throw new InvalidOperationException("Could not find indexer with specified types.");
}
return(new PropertyAccessOperand <TItem>(
target: this,
property: indexerProperty,
indexArguments: new IHappilOperand[] { indexArg1, indexArg2 }));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <T> Iif <T>(IHappilOperand <bool> condition, bool isTautology, IHappilOperand <T> onTrue, IHappilOperand <T> onFalse)
{
if (!isTautology)
{
return(new TernaryConditionalOperator <T>(condition, onTrue, onFalse));
}
else
{
var scope = StatementScope.Current;
scope.Consume(condition);
scope.Consume(onFalse);
return((HappilOperand <T>)onTrue);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilUnaryExpression(
HappilMethod ownerMethod,
IUnaryOperator <TOperand> @operator,
IHappilOperand <TOperand> operand,
UnaryOperatorPosition position = UnaryOperatorPosition.Prefix)
: base(ownerMethod)
{
m_Operand = operand;
m_Operator = @operator;
m_Position = position;
var scope = StatementScope.Current;
scope.Consume(operand as IHappilExpression);
scope.RegisterExpressionStatement(this);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <T> Assign(IHappilOperand <T> value)
{
if (OperandType.IsValueType && value is IValueTypeInitializer && this is ICanEmitAddress)
{
((IValueTypeInitializer)value).Target = this;
return((HappilOperand <T>)value);
}
else
{
return(new HappilBinaryExpression <T, T>(
base.OwnerMethod,
@operator: new BinaryOperators.OperatorAssign <T>(),
left: this,
right: value));
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
internal protected void AddReturnStatement(IHappilOperand <TypeTemplate.TReturn> returnValue)
{
if (m_CurrentBodyDefinitionIndex > 0)
{
if (object.ReferenceEquals(m_ReturnValueLocal, null))
{
m_ReturnValueLocal = this.Local <TypeTemplate.TReturn>();
}
m_ReturnValueLocal.Assign(returnValue.OrNullConstant());
}
else
{
//TODO: verify that current scope belongs to this method
StatementScope.Current.AddStatement(new ReturnStatement <TypeTemplate.TReturn>(returnValue));
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
#region IHappilMethodBodyBase Members
public IHappilIfBody If(IHappilOperand <bool> condition)
{
return(AddStatement(new IfStatement(condition)));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void Return(IHappilOperand <TypeTemplate.TReturn> operand)
{
AddReturnStatement(operand);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <TMethod> MakeDelegate <TTarget, TMethod>(IHappilOperand <TTarget> target, Expression <Func <TTarget, TMethod> > methodSelector)
{
var method = Helpers.ResolveMethodFromLambda(methodSelector);
return(new HappilDelegate <TMethod>(target, method));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void RaiseEvent(string eventName, IHappilOperand <EventArgs> eventArgs)
{
var eventMember = m_HappilClass.FindMember <HappilEvent>(eventName);
eventMember.RaiseEvent(this, eventArgs);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void Return(IHappilOperand <TypeTemplate.TReturn> operand)
{
m_OwnerMethod.AddReturnStatement(operand);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilForShortSyntax For(IHappilOperand <int> from, HappilConstant <int> to, int increment = 1)
{
return(new HappilForShortSyntax(m_OwnerMethod, from.CastTo <int>(), to, increment));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilSwitchSyntax <T> Switch <T>(IHappilOperand <T> value)
{
return(AddStatement(new SwitchStatement <T>(value)));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilLockSyntax Lock(IHappilOperand <object> syncRoot, int millisecondsTimeout)
{
return(AddStatement(new LockStatement(syncRoot, millisecondsTimeout)));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilUsingSyntax Using(IHappilOperand <IDisposable> disposable)
{
return(AddStatement(new UsingStatement(disposable)));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <TReturn> Func <TArg1, TReturn>(MethodInfo method, IHappilOperand <TArg1> arg1)
{
ValidateMemberIsMethodOfType(method);
return(new HappilUnaryExpression <T, TReturn>(m_OwnerMethod, new UnaryOperators.OperatorCall <T>(method, arg1), this));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilForShortSyntax For(IHappilOperand <int> from, IHappilOperand <int> to, int increment = 1)
{
return(new HappilForShortSyntax(this, from.CastTo <int>(), to.CastTo <int>(), increment));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private HappilOperand <T> CreateUnaryExpression <T>(IUnaryOperator <T> @operator, IHappilOperand <T> operand)
{
return(new HappilUnaryExpression <T, T>(
ownerMethod: null,
@operator: @operator,
operand: operand));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <T> Iif <T>(IHappilOperand <bool> condition, IHappilOperand <T> onTrue, IHappilOperand <T> onFalse)
{
return(new TernaryConditionalOperator <T>(condition, onTrue, onFalse));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void Void <TArg1>(MethodInfo method, IHappilOperand <TArg1> arg1)
{
ValidateMemberIsMethodOfType(method);
StatementScope.Current.AddStatement(new CallStatement(this, method, arg1));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilIfBody If(IHappilOperand <bool> condition, bool isTautology)
{
return(AddStatement(new IfStatement(condition, isTautology)));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilWhileSyntax While(IHappilOperand <bool> condition)
{
return(AddStatement(new WhileStatement(condition)));
}
