Exemple #1
0
        /// <summary>
        ///     Parses a For Expression from the Parser
        /// </summary>
        /// <param name="parser">The Parser</param>
        /// <returns>Parsed Expression</returns>
        public static HlExpression ReadFor(HlExpressionParser parser)
        {
            IHlToken ft = parser.CurrentToken;

            parser.Eat(HlTokenType.OpFor);
            parser.Eat(HlTokenType.OpBracketOpen);
            HlExpression vDecl = parser.ParseExpr();

            if (parser.CurrentToken.Type == HlTokenType.OpSemicolon)
            {
                parser.Eat(HlTokenType.OpSemicolon);
            }

            HlExpression condition = parser.ParseExpr();

            if (parser.CurrentToken.Type == HlTokenType.OpSemicolon)
            {
                parser.Eat(HlTokenType.OpSemicolon);
            }

            HlExpression vInc = parser.ParseExpr();

            parser.Eat(HlTokenType.OpBracketClose);

            HlExpression        token = null;
            List <HlExpression> block;

            if (parser.CurrentToken.Type != HlTokenType.OpBlockToken)
            {
                block = new List <HlExpression> {
                    parser.ParseExpr()
                };
            }
            else
            {
                block = HlExpressionParser.Create(new HlExpressionReader(parser.CurrentToken.GetChildren())).
                        Parse().
                        ToList();
            }

            token = new HlForOp(vDecl, condition, vInc, block.ToArray(), ft.SourceIndex);

            return(token);
        }
