Exemple #1
0
        public ExprRecResult Recognize(CodeString Code, PluginRoot Plugin, ref ExpressionNode Ret)
        {
            var InnerCode = BetweenOperatos(Code);

            if (!InnerCode.IsValid)
            {
                return(ExprRecResult.Unknown);
            }

            var String = RecognizerHelper.ProcessString(InnerCode, Plugin, '~');

            if (String == null)
            {
                return(ExprRecResult.Failed);
            }

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

            var Global = Plugin.Container.GlobalContainer;

            Ret = new ConstExpressionNode(Global.CommonIds.Char, new CharValue(String[0]), Code);
            return(ExprRecResult.Succeeded);
        }
Exemple #2
0
        public ExprRecResult Recognize(CodeString Code, CodeString Function, CodeString[] Params,
                                       CodeString[] GenericParams, PluginRoot Plugin, ref ExpressionNode Out)
        {
            var State     = Plugin.State;
            var Container = Plugin.Container;

            int Func;

            if (Function.IsEqual("incbin_ptr"))
            {
                Func = 0;
            }
            else if (Function.IsEqual("incbin_size"))
            {
                Func = 1;
            }
            else
            {
                return(ExprRecResult.Unknown);
            }

            if (GenericParams != null && GenericParams.Length != 0)
            {
                State.Messages.Add(MessageId.NonGenericIdentifier, Function);
                return(ExprRecResult.Failed);
            }

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

            var IncBin = GetIncBin(Params[0], Plugin);

            if (IncBin == null)
            {
                return(ExprRecResult.Failed);
            }

            if (Func == 0)
            {
                Out = new DataPointerNode(Code, IncBin);
            }
            else if (Func == 1)
            {
                var Type = Container.GlobalContainer.CommonIds.UIntPtr;
                Out = new ConstExpressionNode(Type, new IntegerValue(IncBin.Length), Code);
            }
            else
            {
                throw new ApplicationException();
            }

            return(ExprRecResult.Succeeded);
        }
Exemple #3
0
        public ExpressionNode CreateConstNode(ConstExpressionNode ConstNode, PluginRoot Plugin)
        {
            var Glb = CreateExprConst(ConstNode);

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

            return(Plugin.NewNode(new IdExpressionNode(Glb, ConstNode.Code)));
        }
Exemple #4
0
        public ExprRecResult Recognize(CodeString Code, PluginRoot Plugin, ref ExpressionNode Ret)
        {
            var InnerCode = BetweenOperatos(Code);

            if (!InnerCode.IsValid)
            {
                return(ExprRecResult.Unknown);
            }

            var String = RecognizerHelper.ProcessString(InnerCode, Plugin, '~');

            if (String == null)
            {
                return(ExprRecResult.Failed);
            }

            var Global = Plugin.Container.GlobalContainer;

            Ret = new ConstExpressionNode(Global.CommonIds.String, new StringValue(String), Code);
            return(ExprRecResult.Succeeded);
        }
Exemple #5
0
        public bool VerifyArrayLength(CompilerState State, ConstExpressionNode ConstNode, CodeString Code, bool EnableMessages)
        {
            if (ConstNode.Integer < 0)
            {
                if (EnableMessages)
                {
                    State.Messages.Add(MessageId.ArrayLengthTooSmall, Code);
                }

                return(false);
            }
            else if (ConstNode.Integer > int.MaxValue)
            {
                if (EnableMessages)
                {
                    State.Messages.Add(MessageId.ArrayLengthTooBig, Code);
                }

                return(false);
            }

            return(true);
        }
Exemple #6
0
 public void Declare(ConstExpressionNode Value)
 {
     Declare(Value.Type.RealId as Type, Value.Value);
 }
        ExpressionNode MoveConstantToGlobal(ConstExpressionNode Node)
        {
            var RetValue = Container.GlobalContainer.CreateConstNode(Node, Parent);

            return(RetValue == null ? null : Parent.FinishNode(RetValue));
        }
Exemple #8
0
 public GlobalVariable CreateExprConst(ConstExpressionNode Node)
 {
     return(CreateExprConst(Node.Value, Node.Type));
 }
