public SimpleRecResult ExtractPropertyFunction(ref ExpressionNode Node, bool IsSetter) { var Res = ExtractPropertyFunction_OnlyId(ref Node, IsSetter); if (Res != SimpleRecResult.Unknown) { return(Res); } if (Expressions.GetOperator(Node) == Operator.Member) { var Ch = Node.Children; var NewCh1 = Ch[1]; Res = ExtractPropertyFunction_OnlyId(ref NewCh1, IsSetter); if (Res != SimpleRecResult.Succeeded) { return(Res); } var NewCh = new ExpressionNode[] { Ch[0], NewCh1 }; var NewNode = new OpExpressionNode(Operator.Member, NewCh, Node.Code); NewNode.LinkedNodes.AddRange(Node.LinkedNodes); Node = Parent.NewNode(NewNode); return(Node == null ? SimpleRecResult.Failed : SimpleRecResult.Succeeded); } return(SimpleRecResult.Unknown); }
public PluginResult NewOpNode(ref ExpressionNode Node) { var OpNode = Node as OpExpressionNode; var Op = OpNode.Operator; var Ch = OpNode.Children; // ------------------------------------------------------------------------------------ if (Op == Operator.Reinterpret) { if (Ch[0] is ConstExpressionNode) { #warning WARNING } return(PluginResult.Succeeded); } // ------------------------------------------------------------------------------------ else if (Op == Operator.Tuple || Op == Operator.Array) { var Type = Node.Type.RealId as NonrefArrayType; if (Op != Operator.Array || (Type != null && Type.Lengths != null && !(Type.TypeOfValues is AutomaticType))) { if (Ch.TrueForAll(x => x is ConstExpressionNode)) { var Constants = Ch.Select(x => (x as ConstExpressionNode).Value); var SValue = new StructuredValue(Constants.ToList()); Node = Parent.NewNode(new ConstExpressionNode(Node.Type, SValue, Node.Code)); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } } } // ------------------------------------------------------------------------------------ else if (Op == Operator.Index) { if (Ch.TrueForAll(x => x is ConstExpressionNode)) { var ConstCh0 = Ch[0] as ConstExpressionNode; var NonrefArray = Ch[0].Type.RealId as NonrefArrayType; var Dimensions = NonrefArray.Lengths; var Position = 0; var MulBy = 1; for (var i = Dimensions.Length - 1; i >= 0; i--) { var CChip1 = Ch[i + 1] as ConstExpressionNode; var Index = CChip1.Integer; if (Index < 0 || Index >= Dimensions[i]) { State.Messages.Add(MessageId.IndexOutOfRange, CChip1.Code); return(PluginResult.Failed); } Position += (int)Index * MulBy; MulBy *= Dimensions[i]; } var RetValue = ConstCh0.Value.GetMember(Position); var RetType = NonrefArray.TypeOfValues; Node = Parent.NewNode(new ConstExpressionNode(RetType, RetValue, Node.Code)); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } } // ------------------------------------------------------------------------------------ else if (Op == Operator.Member) { var ConstCh0 = Ch[0] as ConstExpressionNode; var Member = Ch[1] as IdExpressionNode; if (ConstCh0 != null && Member != null) { if (ConstCh0.Value is StructuredValue || ConstCh0.Value is ZeroValue) { var SType = ConstCh0.Type.UnderlyingStructureOrRealId as StructuredType; var Members = SType.StructuredScope.IdentifierList; var MemberIndex = Members.IndexOf(Member.Identifier); var RetValue = ConstCh0.Value.GetMember(MemberIndex); var RetType = Member.Identifier.TypeOfSelf; Node = Parent.NewNode(new ConstExpressionNode(RetType, RetValue, Node.Code)); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } } } // ------------------------------------------------------------------------------------ else if (Op == Operator.Cast) { var Child = Ch[0] as ConstExpressionNode; if (Child == null) { return(PluginResult.Succeeded); } var To = Expressions.GetIdentifier(Ch[1]); var RTo = To.RealId as Type; var RFrom = Child.Type.RealId as Type; if (Child.Value is NullValue || RFrom is AutomaticType) { var OldNode = Node; if ((Node = Node.DetachChild(0)) == null) { return(PluginResult.Failed); } Node.Type = OldNode.Type; Node.Flags |= ExpressionFlags.FixedType; return(PluginResult.Ready); } Predicate <Identifier> Func = x => { var Rx = x.RealId as Type; if (Rx is PointerType || Rx is ReferenceType || Rx is PointerAndLength || ((Rx.TypeFlags & TypeFlags.ReferenceValue) != 0 && !(Rx is StringType))) { return(false); } return(true); }; if (!Identifiers.ProcessTuple(RTo, Func)) { return(PluginResult.Succeeded); } if (RTo is TupleType && !(RFrom is TupleType)) { var TupleTo = RTo as TupleType; var ToMembers = TupleTo.StructuredScope.IdentifierList; var TupleCh = new ExpressionNode[ToMembers.Count]; for (var i = 0; i < ToMembers.Count; i++) { var ToType = ToMembers[i].Children[0]; var Value = Child.Value.Convert(ToType); if (Value == null) { var Params = new String[] { Child.Value.ToString(), ToType.Name.ToString() }; State.Messages.Add(MessageId.CannotConvertConst, Node.Code, Params); return(PluginResult.Failed); } TupleCh[i] = Value.ToExpression(Parent, ToType, Node.Code); if (TupleCh[i] == null) { return(PluginResult.Failed); } } Node = new OpExpressionNode(Operator.Tuple, TupleCh, Node.Code); Node.Type = To; Node = Parent.NewNode(Node); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } var Ret = Child.Value.Convert(RTo); if (Ret == null) { var Params = new String[] { Child.Value.ToString(), To.Name.ToString() }; State.Messages.Add(MessageId.CannotConvertConst, Node.Code, Params); return(PluginResult.Failed); } if (Ret is IntegerValue && Node.CheckingMode == CheckingMode.Unchecked) { var IRet = Ret as IntegerValue; IRet.Value = DataStoring.WrapToType(IRet.Value, RTo); } Node = Ret.ToExpression(Parent, To, Node.Code); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } // ------------------------------------------------------------------------------------ else if (Op == Operator.And || Op == Operator.Or) { var ConstIndex = Ch[0] is ConstExpressionNode ? 0 : (Ch[1] is ConstExpressionNode ? 1 : -1); if (ConstIndex != -1) { var CNode = Ch[ConstIndex] as ConstExpressionNode; var IsAnd = Op == Operator.And; if (CNode.Bool == IsAnd) { Node = Node.DetachChild(1 - ConstIndex); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } Node = Parent.NewNode(new ConstExpressionNode(Node.Type, new BooleanValue(!IsAnd), Node.Code)); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } } // ------------------------------------------------------------------------------------ else if (Op == Operator.Condition) { var Condition = Ch[0] as ConstExpressionNode; if (Condition != null) { Node = Condition.Bool ? Ch[1] : Ch[2]; return(PluginResult.Ready); } } // ------------------------------------------------------------------------------------ else if (Op == Operator.Call) { var Res = NewCallOpNode(ref Node); if (Res != PluginResult.Succeeded) { return(Res); } } // ------------------------------------------------------------------------------------ else if (Operators.IsCalculable(Op)) { if (Ch[0] is ConstExpressionNode && (Ch.Length == 1 || Ch[1] is ConstExpressionNode)) { return(Evaluate(ref Node)); } if (Operators.IsReversible(Op) && Ch[0] is ConstExpressionNode && Identifiers.IsScalarOrVectorNumber(Ch[0].Type) && !(Ch[1] is ConstExpressionNode)) { OpNode.Swap(); Op = OpNode.Operator; } if (Op == Operator.Add || Op == Operator.Subract) { var ConstCh1 = Ch[1] as ConstExpressionNode; if (ConstCh1 != null && Identifiers.IsScalarOrVectorNumber(ConstCh1.Type)) { if (Constants.CompareTupleValues(ConstCh1.Value, x => x.Double == 0)) { Node = Node.DetachChild(0); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } var OpCh0 = Ch[0] as OpExpressionNode; if (OpCh0 != null) { var Ch0Op = OpCh0.Operator; var Ch0Ch = OpCh0.Children; if (Ch0Op == Operator.Add || Ch0Op == Operator.Subract) { var ConstIndex = -1; if (Ch0Ch[0] is ConstExpressionNode) { ConstIndex = 0; } else if (Ch0Ch[1] is ConstExpressionNode) { ConstIndex = 1; } if (ConstIndex != -1) { var ConstCh0Chx = Ch0Ch[ConstIndex] as ConstExpressionNode; var NewOp = Op == Ch0Op ? Operator.Add : Operator.Subract; ExpressionNode[] NewCh; // For strings if (NewOp == Operator.Add) { NewCh = new ExpressionNode[] { ConstCh0Chx, Ch[1] } } ; else { NewCh = new ExpressionNode[] { Ch[1], ConstCh0Chx } }; Ch[0] = OpCh0.Children[1 - ConstIndex]; Ch[1] = Parent.NewNode(new OpExpressionNode(NewOp, NewCh, Node.Code)); if (Ch[1] == null) { return(PluginResult.Failed); } } } } } } else if (Op == Operator.Multiply || Op == Operator.Divide) { var ConstCh1 = Ch[1] as ConstExpressionNode; if (ConstCh1 != null && Identifiers.IsScalarOrVectorNumber(ConstCh1.Type)) { if (Constants.CompareTupleValues(ConstCh1.Value, x => x.Double == 1)) { Node = Node.DetachChild(0); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } if (Constants.CompareTupleValues(ConstCh1.Value, x => x.Double == 0) && Op == Operator.Multiply) { Node = Node.DetachChild(1); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } var OpCh0 = Ch[0] as OpExpressionNode; if (OpCh0 != null) { var Ch0Op = OpCh0.Operator; var Ch0Ch = OpCh0.Children; if (Ch0Op == Operator.Multiply || Ch0Op == Operator.Divide) { var ConstIndex = -1; if (Ch0Ch[0] is ConstExpressionNode) { ConstIndex = 0; } else if (Ch0Ch[1] is ConstExpressionNode) { ConstIndex = 1; } if (ConstIndex != -1) { var ConstCh0Chx = Ch0Ch[ConstIndex] as ConstExpressionNode; var NewOp = Op == Ch0Op ? Operator.Multiply : Operator.Divide; var NewCh = new ExpressionNode[] { Ch[1], ConstCh0Chx }; Ch[0] = OpCh0.Children[1 - ConstIndex]; Ch[1] = Parent.NewNode(new OpExpressionNode(NewOp, NewCh, Node.Code)); if (Ch[1] == null) { return(PluginResult.Failed); } } } } } } else if (Operators.IsRelEquality(Op)) { if (Ch[0] is ConstExpressionNode && !(Ch[1] is ConstExpressionNode)) { OpNode.Swap(); Op = OpNode.Operator; } var ConstCh1 = Ch[1] as ConstExpressionNode; var Type = Ch[0].Type != null ? Ch[0].Type.RealId : null; if (Type is UnsignedType && ConstCh1 != null && ConstCh1.Integer == 0) { if (Op == Operator.GreaterEqual) { Node = Constants.GetBoolValue(Container, true, Node.Code); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } else if (Op == Operator.Greater) { OpNode.Operator = Op = Operator.Inequality; } else if (Op == Operator.Less) { Node = Constants.GetBoolValue(Container, false, Node.Code); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } else if (Op == Operator.LessEqual) { OpNode.Operator = Op = Operator.Equality; } } } if (Op == Operator.Subract && Ch[1] is ConstExpressionNode) { var ConstCh1 = Ch[1] as ConstExpressionNode; if (ConstCh1 != null && ConstCh1.Type.RealId is NumberType && ConstCh1.CDouble < 0.0) { var NewCh = new ExpressionNode[] { ConstCh1 }; Ch[1] = Parent.NewNode(new OpExpressionNode(Operator.Negation, NewCh, Node.Code)); if (Ch[1] == null) { return(PluginResult.Failed); } OpNode.Operator = Op = Operator.Add; } } } return(PluginResult.Succeeded); }
public override PluginResult NewNode(ref ExpressionNode Node) { if (!CheckChildrenIdNodes(Node)) { return(PluginResult.Failed); } var TempRes = ResolveLinkingAssigment(ref Node); if (TempRes != PluginResult.Succeeded) { return(TempRes); } var Extracted = false; for (var i = 0; i < Node.LinkedNodes.Count; i++) { var LNode = Node.LinkedNodes[i]; SetIdNodeUsed(LNode.Node); LNode.Node = Extract(LNode.Node, ref Extracted); if (LNode.Node == null) { return(PluginResult.Failed); } } var DontExtractProperties = false; var Ch = Node.Children; if (Node is OpExpressionNode) { var OpNode = Node as OpExpressionNode; var Op = OpNode.Operator; if (Operators.IsIncDec(Op)) { var Linked = new LinkedExprNode(Ch[0]); var AddSubCh = new ExpressionNode[2] { Parent.NewNode(new LinkingNode(Linked, Node.Code)), Parent.NewNode(Constants.GetIntValue(Container, 1, Node.Code, true)), }; if (AddSubCh[0] == null || AddSubCh[1] == null) { return(PluginResult.Failed); } Operator AddSubOp; if (Op == Operator.Increase) { AddSubOp = Operator.Add; } else if (Op == Operator.Decrease) { AddSubOp = Operator.Subract; } else { throw new ApplicationException(); } var AssignmentCh = new ExpressionNode[2] { Parent.NewNode(new LinkingNode(Linked, Node.Code)), Parent.NewNode(new OpExpressionNode(AddSubOp, AddSubCh, Node.Code)) }; if (AssignmentCh[0] == null || AssignmentCh[1] == null) { return(PluginResult.Failed); } Node = new OpExpressionNode(Operator.Assignment, AssignmentCh, Node.Code); Node.LinkedNodes.Add(Linked); if ((Node = Parent.NewNode(Node)) == null) { return(PluginResult.Failed); } return(PluginResult.Ready); } else if (Op == Operator.Assignment) { PluginResult Res; if (Ch[0] is IdExpressionNode && Ch[1] is IdExpressionNode) { var IdCh0 = Ch[0] as IdExpressionNode; var IdCh1 = Ch[1] as IdExpressionNode; if (IdCh0.Identifier.RealId is Variable && IdCh1.Identifier.RealId is Variable) { var Ch0NotUsed = Ch[1].CheckNodes(x => { var xId = Expressions.GetIdentifier(x); return(xId == null ? true : xId.RealId != IdCh0.Identifier.RealId); }); if (Ch0NotUsed && DeclaredIds.Contains(IdCh1.Identifier.RealId)) { var Ch1 = (ExpressionNode)IdCh1; Res = ExpressionNode.ReplaceNodes(ref Ch1, Parent, (ref ExpressionNode x) => { var Idx = x as IdExpressionNode; if (Idx != null && Idx.Identifier.RealId == IdCh1.Identifier.RealId) { Vars.Remove(Idx); x = new IdExpressionNode(IdCh0.Identifier, Idx.Code); x.LinkedNodes.AddRange(Idx.LinkedNodes); return(Parent.NewNode(ref x)); } return(PluginResult.Succeeded); }); Node = Ch1; DeclaredIds.Remove(IdCh1.Identifier.RealId); return(Res == PluginResult.Failed ? Res : PluginResult.Ready); } } } var Ch0 = Ch[0]; var Linked = (LinkedExprNode)null; Res = Expressions.ProcessTuple(Parent, ref Ch0, (x, Index) => { if (x is IdExpressionNode) { var IdNode = x as IdExpressionNode; Vars.AssignedIds.Add(IdNode); } Func <ExpressionNode> Value = () => { LinkedExprNode LLinked; var Ch1 = Ch[1]; var Ret = Expressions.GetTupleMember(Parent, ref Ch1, Index, out LLinked); Ch[1] = Ch1; if (LLinked != null) { Linked = LLinked; } return(Ret); }; var LRes = ExtractPropertySetter(x, Value, ref x, ref Extracted); if (LRes == SimpleRecResult.Failed) { return(null); } return(x); }); if (Res != PluginResult.Succeeded) { Ch0.LinkedNodes.AddRange(Node.LinkedNodes); if (Linked != null) { Ch0.LinkedNodes.Add(Linked); } if (Res == PluginResult.Ready) { Node = Ch0; } return(Res); } SetIdNodeUsed(Ch[1]); } else if (Op == Operator.Member) { var IdCh1 = Ch[1] as IdExpressionNode; if (IdCh1 != null && IdCh1.Identifier.RealId is Property) { Ch[0] = ExtractPropertyGetter(Ch[0], ref Extracted); if (Ch[0] == null) { return(PluginResult.Failed); } DontExtractProperties = true; } SetIdNodeUsed(Ch); } else if (Op == Operator.Index) { var Id = Expressions.GetMemberIdentifier(Ch[0]); if (Id != null && Id.RealId is Property) { for (var i = 1; i < Ch.Length; i++) { Ch[i] = ExtractPropertyGetter(Ch[i], ref Extracted); if (Ch[i] == null) { return(PluginResult.Failed); } } DontExtractProperties = true; } SetIdNodeUsed(Ch); } else if (Op == Operator.Address || Operators.IsReference(Op)) { var IdCh0 = Ch[0] as IdExpressionNode; if (IdCh0 != null) { if (Op == Operator.Reference_IdMustBeAssigned) { if (IdCh0 != null) { Vars.UsedBeforeAssignIds.Add(IdCh0); } } else if (Op == Operator.Reference_IdGetsAssigned) { if (IdCh0 != null) { Vars.AssignedIds.Add(IdCh0); } if (!Expressions.IsLValue(Ch[0])) { State.Messages.Add(MessageId.AddressOfRValue, Node.Code); return(PluginResult.Failed); } } else { if (IdCh0 != null) { Vars.AddressUsed.Add(IdCh0); } } } } else if (Op == Operator.Cast) { var From = Ch[0].Type; var To = Expressions.GetIdentifier(Ch[1]); if (To.RealId is PointerType && From.RealId is ArrayType && Ch[0] is IdExpressionNode) { var IdCh0 = Ch[0] as IdExpressionNode; Vars.AddressUsed.Add(IdCh0); } else { SetIdNodeUsed(Ch); } } else if (Op == Operator.Tuple) { DontExtractProperties = true; } else { SetIdNodeUsed(Ch); } } else { SetIdNodeUsed(Ch); } if (Ch != null) { for (var i = 0; i < Ch.Length; i++) { Ch[i] = ExtractPackedId(Ch[i], ref Extracted); if (Ch[i] == null) { return(PluginResult.Failed); } if (!DontExtractProperties) { Ch[i] = ExtractPropertyGetter(Ch[i], ref Extracted); if (Ch[i] == null) { return(PluginResult.Failed); } } if (Expressions.GetOperator(Ch[i]) == Operator.Tuple) { var LocalExtracted = false; var ChiCh = Ch[i].Children; for (var j = 0; j < ChiCh.Length; j++) { ChiCh[j] = ExtractPropertyGetter(ChiCh[j], ref LocalExtracted); if (ChiCh[j] == null) { return(PluginResult.Failed); } } if (LocalExtracted) { Ch[i] = Parent.NewNode(Ch[i]); if (Ch[i] == null) { return(PluginResult.Failed); } Extracted = true; } } } } if (Extracted) { Node = Parent.NewNode(Node); return(PluginResult.Ready); } return(PluginResult.Succeeded); }
public ExpressionNode ExtractPropertyGetter(ExpressionNode Node, ref bool Extracted) { ExpressionNode[] CallCh; AutoAllocatedList <LinkedExprNode> LinkedNodes = new AutoAllocatedList <LinkedExprNode>(); if ((Node.Flags & ExpressionFlags.EnableGetter) != 0) { var Ch = Node.Children; CallCh = new ExpressionNode[Ch.Length - 1]; if (Expressions.GetOperator(Ch[0]) == Operator.Member) { var Ch0Ch = Ch[0].Children; var Linked = new LinkedExprNode(Ch0Ch[0]); LinkedNodes.Add(Linked); Ch0Ch[0] = Parent.NewNode(new LinkingNode(Linked, Node.Code)); if (Ch0Ch[0] == null || (Ch[0] = Parent.NewNode(Ch[0])) == null) { return(null); } var CallCh0Ch = new ExpressionNode[] { Parent.NewNode(new LinkingNode(Linked, Node.Code)), CallCh[0] = GetGetterForSetter(Ch0Ch[1]), }; if (CallCh0Ch[0] == null || CallCh0Ch[1] == null) { return(null); } CallCh[0] = Parent.NewNode(new OpExpressionNode(Operator.Member, CallCh0Ch, Node.Code)); if (CallCh[0] == null) { return(null); } } else if (Ch[0] is IdExpressionNode) { CallCh[0] = GetGetterForSetter(Ch[0]); } for (var i = 1; i < Ch.Length - 1; i++) { var LinkedNode = new LinkedExprNode(Ch[i]); LinkedNodes.Add(LinkedNode); Node.Children[i] = Parent.NewNode(new LinkingNode(LinkedNode, Node.Code)); CallCh[i] = Parent.NewNode(new LinkingNode(LinkedNode, Node.Code)); if (Node.Children[i] == null || CallCh[i] == null) { return(null); } } Node = Parent.NewNode(Node); if (Node == null) { return(null); } Node.Flags &= ~ExpressionFlags.EnableGetter; LinkedNodes.Add(new LinkedExprNode(Node, LinkedNodeFlags.NotRemovable)); } else if (Expressions.GetOperator(Node) == Operator.Index) { var NewNode = Node.Children[0]; var Res = ExtractPropertyFunction(ref NewNode, false); if (Res == SimpleRecResult.Unknown) { return(Node); } if (Res == SimpleRecResult.Failed) { return(null); } CallCh = Node.Children.Slice(0); CallCh[0] = NewNode; } else { var NewNode = Node; var Res = ExtractPropertyFunction(ref NewNode, false); if (Res == SimpleRecResult.Unknown) { return(Node); } if (Res == SimpleRecResult.Failed) { return(null); } CallCh = new ExpressionNode[] { NewNode }; } var Ret = new OpExpressionNode(Operator.Call, CallCh, Node.Code); Ret.LinkedNodes.AddRange(LinkedNodes); Extracted = true; return(Parent.NewNode(Ret)); }
public override PluginResult NewNode(ref ExpressionNode Node) { for (var i = 0; i < Node.LinkedNodes.Count; i++) { var LNode = Node.LinkedNodes[i]; LNode.Node = ResolveNode(LNode.Node); if (LNode.Node == null) { return(PluginResult.Failed); } } if (Node is StrExpressionNode) { return(PluginResult.Interrupt); } else if (Node is LinkingNode) { return(PluginResult.Interrupt); } else if (Node is IdExpressionNode) { var IdNode = Node as IdExpressionNode; var Id = IdNode.Identifier.RealId; if (Id is LocalVariable) { if (!Container.IsSubContainerOf(Id.Container) && Container != Id.Container) { throw new ApplicationException(); } } if (Id is ConstVariable) { var Const = Id as ConstVariable; if (Const.ConstInitValue == null) { throw new ApplicationException(); } Node = Parent.NewNode(new ConstExpressionNode(Const.TypeOfSelf, Const.ConstInitValue, Node.Code)); if (Node == null) { return(PluginResult.Failed); } if (ConvertEnums != null && Const.TypeOfSelf == ConvertEnums) { Node = new OpExpressionNode(Operator.Cast, Node.Code) { Children = new ExpressionNode[] { Node }, Type = ConvertEnums.TypeOfValues, }; if ((Node = Parent.NewNode(Node)) == null) { return(PluginResult.Failed); } } return(PluginResult.Ready); } return(PluginResult.Interrupt); } else if (Node is OpExpressionNode) { var OpNode = Node as OpExpressionNode; var Op = OpNode.Operator; var Ch = OpNode.Children; if (Op == Operator.Assignment) { if ((Ch[1] = ResolveNode(Ch[1])) == null) { return(PluginResult.Failed); } if ((Ch[0] = ResolveNode(Ch[0], Ch[1].Type)) == null) { return(PluginResult.Failed); } } else if (Op == Operator.Call) { if (!ResolveParams(Ch)) { return(PluginResult.Failed); } var OverloadData = Expressions.GetOverloadSelectData(Ch); Ch[0] = ResolveNode(Ch[0], OverloadData: OverloadData); if (Ch[0] == null) { return(PluginResult.Failed); } var Res = ProcessParams(ref Node); if (Res != PluginResult.Succeeded) { return(Res); } if ((State.Language.Flags & LangaugeFlags.AllowMemberFuncStaticRef) != 0) { var Ch0Id = Expressions.GetIdentifier(Ch[0]); if (Ch0Id != null && Ch0Id.IsInstanceIdentifier) { State.Messages.Add(MessageId.NonStatic, Ch[0].Code); return(PluginResult.Failed); } } } else if (Op == Operator.NewArray) { if (!ResolveParams(Ch)) { return(PluginResult.Failed); } if (Ch[0] is StrExpressionNode) { var Type = Container.RecognizeIdentifier(Ch[0].Code, GetIdOptions.DefaultForType); if (Type == null) { return(PluginResult.Failed); } if (Ch.Length < 2) { State.Messages.Add(MessageId.ParamCount, Node.Code); return(PluginResult.Failed); } Node.Type = new RefArrayType(Container, Type, Ch.Length - 1); Node.Children = Ch.Slice(1); return(PluginResult.Succeeded); } var Ch0Id = Expressions.GetIdentifier(Ch[0]); if (Ch0Id != null && Ch0Id.RealId is Type) { if (Ch.Length < 2) { State.Messages.Add(MessageId.ParamCount, Node.Code); return(PluginResult.Failed); } Node.Type = new RefArrayType(Container, Ch0Id, Ch.Length - 1); Node.Children = Ch.Slice(1); return(PluginResult.Succeeded); } } else if (Op == Operator.NewObject) { if (!ResolveParams(Ch)) { return(PluginResult.Failed); } Identifier ConstructType = null; if (Ch[0] is StrExpressionNode) { ConstructType = Container.RecognizeIdentifier(Ch[0].Code, GetIdOptions.DefaultForType); if (ConstructType == null) { return(PluginResult.Failed); } } else if (Ch[0] is IdExpressionNode) { var IdCh0 = Ch[0] as IdExpressionNode; if (IdCh0.Identifier.RealId is Type) { ConstructType = IdCh0.Identifier; } } if (ConstructType != null) { Node.Type = ConstructType; if (ConstructType.RealId is AutomaticType) { if (!(Ch[0] is IdExpressionNode)) { Ch[0] = Parent.NewNode(new IdExpressionNode(ConstructType, Node.Code)); if (Ch[0] == null) { return(PluginResult.Failed); } } Ch[0] = ResolveNode(Ch[0]); return(Ch[0] == null ? PluginResult.Failed : PluginResult.Succeeded); } if (Ch.Length == 1 && !(ConstructType.UnderlyingClassOrRealId is ClassType)) { OpNode.Children = Ch = null; return(PluginResult.Succeeded); } var Structured = ConstructType.UnderlyingClassOrRealId as StructuredType; if (Structured == null) { State.Messages.Add(MessageId.ParamCount, Node.Code); return(PluginResult.Failed); } var Options = GetIdOptions.Default; Options.OverloadData = Expressions.GetOverloadSelectData(Ch); Options.Func = x => x is Constructor; var Constructor = Identifiers.GetMember(State, Structured, null, Node.Code, Options); if (Constructor == null) { return(PluginResult.Failed); } if (!Identifiers.VerifyAccess(Container, Constructor, Node.Code)) { return(PluginResult.Failed); } Ch[0] = Parent.NewNode(new IdExpressionNode(Constructor, Ch[0].Code)); if (Ch[0] == null) { return(PluginResult.Failed); } } Ch[0] = ResolveNode(Ch[0]); if (Ch[0] == null) { return(PluginResult.Failed); } var Res = ProcessParams(ref Node); if (Res != PluginResult.Succeeded) { return(Res); } } else if (Op == Operator.Member) { if ((Ch[0] = ResolveNode(Ch[0])) == null) { return(PluginResult.Failed); } return(PluginResult.Interrupt); } else if (Op == Operator.Tuple || Op == Operator.ScopeResolution) { return(PluginResult.Interrupt); } else if (Ch != null) { for (var i = 0; i < Ch.Length; i++) { Ch[i] = ResolveNode(Ch[i]); if (Ch[i] == null) { return(PluginResult.Failed); } } return(PluginResult.Succeeded); } } else if (Node.Children != null) { for (var i = 0; i < Node.Children.Length; i++) { Node.Children[i] = ResolveNode(Node.Children[i]); if (Node.Children[i] == null) { return(PluginResult.Failed); } } } return(PluginResult.Succeeded); }