Ejemplo n.º 1
0
        public SkippingHandlerResult SkipResult(ref ResultSkippingManager RSM)
        {
            if (!RSM.DoNotSkipBrackets)
            {
                var Char = RSM.CurrentChar;
                if (GenericBracketSkipOptions.Enabled)
                {
                    if ((Char == '<' && !RSM.Back) || (Char == '>' && RSM.Back))
                    {
                        var Result = SkipBracket(ref RSM);
                        if (Result.Index == -1 || GenericBracketSkipOptions.DisableFind == null)
                        {
                            return(Result);
                        }

                        var Substring = RSM.String.SubstringFromTo(RSM.Current + 1, Result.Index - 1);
                        var FindRes   = Substring.Find(GenericBracketSkipOptions.DisableFind,
                                                       GenericBracketSkipOptions.DisableSkip, false, new IdCharCheck(true),
                                                       GenericBracketSkipOptions.SkippingHandlers);

                        if (FindRes.Position == -1)
                        {
                            return(Result);
                        }
                    }
                }

                if (Helper.GetBracket(Char, RSM.Back))
                {
                    return(SkipBracket(ref RSM));
                }
            }

            return(new SkippingHandlerResult(-1));
        }
Ejemplo n.º 2
0
        public SkippingHandlerResult SkipResult(ref ResultSkippingManager RSM)
        {
            if (RSM.CurrentChar == Marker || !UseMarker)
            {
                var Result = RSM.String.SubstringEquals(RSM.Current, Operators, Skip);
                if (Result.Position != -1)
                {
                    if (RSM.Back)
                    {
                        var NewString = RSM.String.Substring(0, RSM.Current);
                        var Res       = NewString.Find(Operators, Skip, Back: true);
                        if (Res.Position != -1)
                        {
                            return(new SkippingHandlerResult(Res.Position));
                        }
                    }
                    else
                    {
                        var NewString = RSM.String.Substring(RSM.Current + Result.String.Length);
                        var Res       = NewString.Find(Operators, Skip, Back: false);

                        if (Res.Position != -1)
                        {
                            var P = Res.Position + RSM.Current + Result.String.Length;
                            return(new SkippingHandlerResult(P));
                        }
                    }
                }
            }

            return(new SkippingHandlerResult(-1));
        }
Ejemplo n.º 3
0
        public SkippingHandlerResult SkipResult(ref ResultSkippingManager RSM)
        {
            var Pos = RSM.Current;

            if (Pos <= 0)
            {
                return(new SkippingHandlerResult(-1));
            }

            var Chr = RSM.String[Pos];

            while (Chr == '-' || Chr == '+')
            {
                Pos--;
                if (Pos == -1)
                {
                    return(new SkippingHandlerResult(-1));
                }
                else
                {
                    Chr = RSM.String[Pos];
                }
            }

            if (Chr != 'e' && Chr != 'E')
            {
                return(new SkippingHandlerResult(-1));
            }

            if (HEXLetterCase != LetterCase.Both)
            {
                if (Chr == 'e' && HEXLetterCase == LetterCase.OnlyLower)
                {
                    return(new SkippingHandlerResult(-1));
                }

                if (Chr == 'E' && HEXLetterCase == LetterCase.OnlyUpper)
                {
                    return(new SkippingHandlerResult(-1));
                }
            }

            var LeftSide = RSM.String.Substring(0, Pos);

            if (LeftSide.Word(Back: true).ValidIdentifierName)
            {
                return(new SkippingHandlerResult(-1));
            }

            var Ret = RSM.Back ? RSM.Current - 1 : RSM.Current + 1;

            return(new SkippingHandlerResult(Ret, true));
        }
Ejemplo n.º 4
0
        SkippingHandlerResult SkipBracket(ref ResultSkippingManager RSM)
        {
            if (RSM.Back)
            {
                var NewString = RSM.String.Substring(0, RSM.Current + 1);
                var Pos       = NewString.GetBracketPos(true, RSM.SkippingHandlers);
                if (Pos != -1)
                {
                    return(new SkippingHandlerResult(Pos));
                }
            }
            else
            {
                var NewString = RSM.String.Substring(RSM.Current);
                var Pos       = NewString.GetBracketPos(false, RSM.SkippingHandlers);
                if (Pos != -1)
                {
                    return(new SkippingHandlerResult(Pos + RSM.Current));
                }
            }

            return(new SkippingHandlerResult(-1));
        }
Ejemplo n.º 5
0
        public static int FindParamPosition(CompilerState State, StringSlice Code)
        {
            var Ok       = false;
            var Handlers = State.Language.GlobalHandlers;
            var RSM      = new ResultSkippingManager(Handlers, Code);

            var Language       = State.Language;
            var LangRoot       = Language.Root;
            var CastRecognizer = Language.Root.GetObject <CastRecognizer>(false);

            while (RSM.Loop())
            {
                var Pos = RSM.Current;
                var Chr = Code[Pos];
                if (!Helper.IsIdChar(Chr))
                {
                    if (!Ok)
                    {
                        continue;
                    }

                    if (Chr == '(')
                    {
                        var Brackets = Code.Substring(Pos);
                        if (CastRecognizer != null && CastRecognizer.IsCastString(State, Brackets))
                        {
                            return(Pos);
                        }

                        if (Brackets.GetBracketPos(false, Handlers) == Brackets.Length - 1)
                        {
                            return(Pos);
                        }
                    }
                    else if (char.IsWhiteSpace(Chr))
                    {
                        // ambiguous: Print (Obj is object).ToString()
                        var After    = Code.Substring(Pos + 1).Trim();
                        var AfterChr = After.Length > 0 ? After[0] : '\0';
                        if (Helper.IsIdChar(AfterChr) || AfterChr == '(' || AfterChr == '[')
                        {
                            return(Pos);
                        }
                    }

                    if (Code.SubstringEquals(Pos, LangRoot.OnlyRight, LangRoot.OnlyRightSkip,
                                             false, new IdCharCheck(true)).Position != -1)
                    {
                        return(Pos);
                    }

                    for (var i = 0; i < Language.ExprRecognizers.Length; i++)
                    {
                        var Rec = Language.ExprRecognizers[i] as SkippedBetweenRecognizer;
                        if (Rec != null && Code.SubstringEquals(Pos, Rec.Operators, Rec.Skip).Index != -1)
                        {
                            return(Pos);
                        }
                    }
                }
                else
                {
                    Ok = true;
                }
            }

            return(-1);
        }