Exemple #9
0
        public ExprRecResult Recognize(CodeString Code, PluginRoot Plugin, ref ExpressionNode Ret)
        {
            if (Code.Length == 0)
            {
                return(ExprRecResult.Unknown);
            }

            var OldCode   = Code;
            var State     = Plugin.State;
            var Container = Plugin.Container;
            var Global    = Container.GlobalContainer;

            var RadixSpecified = false;
            var Radix          = 10;

            var Sign = RecognizerHelper.GetSign(ref Code);

            if (Code.Length == 0)
            {
                return(ExprRecResult.Unknown);
            }

            if (AtStartStrings != null)
            {
                var Result = Code.StartsWith(AtStartStrings, Skip);
                if (Result.Index != -1)
                {
                    Code = Code.TrimmedSubstring(State, Result.String.Length);
                    if (!Code.IsValid)
                    {
                        return(ExprRecResult.Failed);
                    }

                    RadixSpecified = true;
                    Radix          = AtStart[Result.Index].Radix;
                }
            }

            if (AtEndStrings != null)
            {
                var Result = Code.EndsWith(AtEndStrings, Skip);
                if (Result.Index != -1)
                {
                    if (Radix != -1)
                    {
                        State.Messages.Add(MessageId.MultipleRadix, Code);
                        return(ExprRecResult.Failed);
                    }

                    Code = Code.TrimmedSubstring(State, Result.String.Length);
                    if (!Code.IsValid)
                    {
                        return(ExprRecResult.Failed);
                    }

                    RadixSpecified = true;
                    Radix          = AtStart[Result.Index].Radix;
                }
            }

            if (RecognizerHelper.GetSign(ref Code))
            {
                Sign = !Sign;
            }
            if (Code.Length == 0 || (!char.IsDigit(Code[0]) && !RadixSpecified))
            {
                return(ExprRecResult.Unknown);
            }

            var Options = new ConvStrToNumberOptions();
            var Type    = TypeExtractor(Container, ref Code);

            if (Type == null)
            {
                Options.Type = ConstValueType.Unknown;
            }
            else
            {
                var RType = Type.RealId as Type;
                Options.Type = RType.ConstValueType;
            }

            Code = Code.Trim();
            if (Code.Length == 0)
            {
                return(ExprRecResult.Unknown);
            }

            Options.Radix           = Radix;
            Options.Number          = Code.String;
            Options.LetterCase      = LetterCase.OnlyUpper;
            Options.EnableENotation = true;
            Options.Sign            = Sign;

            ConstValue Value;
            var        Res = RecognizerHelper.ConvStrToNumber(State, Code, Options, out Value);

            if (Res == SimpleRecResult.Unknown)
            {
                return(ExprRecResult.Unknown);
            }
            else if (Res == SimpleRecResult.Failed)
            {
                return(ExprRecResult.Failed);
            }

            if (Type == null)
            {
                Type = Constants.GetDefaultType(Container, Value.Type);
                if (Type.RealId is NumberType && !Value.CheckBounds(Type))
                {
                    var SystemType = Type.GetType();

                    do
                    {
                        var RType = Type.RealId as Type;
                        Type = Global.CommonIds.GetIdentifier(SystemType, RType.Size * 2);

                        if (Type == null)
                        {
                            if (typeof(SignedType).IsEquivalentTo(SystemType))
                            {
                                Type = Global.CommonIds.GetLargestType(typeof(UnsignedType));
                            }
                            else
                            {
                                Type = Global.CommonIds.GetLargestType(typeof(SignedType));
                            }
                            break;
                        }
                    } while (!Value.CheckBounds(Type));
                }
            }

            if (!Value.CheckBounds(State, Type, OldCode))
            {
                return(ExprRecResult.Failed);
            }

            var Flags = Options.Type == ConstValueType.Unknown ?
                        ExpressionFlags.AutoConvert : ExpressionFlags.None;

            Ret = new ConstExpressionNode(Type, Value, OldCode, Flags);
            return(ExprRecResult.Succeeded);
        }
Exemple #10
0
        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);
        }