//----------------------------------------------------------------------------------------------------------------------------------------------------- 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))); }