Exemple #2
0
        /// <summary>
        ///     Creates a Value based on the Current State of the Expression Parser
        /// </summary>
        /// <param name="parser">The Parser</param>
        /// <returns>Parsed Expression</returns>
        public HlExpression CreateValue(HlExpressionParser parser, uint maxPrecedence)
        {
            if (parser.CurrentToken.Type == HlTokenType.OpBang ||
                parser.CurrentToken.Type == HlTokenType.OpTilde ||
                parser.CurrentToken.Type == HlTokenType.OpPlus ||
                parser.CurrentToken.Type == HlTokenType.OpMinus)
            {
                if (parser.Reader.PeekNext().Type == HlTokenType.OpPlus)
                {
                    parser.Eat(HlTokenType.OpPlus);
                    parser.Eat(HlTokenType.OpPlus);
                    HlTokenType  t     = HlTokenType.OpUnaryPrefixIncrement;
                    HlExpression token = new HlUnaryOp(parser.ParseExpr(), t);

                    return(token);
                }
                else if (parser.Reader.PeekNext().Type == HlTokenType.OpMinus)
                {
                    parser.Eat(HlTokenType.OpMinus);
                    parser.Eat(HlTokenType.OpMinus);
                    HlTokenType  t     = HlTokenType.OpUnaryPrefixDecrement;
                    HlExpression token = new HlUnaryOp(parser.ParseExpr(), t);

                    return(token);
                }
                else
                {
                    HlTokenType t = parser.CurrentToken.Type;
                    parser.Eat(t);
                    HlExpression token = new HlUnaryOp(parser.ParseExpr(), t);

                    return(token);
                }
            }

            if (parser.CurrentToken.Type == HlTokenType.OpAnd)
            {
                HlTokenType t = parser.CurrentToken.Type;
                parser.Eat(t);
                HlExpression token = new HlUnaryOp(parser.ParseExpr(2), HlTokenType.OpReference);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpAsterisk)
            {
                HlTokenType t = parser.CurrentToken.Type;
                parser.Eat(t);
                HlExpression token = new HlUnaryOp(parser.ParseExpr(2), HlTokenType.OpDeReference);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpNew && maxPrecedence >= 3)
            {
                parser.Eat(parser.CurrentToken.Type);
                HlExpression token = new HlUnaryOp(parser.ParseExpr(2), HlTokenType.OpNew);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpReturn)
            {
                IHlToken rt = parser.CurrentToken;
                parser.Eat(HlTokenType.OpReturn);

                if (parser.CurrentToken.Type == HlTokenType.OpSemicolon)
                {
                    return(new HlReturnOp(null, rt.SourceIndex));
                }

                return(new HlReturnOp(parser.ParseExpr(), rt.SourceIndex));
            }

            if (parser.CurrentToken.Type == HlTokenType.OpContinue)
            {
                IHlToken ct = parser.CurrentToken;
                parser.Eat(HlTokenType.OpContinue);

                return(new HlContinueOp(ct.SourceIndex));
            }

            if (parser.CurrentToken.Type == HlTokenType.OpBreak)
            {
                IHlToken bt = parser.CurrentToken;
                parser.Eat(HlTokenType.OpBreak);

                return(new HlBreakOp(bt.SourceIndex));
            }

            if (parser.CurrentToken.Type == HlTokenType.OpIf)
            {
                return(HlSpecialOps.ReadIf(parser));
            }

            if (parser.CurrentToken.Type == HlTokenType.OpFor)
            {
                return(HlSpecialOps.ReadFor(parser));
            }

            if (parser.CurrentToken.Type == HlTokenType.OpWhile)
            {
                return(HlSpecialOps.ReadWhile(parser));
            }

            if (parser.CurrentToken.Type == HlTokenType.OpBracketOpen)
            {
                parser.Eat(HlTokenType.OpBracketOpen);
                HlExpression token = parser.ParseExpr();
                parser.Eat(HlTokenType.OpBracketClose);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpThis ||
                parser.CurrentToken.Type == HlTokenType.OpBase)
            {
                HlExpression token = new HlVarOperand(
                    parser.CurrentToken,
                    parser.CurrentToken.SourceIndex
                    );

                parser.Eat(parser.CurrentToken.Type);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpWord || parser.CurrentToken.Type == HlTokenType.OpNew)
            {
                IHlToken item = parser.CurrentToken;
                parser.Eat(parser.CurrentToken.Type);

                HlExpression token = new HlVarOperand(item, item.SourceIndex);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpVariableDefinition)
            {
                VariableDefinitionToken vd = ( VariableDefinitionToken )parser.CurrentToken;
                HlVarDefOperand         token;

                if (vd.InitializerExpression != null && vd.InitializerExpression.Length != 0)
                {
                    HlExpressionParser p =
                        HlExpressionParser.Create(new HlExpressionReader(vd.InitializerExpression.ToList()));

                    token =
                        new HlVarDefOperand(vd, p.Parse());
                }
                else
                {
                    token =
                        new HlVarDefOperand(vd, new HlExpression[0]);
                }

                parser.Eat(HlTokenType.OpVariableDefinition);

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpFunctionDefinition)
            {
                FunctionDefinitionToken fToken = ( FunctionDefinitionToken )parser.CurrentToken;
                parser.Eat(HlTokenType.OpFunctionDefinition);

                HlExpression[] expressionBlock = null;

                if (fToken.Mods.All(x => x.Type != HlTokenType.OpAbstractMod))
                {
                    expressionBlock = HlExpressionParser.Create(new HlExpressionReader(fToken.Block.ToList())).
                                      Parse();
                }

                HlExpression token =
                    new HlFuncDefOperand(
                        fToken,
                        expressionBlock
                        );

                return(token);
            }

            if (parser.CurrentToken.Type == HlTokenType.OpNumber ||
                parser.CurrentToken.Type == HlTokenType.OpDecimalNumber ||
                parser.CurrentToken.Type == HlTokenType.OpStringLiteral ||
                parser.CurrentToken.Type == HlTokenType.OpCharLiteral)
            {
                HlExpression token = new HlValueOperand(parser.CurrentToken);
                parser.Eat(parser.CurrentToken.Type);

                return(token);
            }

            EventManager <ErrorEvent> .SendEvent(new HlTokenReadEvent( HlTokenType.Any, parser.CurrentToken.Type ));

            return(null);
        }