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