예제 #1
0
        public static ExpressionNode Throw(PluginRoot Plugin, Identifier ExceptionType,
                                           CodeString Code, BeginEndMode BEMode = BeginEndMode.Both)
        {
            var GlobalContainer = Plugin.Container.GlobalContainer;

            if ((BEMode & BeginEndMode.Begin) != 0 && !Plugin.Begin())
            {
                return(null);
            }

            var IdNode = Plugin.NewNode(new IdExpressionNode(ExceptionType, Code));

            if (IdNode == null)
            {
                return(null);
            }

            var Ch   = new ExpressionNode[] { IdNode };
            var Node = Plugin.NewNode(new OpExpressionNode(Operator.NewObject, Ch, Code));

            if (Node == null)
            {
                return(null);
            }

            return(Throw(Plugin, Node, Code, (BEMode & BeginEndMode.End) != 0));
        }
예제 #2
0
        public static ExpressionNode IsInRange(PluginRoot Plugin, ExpressionNode Node,
                                               ConstValue Min, ConstValue Max, CodeString Code)
        {
            var MinNode = Plugin.NewNode(new ConstExpressionNode(Node.Type, Min, Code));
            var MaxNode = Plugin.NewNode(new ConstExpressionNode(Node.Type, Max, Code));

            if (MinNode == null || MaxNode == null)
            {
                return(null);
            }

            return(IsInRange(Plugin, Node, MinNode, MaxNode, Code));
        }
예제 #3
0
        public static ExpressionNode GetArrayDimension(PluginRoot Plugin,
                                                       ExpressionNode Array, int Index, CodeString Code)
        {
            var Container = Plugin.Container;
            var Type      = Array.Type.RealId;

            if (Type is NonrefArrayType)
            {
                var Arr = Type as NonrefArrayType;
                if (Arr.Lengths == null)
                {
                    throw new ArgumentOutOfRangeException("Index");
                }
                return(Plugin.NewNode(Constants.GetUIntPtrValue(Container, Arr.Lengths[Index], Code)));
            }
            else if (Type is RefArrayType)
            {
                var Arr          = Type as RefArrayType;
                var DimensionsId = Identifiers.GetMember(Plugin.State, Arr, "Dimensions", Code);
                if (DimensionsId == null)
                {
                    return(null);
                }

                var DimensionsIdNode = Plugin.NewNode(new IdExpressionNode(DimensionsId, Code));
                if (DimensionsIdNode == null)
                {
                    return(null);
                }

                var DimensionsCh = new ExpressionNode[] { Array, DimensionsIdNode };
                var Dimensions   = Plugin.NewNode(new OpExpressionNode(Operator.Member, DimensionsCh, Code));
                if (Dimensions == null)
                {
                    return(null);
                }

                var IndexValue = Plugin.NewNode(Constants.GetIntValue(Container, Index, Code));
                if (IndexValue == null)
                {
                    return(null);
                }

                var IndexCh = new ExpressionNode[] { Dimensions, IndexValue };
                return(Plugin.NewNode(new OpExpressionNode(Operator.Index, IndexCh, Code)));
            }
            else
            {
                throw new NotImplementedException();
            }
        }
예제 #4
0
        public static ExpressionNode FlattenIndicesWithoutTempVar(PluginRoot Plugin,
                                                                  ExpressionNode[] Indices, ExpressionNode[] Dimensions, CodeString Code)
        {
            if (Dimensions.Length == 1)
            {
                return(Indices[0]);
            }

            var Ret = (ExpressionNode)null;

            for (var i = Dimensions.Length - 1; i >= 0; i--)
            {
                var Chi = Indices[i];
                for (var j = i + 1; j < Dimensions.Length; j++)
                {
                    var MulCh = new ExpressionNode[] { Chi, Dimensions[j] };
                    Chi = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code));
                    if (Chi == null)
                    {
                        return(null);
                    }
                }

                if (Ret != null)
                {
                    var AddCh = new ExpressionNode[] { Ret, Chi };
                    Ret = Plugin.NewNode(new OpExpressionNode(Operator.Add, AddCh, Code));
                    if (Ret == null)
                    {
                        return(null);
                    }
                }
                else
                {
                    Ret = Chi;
                }
            }

            return(Ret);
        }
