Exemplo n.º 1
0
        public static KirinWhileLoop ParseNodes(
            KirinWhileLoop startNode,
            KirinNode[] nodes,
            KirinLoopEnd endNode,
            string content)
        {
            var statement = startNode;

            if (endNode != null)
            {
                statement.Length    = (endNode.Start + endNode.Length) - startNode.Start;
                statement.Statement = FiMLexer.ParseStatement(nodes, content);
            }

            return(statement);
        }
Exemplo n.º 2
0
        public static KirinIfStatement ParseNodes(
            KirinIfStatementStart startNode,
            KirinNode[] nodes,
            KirinIfStatementEnd endNode,
            string content)
        {
            var statement = new KirinIfStatement(-1, -1);

            string           currentCondition = startNode.RawCondition;
            KirinNode        conditionNode    = startNode;
            List <KirinNode> subStatement     = new List <KirinNode>();

            foreach (var subnode in nodes)
            {
                if (subnode.NodeType != "KirinElseIfStatement")
                {
                    subStatement.Add(subnode);
                }
                else
                {
                    var conditionStatement = FiMLexer.ParseStatement(subStatement.ToArray(), content);
                    try
                    {
                        statement.AddCondition(currentCondition, conditionStatement);
                    }
                    catch (FiMException ex)
                    {
                        throw new Exception(ex.Message + " at line " +
                                            FiMHelper.GetIndexPair(content, conditionNode.Start).Line);
                    }


                    var elseIfNode = subnode as KirinElseIfStatement;
                    currentCondition = elseIfNode.RawCondition;
                    conditionNode    = subnode;

                    subStatement.Clear();
                }
            }

            if (subStatement.Count > 0)
            {
                var conditionStatement = FiMLexer.ParseStatement(subStatement.ToArray(), content);
                try
                {
                    statement.AddCondition(currentCondition, conditionStatement);
                }
                catch (FiMException ex)
                {
                    throw new Exception(ex.Message + " at line " +
                                        FiMHelper.GetIndexPair(content, conditionNode.Start).Line);
                }
            }

            statement.SetComplete(startNode.Start, endNode.Start + endNode.Length);

            if (statement.Count == 0)
            {
                throw new FiMException("If Statement has empty conditions");
            }

            return(statement);
        }
Exemplo n.º 3
0
        public static KirinSwitch ParseNodes(
            KirinSwitchStart startNode,
            KirinNode[] nodes,
            KirinLoopEnd endNode,
            string content)
        {
            var statement = new KirinSwitch(-1, -1);

            statement.RawVariable = startNode.RawVariable;
            statement.Start       = startNode.Start;
            statement.Length      = (endNode.Start + endNode.Length) - startNode.Start;

            string           currentCase  = string.Empty;
            bool             isDefault    = false;
            List <KirinNode> subStatement = new List <KirinNode>();

            foreach (var subnode in nodes)
            {
                if (subnode.NodeType == "KirinSwitchCase")
                {
                    if (subStatement.Count > 0)
                    {
                        var s = FiMLexer.ParseStatement(subStatement.ToArray(), content);
                        if (currentCase != string.Empty)
                        {
                            statement.AddCase(s, currentCase);
                        }
                        else if (isDefault)
                        {
                            statement.AddCase(s);
                        }
                        subStatement.Clear();
                    }

                    var cNode = subnode as KirinSwitchCase;
                    currentCase = cNode.RawCase;
                    isDefault   = false;
                }
                else if (subnode.NodeType == "KirinSwitchCaseDefault")
                {
                    if (subStatement.Count > 0)
                    {
                        var s = FiMLexer.ParseStatement(subStatement.ToArray(), content);
                        if (currentCase != string.Empty)
                        {
                            statement.AddCase(s, currentCase);
                        }
                        else if (isDefault)
                        {
                            statement.AddCase(s);
                        }
                        subStatement.Clear();
                    }

                    currentCase = string.Empty;
                    isDefault   = true;
                }
                else
                {
                    if (currentCase == string.Empty && !isDefault)
                    {
                        throw new FiMException("Switch case not found");
                    }

                    subStatement.Add(subnode);
                }
            }

            if (subStatement.Count > 0)
            {
                var s = FiMLexer.ParseStatement(subStatement.ToArray(), content);
                if (currentCase != string.Empty)
                {
                    statement.AddCase(s, currentCase);
                }
                else if (isDefault)
                {
                    statement.AddCase(s);
                }
                subStatement.Clear();
            }

            return(statement);
        }