public bool Initialize() { if (Type.Children.Length > 1) { Parameters = new List <ParamVariable>(); for (var i = 1; i < Type.Children.Length; i++) { var e = Type.Children[i] as FunctionParameter; var Param = new ParamVariable(this, e.Name, e.TypeOfSelf); Param.LocalIndex = LocalIdentifiers.Count; LocalIdentifiers.Add(Param); Parameters.Add(Param); } } var StructuredParent = Parent.RealContainer as StructuredScope; if (StructuredParent != null && (Function.Flags & IdentifierFlags.Static) == 0) { var StructuredType = StructuredParent.StructuredType; SelfVariable = new SelfVariable(this, StructuredType); LocalIdentifiers.Add(SelfVariable); var ClassType = StructuredType as ClassType; if (ClassType != null && ClassType.BaseStructures.Length == 1) { BaseVariable = new BaseVariable(this, ClassType.BaseStructures[0].Base); LocalIdentifiers.Add(BaseVariable); } } return(true); }
public void UnionInPlace(NodeVariables Vars) { for (var i = 0; i < Vars.AssignedIds.Count; i++) { if (!AssignedIds.Contains(Vars.AssignedIds[i])) { AssignedIds.Add(Vars.AssignedIds[i]); } } for (var i = 0; i < Vars.UsedBeforeAssignIds.Count; i++) { if (!UsedBeforeAssignIds.Contains(Vars.UsedBeforeAssignIds[i])) { UsedBeforeAssignIds.Add(Vars.UsedBeforeAssignIds[i]); } } for (var i = 0; i < Vars.AddressUsed.Count; i++) { if (!AddressUsed.Contains(Vars.AddressUsed[i])) { AddressUsed.Add(Vars.AddressUsed[i]); } } }
public ExpressionNode DetachChild(int Index) { var Ret = Children[Index]; var LinkedNodes = new AutoAllocatedList <LinkedExprNode>(); for (var i = 0; i < this.LinkedNodes.Count; i++) { var LNode = this.LinkedNodes[i]; if ((LNode.Flags & LinkedNodeFlags.PostComputation) != 0) { throw new NotImplementedException(); } if ((LNode.Flags & LinkedNodeFlags.NotRemovable) != 0) { LinkedNodes.Add(LNode); } else { var LinkingCount = Children[Index].GetLinkingCount(LNode); if (LinkingCount > 0) { LNode.LinkingCount = LinkingCount; LinkedNodes.Add(LNode); } } } for (var i = 0; i < Index; i++) { Children[i].GetLinkedNodes(ref LinkedNodes, true); } if (Children[Index].LinkedNodes.List != null) { LinkedNodes.AddRange(Children[Index].LinkedNodes.List); } for (var i = Index + 1; i < Children.Length; i++) { Children[i].GetLinkedNodes(ref LinkedNodes, true); } Ret.LinkedNodes = LinkedNodes; return(Ret); }
public virtual void AddIdentifier(Identifier Id) { if (FunctionScope != null) { Id.LocalIndex = FunctionScope.LocalIdentifiers.Count; FunctionScope.LocalIdentifiers.Add(Id); } IdentifierList.Add(Id); }
public AutoAllocatedList <T2> Change <T2>() where T2 : class { var Ret = new AutoAllocatedList <T2>(); for (var i = 0; i < Count; i++) { Ret.Add(this[i] as T2); } return(Ret); }
public bool OnIdentifierDeclared(Identifier Id) { var Loc = Id as LocalVariable; if (Loc != null) { Loc.PreAssigned = true; } DeclaredIds.Add(Id); return(true); }
private void ProcessVirtual(MemberFunction Func) { Func.SetUsed(); if ((Func.Flags & IdentifierFlags.Override) != 0) { var Overridden = Func.OverriddenId.RealId as MemberFunction; Func.VirtualIndex = Overridden.VirtualIndex; OldVirtuals[Func.VirtualIndex] = Func; } else { Func.VirtualIndex = OldVirtuals.Count; OldVirtuals.Add(Func); } }
public FunctionOverloads GetOverload(string Name) { for (var i = 0; i < FunctionOverloads.Count; i++) { var Overload = FunctionOverloads[i]; if (Overload.Name == Name) { return(Overload); } } var Ret = new FunctionOverloads(Name); FunctionOverloads.Add(Ret); return(Ret); }
public void GetLinkedNodes(ref AutoAllocatedList <LinkedExprNode> Out, bool OnlyNotRemovable = false) { if (LinkedNodes.List != null) { Out.AddRange(LinkedNodes.List); } for (var i = 0; i < LinkedNodes.Count; i++) { var LNode = LinkedNodes[i]; if (!OnlyNotRemovable || (LNode.Flags & LinkedNodeFlags.NotRemovable) != 0) { Out.Add(LNode); } } if (Children != null) { for (var i = 0; i < Children.Length; i++) { Children[i].GetLinkedNodes(ref Out, OnlyNotRemovable); } } }
public override PluginResult NewNode(ref ExpressionNode Node) { if (Node is StrExpressionNode) { var IdNode = Node as StrExpressionNode; var Preproc = State.GlobalContainer.Preprocessor; var Macro = Preproc.GetMacro(IdNode.Code.ToString()); if (IfDef) { Node = Parent.NewNode(Constants.GetBoolValue(Container, Macro != null, Node.Code)); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } else if (Macro != null) { if (Macro.Value == null) { State.Messages.Add(MessageId.MacroWithoutValue, Node.Code); return(PluginResult.Failed); } Macro.Used = true; if (Macro.Parameters == null || Macro.Parameters.Count == 0) { Node = Macro.Value.Copy(Parent, Mode: BeginEndMode.None, Code: IdNode.Code); } else { Node = Parent.NewNode(new MacroExpressionNode(Macro, Node.Code)); } return(Node == null ? PluginResult.Failed : PluginResult.Ready); } } // ------------------------------------------------------------------------------------ else if (Node is OpExpressionNode) { var OpNode = Node as OpExpressionNode; var Ch = OpNode.Children; var Op = OpNode.Operator; if (Op == Operator.Call && Ch[0] is MacroExpressionNode) { var MFunc = Ch[0] as MacroExpressionNode; var Macro = MFunc.Macro; Macro.Used = true; if (Ch.Length != Macro.Parameters.Count + 1) { State.Messages.Add(MessageId.ParamCount, Node.Code); return(PluginResult.Failed); } var Nodes = new AutoAllocatedList <ExpressionNode>(); var LnkNodes = new AutoAllocatedList <LinkedExprNode>(); for (var i = 1; i < Ch.Length; i++) { if (!(Ch[i] is OpExpressionNode)) { Nodes.Add(Ch[i]); } else { var N = new LinkedExprNode(Ch[i]); LnkNodes.Add(N); Nodes.Add(new LinkingNode(N, Node.Code)); } } PluginFunc Func = (ref ExpressionNode x) => { if (x is MacroArgNode) { var ArgIndex = (x as MacroArgNode).Index; x = Nodes[ArgIndex].Copy(Parent, Mode: BeginEndMode.None); return(x == null ? PluginResult.Failed : PluginResult.Ready); } return(PluginResult.Succeeded); }; Node = Macro.Value.Copy(Parent, Func, BeginEndMode.None); if (Node == null) { return(PluginResult.Failed); } Node.LinkedNodes.AddRange(LnkNodes); Node = Parent.NewNode(Node); return(Node == null ? PluginResult.Failed : PluginResult.Ready); } } // ------------------------------------------------------------------------------------ if (!CheckMacroNodes(Node)) { return(PluginResult.Failed); } else { 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)); }
void ReadReference(LoaderReference Ref) { var NonDeclared = (UndeclaredIdType)Reader.ReadByte(); if (NonDeclared == UndeclaredIdType.Unknown) { ReadReferenceDeclared(Ref); return; } Identifier NewId; var Container = Ref.DstId.Container; if (NonDeclared == UndeclaredIdType.RefArrayType) { var Arr = new RefArrayType(Container, null, 0, false); ReadReference(Arr, ReferenceDestination.Children, 0); UpdateList.Add(Arr); Arr.Dimensions = ReadLEB128_Int(); NewId = Arr; } else if (NonDeclared == UndeclaredIdType.NonrefArrayType) { var Arr = new NonrefArrayType(Container, null, null, false); ReadReference(Arr, ReferenceDestination.Children, 0); UpdateList.Add(Arr); var Dimensions = ReadLEB128_Int(); if (Dimensions != 0) { var Lengths = new int[Dimensions]; for (var i = 0; i < Dimensions; i++) { Lengths[i] = ReadLEB128_Int(); } Arr.Lengths = Lengths; Arr.Dimensions = Dimensions; } NewId = Arr; } else if (NonDeclared == UndeclaredIdType.Pointer) { NewId = new PointerType(Container, null, false); ReadReference(NewId, ReferenceDestination.Children, 0); UpdateList.Add(NewId); } else if (NonDeclared == UndeclaredIdType.Reference) { var Mode = (ReferenceMode)Reader.ReadByte(); NewId = new ReferenceType(Container, null, Mode, false); ReadReference(NewId, ReferenceDestination.Children, 0); UpdateList.Add(NewId); } else if (NonDeclared == UndeclaredIdType.Tuple) { var Tuple = new TupleType(Container, (List <Identifier>)null); Tuple.InstanceSize = ReadLEB128_Int(); if (Tuple.InstanceSize <= 0) { throw new InvalidAssemblyException("Invalid size"); } Tuple.Size = Tuple.InstanceSize; Tuple.Align = ReadLEB128_Int(); Tuple.LayoutCalculated = true; if (!DataStoring.VerifyAlign(Tuple.Align)) { throw new InvalidAssemblyException("Invalid alignment"); } var Named = Reader.ReadBoolean(); var MemberCount = ReadLEB128_Int(); for (var i = 0; i < MemberCount; i++) { var Name = Named ? new CodeString(ReadLEB128_String()) : new CodeString(); var MemberVar = new MemberVariable(Tuple.StructuredScope, Name, null); MemberVar.Access = IdentifierAccess.Public; ReadReference(MemberVar, ReferenceDestination.Children, 0); MemberVar.Offset = ReadLEB128_Int(); Tuple.StructuredScope.IdentifierList.Add(MemberVar); } UpdateList.Add(Tuple); NewId = Tuple; } else if (NonDeclared == UndeclaredIdType.PointerAndLength) { var PAndL = new PointerAndLength(Container, null, false); ReadReference(PAndL.PointerType, ReferenceDestination.Children, 0); UpdateList.Add(PAndL); NewId = PAndL; } else if (NonDeclared == UndeclaredIdType.NonstaticFunctionType) { var FType = new NonstaticFunctionType(Container, null, false); ReadReference(FType, ReferenceDestination.Children, 0); UpdateList.Add(FType); NewId = FType; } else if (NonDeclared == UndeclaredIdType.Function) { var Conv = (CallingConvention)Reader.ReadByte(); NewId = new TypeOfFunction(Container, Conv, new Identifier[1], false); ReadReference(NewId, ReferenceDestination.Children, 0); ReadParameterReferences(NewId); UpdateList.Add(NewId); } else { NewId = Global.CommonIds.GetIdentifier(NonDeclared); if (NewId == null) { throw new InvalidAssemblyException(); } } SetReferencedId(Ref, NewId); }
PluginResult ProcessParams(ref ExpressionNode Node) { var Ch = Node.Children; var Type = Ch[0].Type; if (Type == null) { var IdCh0 = Ch[0] as IdExpressionNode; if (IdCh0 != null) { Type = IdCh0.Identifier.TypeOfSelf; } else { return(PluginResult.Succeeded); } } var FuncType = Type.RealId as TypeOfFunction; if (FuncType == null) { return(PluginResult.Succeeded); } if (FuncType.Children.Length < Ch.Length) { if ((State.Language.Flags & LangaugeFlags.ConvertParametersToTuple) != 0) { if (FuncType.Children.Length == 2 && Ch.TrueForAll(x => !(x is NamedParameterNode))) { var Param0 = FuncType.Children[1] as FunctionParameter; if (Param0.TypeOfSelf.RealId is TupleType) { var NewCh1 = Parent.NewNode(new OpExpressionNode(Operator.Tuple, Ch.Slice(1), Node.Code)); if (NewCh1 == null || ResolveNode(ref NewCh1) == PluginResult.Failed) { return(PluginResult.Failed); } Node.Children = Ch = new ExpressionNode[] { Ch[0], NewCh1 }; return(PluginResult.Succeeded); } } } } var ExtraParams = new AutoAllocatedList <ExpressionNode>(); var Ret = new ExpressionNode[FuncType.Children.Length]; Ret[0] = Ch[0]; var RetValue = true; var NamedParameter = false; for (var i = 1; i < Ch.Length; i++) { if (Ch[i] is NamedParameterNode) { var Chi = Ch[i] as NamedParameterNode; var Param = FuncType.GetParameter(Chi.Name.ToString()); if (Param == null) { State.Messages.Add(MessageId.UnknownId, Chi.Name); RetValue = false; continue; } var Index = FuncType.GetChildIndex(Param); if (Ret[Index] != null) { State.Messages.Add(MessageId.ParamAlreadySpecified, Chi.Code); RetValue = false; continue; } Ret[Index] = Chi.Children[0]; NamedParameter = true; } else { if (NamedParameter) { State.Messages.Add(MessageId.UnnamedParamAfterNamed, Ch[i].Code); RetValue = false; continue; } if (i >= Ret.Length) { ExtraParams.Add(Ch[i]); } else { Ret[i] = Ch[i]; } } } var LastParam = FuncType.Children[FuncType.Children.Length - 1] as FunctionParameter; if (LastParam != null && (LastParam.ParamFlags & ParameterFlags.ParamArray) != 0) { var First = Ret[Ret.Length - 1]; if (ExtraParams.Count > 0 || NeedToCreateParamArray(First, LastParam)) { ExtraParams.Insert(0, First); var ArrCh = ExtraParams.ToArray(); var Arr = Parent.NewNode(new OpExpressionNode(Operator.Array, ArrCh, Node.Code)); if (Arr == null) { return(PluginResult.Failed); } Ret[Ret.Length - 1] = Arr; } } else if (ExtraParams.Count > 0) { State.Messages.Add(MessageId.ParamCount, Node.Code); return(PluginResult.Failed); } for (var i = 1; i < Ret.Length; i++) { if (Ret[i] == null) { var Param = FuncType.Children[i] as FunctionParameter; if (Param.ConstInitValue != null) { Ret[i] = new ConstExpressionNode(Param.TypeOfSelf, Param.ConstInitValue, Node.Code); if ((Ret[i] = Parent.NewNode(Ret[i])) == null) { RetValue = false; continue; } } else { State.Messages.Add(MessageId.ParamNotSpecified, Node.Code, Param.Name.ToString()); RetValue = false; continue; } } } Node.Children = Ret; return(RetValue ? PluginResult.Succeeded : PluginResult.Failed); }
PluginResult ForceContinue(ref ExpressionNode Node, Identifier DeclarationType = null, OverloadSelectionData OverloadData = new OverloadSelectionData(), ResolveNodeFlags Flags = ResolveNodeFlags.None) { if (Node is StrExpressionNode) { var StrNode = Node as StrExpressionNode; var Code = StrNode.Code; Node = GetOrDeclareId(Code, !DoNotFail, DeclarationType, OverloadData); if (Node == null) { if (!DoNotFail) { return(PluginResult.Failed); } Node = StrNode; Node.InterrupterPlugin = -1; Dependencies.Add(StrNode.Code); } else { if (ResolveNode(ref Node) == PluginResult.Failed) { return(PluginResult.Failed); } return(PluginResult.Ready); } } else if (Node is IdExpressionNode) { var IdNode = Node as IdExpressionNode; var Id = IdNode.Identifier.RealId; if (!(Id is Constructor)) { if ((Flags & ResolveNodeFlags.Member) == 0) { var Lang = State.Language; if ((Lang.Flags & LangaugeFlags.AllowMemberFuncStaticRef) == 0 || !(IdNode.Identifier.RealId is Function)) { if (IdNode.Identifier.IsInstanceIdentifier) { State.Messages.Add(MessageId.NonStatic, Node.Code); return(PluginResult.Failed); } } } else { if (!IdNode.Identifier.IsInstanceIdentifier) { State.Messages.Add(MessageId.Static, Node.Code); return(PluginResult.Failed); } } } } else if (Node is LinkingNode) { var LinkingNode = Node as LinkingNode; var LinkedNode = LinkingNode.LinkedNode; LinkedNode.Node = ResolveNode(LinkedNode.Node, DeclarationType, OverloadData); if (LinkedNode.Node == null) { return(PluginResult.Failed); } } else if (Node is OpExpressionNode) { var OpNode = Node as OpExpressionNode; var Ch = OpNode.Children; var Op = OpNode.Operator; if (Op == Operator.Tuple) { var Failed = false; var TupleDeclType = DeclarationType != null ? DeclarationType.RealId as TupleType : null; for (var i = 0; i < Ch.Length; i++) { var T = (Identifier)null; if (TupleDeclType != null) { T = TupleDeclType.StructuredScope.IdentifierList[i].TypeOfSelf; } if ((Ch[i] = ResolveNode(Ch[i], T)) == null) { Failed = true; } } if (Failed) { return(PluginResult.Failed); } } else if (Op == Operator.Member) { if (Ch[1] is StrExpressionNode) { var Res = ForceContinue_MemberNode(ref Node, OverloadData); if (Res != PluginResult.Succeeded) { return(Res); } } Ch[1] = ResolveNode(Ch[1], Flags: Flags | ResolveNodeFlags.Member); if (Ch[1] == null) { return(PluginResult.Failed); } } else if (Op == Operator.ScopeResolution) { if (Ch[1] is StrExpressionNode) { var Res = ForceContinue_ScopeResolution(ref Node, OverloadData); if (Res != PluginResult.Succeeded) { return(Res); } } Ch[1] = ResolveNode(Ch[1], Flags: Flags | ResolveNodeFlags.Member); if (Ch[1] == null) { return(PluginResult.Failed); } } else { throw new ApplicationException(); } } else { throw new ApplicationException(); } return(PluginResult.Succeeded); }