예제 #5
0
        public static ExpressionNode Negate(PluginRoot Plugin, ExpressionNode Node, CodeString Code, bool End = false)
        {
            var Ch = new ExpressionNode[] { Node };

            Node = Plugin.NewNode(new OpExpressionNode(Operator.Not, Ch, Code));
            if (Node == null)
            {
                return(null);
            }

            if (End && Plugin.End(ref Node) == PluginResult.Failed)
            {
                return(null);
            }

            return(Node);
        }
예제 #6
0
        public ExpressionNode CreateFuncCallNode(PluginRoot Plugin, CodeString Code)
        {
            CodeString Function, Parameters;

            if (!GetParameters(Plugin.State, Code, out Function, out Parameters))
            {
                return(null);
            }

            var Ch = CallRecognizer.ProcessParameters(Plugin, Function, Parameters);

            if (Ch == null)
            {
                return(null);
            }

            return(Plugin.NewNode(new OpExpressionNode(Operator.Call, Ch, Code)));
        }
예제 #7
0
        public ExprRecResult Recognize(CodeString Code, CodeString Function, CodeString[] Params,
                                       CodeString[] GenericParams, PluginRoot Plugin, ref ExpressionNode Out)
        {
            if (Function.IsEqual("reinterpret_cast"))
            {
                var State     = Plugin.State;
                var Container = Plugin.Container;

                if (GenericParams == null || GenericParams.Length != 1)
                {
                    State.Messages.Add(MessageId.GenericParamCount, Code);
                    return(ExprRecResult.Failed);
                }

                if (Params.Length != 1)
                {
                    State.Messages.Add(MessageId.ParamCount, Code);
                    return(ExprRecResult.Failed);
                }

                var Options = GetIdOptions.DefaultForType;
                var Type    = Identifiers.Recognize(Container, GenericParams[0], Options);
                if (Type == null)
                {
                    return(ExprRecResult.Failed);
                }

                var Child    = Expressions.Recognize(Params[0], Plugin, true);
                var TypeNode = Plugin.NewNode(new IdExpressionNode(Type, GenericParams[0]));
                if (Child == null || TypeNode == null)
                {
                    return(ExprRecResult.Failed);
                }

                Out          = new OpExpressionNode(Operator.Reinterpret, Code);
                Out.Children = new ExpressionNode[] { Child, TypeNode };
                return(ExprRecResult.Succeeded);
            }

            return(ExprRecResult.Unknown);
        }
예제 #8
0
        private bool AllocateObject(CodeScopeNode Scope, ref int Index, SelfVariable Self, ExpressionNode Size, PluginRoot Plugin, CodeString Code)
        {
            var TypeMngrPlugin = Plugin.GetPlugin <TypeMngrPlugin>();

            TypeMngrPlugin.Flags |= TypeMngrPluginFlags.NoWarningOnCastingToSameType;
            TypeMngrPlugin.Flags |= TypeMngrPluginFlags.EnableReadonlyWriting;

            var Func = Identifiers.GetByFullNameFast <Function>(Scope.State, "Internals.ObjectHelper.Allocate");

            if (Func == null)
            {
                return(false);
            }

            var FuncNode = Plugin.NewNode(new IdExpressionNode(Func, Code));

            if (Func == null)
            {
                return(false);
            }

            var FuncType  = Func.Children[0] as TypeOfFunction;
            var SizeParam = FuncType.Children[1] as FunctionParameter;

            if (Size.Type == null || !Size.Type.IsEquivalent(SizeParam.TypeOfSelf))
            {
                Size = Expressions.Convert(Size, SizeParam.TypeOfSelf, Plugin, Code);
                if (Size == null)
                {
                    return(false);
                }
            }

            var CallCh = new ExpressionNode[] { FuncNode, Size };
            var Call   = Plugin.NewNode(new OpExpressionNode(Operator.Call, CallCh, Code));

            if (Call == null)
            {
                return(false);
            }

            var Node = Expressions.Reinterpret(Call, Self.TypeOfSelf, Plugin, Code);

            if (Node == null)
            {
                return(false);
            }

            var FS         = Scope.FunctionScope;
            var Assignment = Expressions.SetValue(FS.SelfVariable, Node, Plugin, Code, true);

            if (Assignment == null)
            {
                return(false);
            }

            var Command = new Command(Scope, Code, CommandType.Expression);

            Command.Expressions = new List <ExpressionNode>()
            {
                Assignment
            };
            Scope.Children.Insert(Index, Command);
            Index++;

            return(ProcessContainer(Command));
        }
예제 #9
0
        public static ExpressionNode FlattenIndices(PluginRoot Plugin, ExpressionNode[] Indices,
                                                    ExpressionNode[] Dimensions, CodeString Code, Identifier TempVarType = null)
        {
            if (Dimensions.Length == 1)
            {
                return(Indices[0]);
            }

            var Ret       = (ExpressionNode)null;
            var MulVar    = (Identifier)null;
            var Container = Plugin.Container;
            var State     = Plugin.State;

            if (Dimensions.Length >= 2)
            {
                var NCPlugin      = Plugin.GetPlugin <NCPlugin>();
                var DeclContainer = NCPlugin.DeclContainer;
                MulVar = DeclContainer.CreateAndDeclareVariable(State.AutoVarName, TempVarType);
                if (MulVar == null)
                {
                    return(null);
                }
            }

            for (var i = Dimensions.Length - 1; i >= 0; i--)
            {
                var Chi        = Indices[i];
                var LinkedNode = (LinkedExprNode)null;
                if (MulVar != null && i != 1)
                {
                    ExpressionNode[] AssignmentCh;
                    if (i == Dimensions.Length - 1)
                    {
                        var Dst = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
                        if (Dst == null)
                        {
                            return(null);
                        }

                        AssignmentCh = new ExpressionNode[] { Dst, Dimensions[i] };
                    }
                    else
                    {
                        var Dst    = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
                        var MulSrc = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
                        if (Dst == null || MulSrc == null)
                        {
                            return(null);
                        }

                        var MulCh   = new ExpressionNode[] { MulSrc, Dimensions[i] };
                        var MulNode = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code));
                        if (MulNode == null)
                        {
                            return(null);
                        }

                        AssignmentCh = new ExpressionNode[] { Dst, MulNode };
                    }

                    var Assignment = Plugin.NewNode(new OpExpressionNode(Operator.Assignment, AssignmentCh, Code));
                    if (Assignment == null)
                    {
                        return(null);
                    }

                    LinkedNode = new LinkedExprNode(Assignment, LinkedNodeFlags.NotRemovable);
                }

                if (MulVar != null && i != Dimensions.Length - 1)
                {
                    var MulNode = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
                    if (MulNode == null)
                    {
                        return(null);
                    }

                    var MulCh = new ExpressionNode[] { Chi, MulNode };
                    Chi = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code));
                    if (Chi == null)
                    {
                        return(null);
                    }
                }

                if (Ret != null)
                {
                    var AddCh   = new ExpressionNode[] { Ret, Chi };
                    var AddNode = new OpExpressionNode(Operator.Add, AddCh, Code);
                    if (LinkedNode != null)
                    {
                        AddNode.LinkedNodes.Add(LinkedNode);
                    }

                    Ret = Plugin.NewNode(AddNode);
                    if (Ret == null)
                    {
                        return(null);
                    }
                }
                else
                {
                    Ret = Chi;
                    if (LinkedNode != null)
                    {
                        Ret.LinkedNodes.Add(LinkedNode);
                    }
                }
            }

            return(Ret);
        }