Exemple #1
0
        private void PushBlock(string tag, string markup)
        {
            Condition block;

            if (tag == "else")
            {
                block = new ElseCondition();
            }
            else
            {
                List <string> expressions = R.Scan(markup, ExpressionsAndOperatorsRegex);

                // last item in list
                string syntax = expressions.TryGetAtIndexReverse(0);

                if (string.IsNullOrEmpty(syntax))
                {
                    throw new SyntaxException(SyntaxHelp);
                }
                Match syntaxMatch = Syntax.Match(syntax);
                if (!syntaxMatch.Success)
                {
                    throw new SyntaxException(SyntaxHelp);
                }

                Condition condition = new Condition(syntaxMatch.Groups[1].Value,
                                                    syntaxMatch.Groups[2].Value, syntaxMatch.Groups[3].Value);

                // continue to process remaining items in the list backwards, in pairs
                for (int i = 1; i < expressions.Count; i = i + 2)
                {
                    string @operator = expressions.TryGetAtIndexReverse(i).Trim();

                    Match expressionMatch = Syntax.Match(expressions.TryGetAtIndexReverse(i + 1));
                    if (!expressionMatch.Success)
                    {
                        throw new SyntaxException(SyntaxHelp);
                    }

                    Condition newCondition = new Condition(expressionMatch.Groups[1].Value,
                                                           expressionMatch.Groups[2].Value, expressionMatch.Groups[3].Value);
                    switch (@operator)
                    {
                    case "and":
                        newCondition.And(condition);
                        break;

                    case "or":
                        newCondition.Or(condition);
                        break;
                    }
                    condition = newCondition;
                }
                block = condition;
            }

            Blocks.Add(block);
            NodeList = block.Attach(new List <object>());
        }
Exemple #2
0
        private void RecordElseCondition(string markup)
        {
            if (markup.Trim() != string.Empty)
                throw new SyntaxException("Syntax Error in tag 'case' - Valid else condition: {{% else %}} (no parameters)");

            ElseCondition block = new ElseCondition();
            block.Attach(NodeList);
            _blocks.Add(block);
        }
Exemple #3
0
        private void RecordElseCondition(string markup)
        {
            if (markup.Trim() != string.Empty)
                throw new SyntaxException(Liquid.ResourceManager.GetString("CaseTagElseSyntaxException"));

            ElseCondition block = new ElseCondition();
            block.Attach(NodeList);
            _blocks.Add(block);
        }
Exemple #4
0
        private void PushBlock(string tag, string markup)
        {
            Condition block;

            if (tag == "else")
            {
                block = new ElseCondition();
            }
            else
            {
                List <string> expressions = R.Scan(markup, ExpressionsAndOperators);
                expressions.Reverse();
                string syntax = expressions.Shift();
                if (string.IsNullOrEmpty(syntax))
                {
                    throw new SyntaxException(SyntaxHelp);
                }
                Match syntaxMatch = Syntax.Match(syntax);
                if (!syntaxMatch.Success)
                {
                    throw new SyntaxException(SyntaxHelp);
                }

                Condition condition = new Condition(syntaxMatch.Groups[1].Value,
                                                    syntaxMatch.Groups[2].Value, syntaxMatch.Groups[3].Value);

                while (expressions.Any())
                {
                    string @operator = expressions.Shift().Trim();

                    Match expressionMatch = Syntax.Match(expressions.Shift());
                    if (!expressionMatch.Success)
                    {
                        throw new SyntaxException(SyntaxHelp);
                    }

                    Condition newCondition = new Condition(expressionMatch.Groups[1].Value,
                                                           expressionMatch.Groups[2].Value, expressionMatch.Groups[3].Value);
                    switch (@operator)
                    {
                    case "and":
                        newCondition.And(condition);
                        break;

                    case "or":
                        newCondition.Or(condition);
                        break;
                    }
                    condition = newCondition;
                }
                block = condition;
            }

            Blocks.Add(block);
            NodeList = block.Attach(new List <object>());
        }
Exemple #5
0
        private void RecordElseCondition(string markup)
        {
            if (markup.Trim() != string.Empty)
            {
                throw new SyntaxException(Liquid.ResourceManager.GetString("CaseTagElseSyntaxException"));
            }

            var block = new ElseCondition();

            block.Attach(NodeList);
            _blocks.Add(block);
        }
Exemple #6
0
        private void PushBlock(string tag, string markup)
        {
            Condition block;
            if (tag == "else")
            {
                block = new ElseCondition();
            }
            else
            {
                List<string> expressions = R.Scan(markup, ExpressionsAndOperatorsRegex);

                // last item in list
                string syntax = expressions.TryGetAtIndexReverse(0);

                if (string.IsNullOrEmpty(syntax))
                    throw new SyntaxException(SyntaxHelp);
                Match syntaxMatch = Syntax.Match(syntax);
                if (!syntaxMatch.Success)
                    throw new SyntaxException(SyntaxHelp);

                Condition condition = new Condition(syntaxMatch.Groups[1].Value,
                    syntaxMatch.Groups[2].Value, syntaxMatch.Groups[3].Value);

                // continue to process remaining items in the list backwards, in pairs
                for (int i = 1; i < expressions.Count; i = i + 2)
                {
                    string @operator = expressions.TryGetAtIndexReverse(i).Trim();

                    Match expressionMatch = Syntax.Match(expressions.TryGetAtIndexReverse(i + 1));
                    if (!expressionMatch.Success)
                        throw new SyntaxException(SyntaxHelp);

                    Condition newCondition = new Condition(expressionMatch.Groups[1].Value,
                        expressionMatch.Groups[2].Value, expressionMatch.Groups[3].Value);
                    switch (@operator)
                    {
                        case "and":
                            newCondition.And(condition);
                            break;
                        case "or":
                            newCondition.Or(condition);
                            break;
                    }
                    condition = newCondition;
                }
                block = condition;
            }

            Blocks.Add(block);
            NodeList = block.Attach(new List<object>());
        }
Exemple #7
0
        private void PushBlock(string tag, string markup)
        {
            Condition block;
            if (tag == "else")
            {
                block = new ElseCondition();
            }
            else
            {
                List<string> expressions = R.Scan(markup, ExpressionsAndOperators);
                expressions.Reverse();
                string syntax = expressions.Shift();
                if (string.IsNullOrEmpty(syntax))
                    throw new SyntaxException(SyntaxHelp);
                Match syntaxMatch = Syntax.Match(syntax);
                if (!syntaxMatch.Success)
                    throw new SyntaxException(SyntaxHelp);

                Condition condition = new Condition(syntaxMatch.Groups[1].Value,
                    syntaxMatch.Groups[2].Value, syntaxMatch.Groups[3].Value);

                while (expressions.Any())
                {
                    string @operator = expressions.Shift().Trim();

                    Match expressionMatch = Syntax.Match(expressions.Shift());
                    if (!expressionMatch.Success)
                        throw new SyntaxException(SyntaxHelp);

                    Condition newCondition = new Condition(expressionMatch.Groups[1].Value,
                        expressionMatch.Groups[2].Value, expressionMatch.Groups[3].Value);
                    switch (@operator)
                    {
                        case "and":
                            newCondition.And(condition);
                            break;
                        case "or":
                            newCondition.Or(condition);
                            break;
                    }
                    condition = newCondition;
                }
                block = condition;
            }

            Blocks.Add(block);
            NodeList = block.Attach(new List<object>());
        }
Exemple #8
0
            private static IToken BuildCodeElementFromType(CodeElementType type, Token lastTokenBeforeError, string informationText)
            {
                CodeElement codeElement = null;

                switch (type)
                {
                case CodeElementType.ProgramIdentification:
                    codeElement = new ProgramIdentification();
                    break;

                case CodeElementType.ProgramEnd:
                    codeElement = new ProgramEnd();
                    break;

                case CodeElementType.ClassIdentification:
                    codeElement = new ClassIdentification();
                    break;

                case CodeElementType.ClassEnd:
                    codeElement = new ClassEnd();
                    break;

                case CodeElementType.FactoryIdentification:
                    codeElement = new FactoryIdentification();
                    break;

                case CodeElementType.FactoryEnd:
                    codeElement = new FactoryEnd();
                    break;

                case CodeElementType.ObjectIdentification:
                    codeElement = new ObjectIdentification();
                    break;

                case CodeElementType.ObjectEnd:
                    codeElement = new ObjectEnd();
                    break;

                case CodeElementType.MethodIdentification:
                    codeElement = new MethodIdentification();
                    break;

                case CodeElementType.MethodEnd:
                    codeElement = new MethodEnd();
                    break;

                case CodeElementType.EnvironmentDivisionHeader:
                    codeElement = new EnvironmentDivisionHeader();
                    break;

                case CodeElementType.DataDivisionHeader:
                    codeElement = new DataDivisionHeader();
                    break;

                case CodeElementType.ProcedureDivisionHeader:
                    codeElement = new ProcedureDivisionHeader();
                    break;

                case CodeElementType.DeclarativesHeader:
                    codeElement = new DeclarativesHeader();
                    break;

                case CodeElementType.DeclarativesEnd:
                    codeElement = new DeclarativesEnd();
                    break;

                case CodeElementType.SectionHeader:
                    codeElement = new SectionHeader();
                    break;

                case CodeElementType.ConfigurationSectionHeader:
                    codeElement = new ConfigurationSectionHeader();
                    break;

                case CodeElementType.InputOutputSectionHeader:
                    codeElement = new InputOutputSectionHeader();
                    break;

                case CodeElementType.FileSectionHeader:
                    codeElement = new FileSectionHeader();
                    break;

                case CodeElementType.WorkingStorageSectionHeader:
                    codeElement = new WorkingStorageSectionHeader();
                    break;

                case CodeElementType.LocalStorageSectionHeader:
                    codeElement = new LocalStorageSectionHeader();
                    break;

                case CodeElementType.LinkageSectionHeader:
                    codeElement = new LinkageSectionHeader();
                    break;

                case CodeElementType.ParagraphHeader:
                    codeElement = new ParagraphHeader();
                    break;

                case CodeElementType.FileControlParagraphHeader:
                    codeElement = new FileControlParagraphHeader();
                    break;

                case CodeElementType.IOControlParagraphHeader:
                    codeElement = new IOControlParagraphHeader();
                    break;

                case CodeElementType.SentenceEnd:
                    codeElement = new SentenceEnd();
                    break;

                case CodeElementType.FileDescriptionEntry:
                    codeElement = new FileDescriptionEntry();
                    break;

                case CodeElementType.DataDescriptionEntry:
                    codeElement = new DataDescriptionEntry();
                    break;

                case CodeElementType.DataRedefinesEntry:
                    codeElement = new DataRedefinesEntry();
                    break;

                case CodeElementType.DataRenamesEntry:
                    codeElement = new DataRenamesEntry();
                    break;

                case CodeElementType.DataConditionEntry:
                    codeElement = new DataConditionEntry();
                    break;

                case CodeElementType.FileControlEntry:
                    codeElement = new FileControlEntry();
                    break;

                case CodeElementType.IOControlEntry:
                    codeElement = new RerunIOControlEntry();
                    break;

                case CodeElementType.SourceComputerParagraph:
                    codeElement = new SourceComputerParagraph();
                    break;

                case CodeElementType.ObjectComputerParagraph:
                    codeElement = new ObjectComputerParagraph();
                    break;

                case CodeElementType.SpecialNamesParagraph:
                    codeElement = new SpecialNamesParagraph();
                    break;

                case CodeElementType.RepositoryParagraph:
                    codeElement = new RepositoryParagraph();
                    break;

                case CodeElementType.AcceptStatement:
                    codeElement = new AcceptFromInputDeviceStatement();
                    break;

                case CodeElementType.AddStatement:
                    codeElement = new AddSimpleStatement();
                    break;

                case CodeElementType.AlterStatement:
                    codeElement = new AlterStatement();
                    break;

                case CodeElementType.CallStatement:
                    codeElement = new CallStatement();
                    break;

                case CodeElementType.CancelStatement:
                    codeElement = new CancelStatement();
                    break;

                case CodeElementType.CloseStatement:
                    codeElement = new CloseStatement();
                    break;

                case CodeElementType.ComputeStatement:
                    codeElement = new ComputeStatement();
                    break;

                case CodeElementType.ContinueStatement:
                    codeElement = new ContinueStatement();
                    break;

                case CodeElementType.DeleteStatement:
                    codeElement = new DeleteStatement();
                    break;

                case CodeElementType.DisplayStatement:
                    codeElement = new DisplayStatement();
                    break;

                case CodeElementType.DivideStatement:
                    codeElement = new DivideSimpleStatement();
                    break;

                case CodeElementType.EntryStatement:
                    codeElement = new EntryStatement();
                    break;

                case CodeElementType.EvaluateStatement:
                    codeElement = new EvaluateStatement();
                    break;

                case CodeElementType.ExecStatement:
                    codeElement = new ExecStatement();
                    break;

                case CodeElementType.ExitMethodStatement:
                    codeElement = new ExitMethodStatement();
                    break;

                case CodeElementType.ExitProgramStatement:
                    codeElement = new ExitProgramStatement();
                    break;

                case CodeElementType.ExitStatement:
                    codeElement = new ExitStatement();
                    break;

                case CodeElementType.GobackStatement:
                    codeElement = new GobackStatement();
                    break;

                case CodeElementType.GotoStatement:
                    codeElement = new GotoSimpleStatement();
                    break;

                case CodeElementType.IfStatement:
                    codeElement = new IfStatement();
                    break;

                case CodeElementType.InitializeStatement:
                    codeElement = new InitializeStatement();
                    break;

                case CodeElementType.InspectStatement:
                    codeElement = new InspectTallyingStatement();
                    break;

                case CodeElementType.InvokeStatement:
                    codeElement = new InvokeStatement();
                    break;

                case CodeElementType.MergeStatement:
                    codeElement = new MergeStatement();
                    break;

                case CodeElementType.MoveStatement:
                    codeElement = new MoveSimpleStatement(null, null, null);
                    break;

                case CodeElementType.MultiplyStatement:
                    codeElement = new MultiplySimpleStatement();
                    break;

                case CodeElementType.NextSentenceStatement:
                    codeElement = new NextSentenceStatement();
                    break;

                case CodeElementType.OpenStatement:
                    codeElement = new OpenStatement();
                    break;

                case CodeElementType.PerformProcedureStatement:
                    codeElement = new PerformProcedureStatement();
                    break;

                case CodeElementType.PerformStatement:
                    codeElement = new PerformStatement();
                    break;

                case CodeElementType.ReadStatement:
                    codeElement = new ReadStatement();
                    break;

                case CodeElementType.ReleaseStatement:
                    codeElement = new ReleaseStatement();
                    break;

                case CodeElementType.ReturnStatement:
                    codeElement = new ReturnStatement();
                    break;

                case CodeElementType.RewriteStatement:
                    codeElement = new RewriteStatement();
                    break;

                case CodeElementType.SearchStatement:
                    codeElement = new SearchSerialStatement();
                    break;

                case CodeElementType.SetStatement:
                    codeElement = new SetStatementForAssignment();
                    break;

                case CodeElementType.SortStatement:
                    codeElement = new SortStatement();
                    break;

                case CodeElementType.StartStatement:
                    codeElement = new StartStatement();
                    break;

                case CodeElementType.StopStatement:
                    codeElement = new StopStatement();
                    break;

                case CodeElementType.StringStatement:
                    codeElement = new StringStatement();
                    break;

                case CodeElementType.SubtractStatement:
                    codeElement = new SubtractSimpleStatement();
                    break;

                case CodeElementType.UnstringStatement:
                    codeElement = new UnstringStatement();
                    break;

                case CodeElementType.UseStatement:
                    codeElement = new UseAfterIOExceptionStatement();
                    break;

                case CodeElementType.WriteStatement:
                    codeElement = new WriteStatement();
                    break;

                case CodeElementType.XmlGenerateStatement:
                    codeElement = new XmlGenerateStatement();
                    break;

                case CodeElementType.XmlParseStatement:
                    codeElement = new XmlParseStatement();
                    break;

                case CodeElementType.AtEndCondition:
                    codeElement = new AtEndCondition();
                    break;

                case CodeElementType.NotAtEndCondition:
                    codeElement = new NotAtEndCondition();
                    break;

                case CodeElementType.AtEndOfPageCondition:
                    codeElement = new AtEndOfPageCondition();
                    break;

                case CodeElementType.NotAtEndOfPageCondition:
                    codeElement = new NotAtEndOfPageCondition();
                    break;

                case CodeElementType.OnExceptionCondition:
                    codeElement = new OnExceptionCondition();
                    break;

                case CodeElementType.NotOnExceptionCondition:
                    codeElement = new NotOnExceptionCondition();
                    break;

                case CodeElementType.OnOverflowCondition:
                    codeElement = new OnOverflowCondition();
                    break;

                case CodeElementType.NotOnOverflowCondition:
                    codeElement = new NotOnOverflowCondition();
                    break;

                case CodeElementType.InvalidKeyCondition:
                    codeElement = new InvalidKeyCondition();
                    break;

                case CodeElementType.NotInvalidKeyCondition:
                    codeElement = new NotInvalidKeyCondition();
                    break;

                case CodeElementType.OnSizeErrorCondition:
                    codeElement = new OnSizeErrorCondition();
                    break;

                case CodeElementType.NotOnSizeErrorCondition:
                    codeElement = new NotOnSizeErrorCondition();
                    break;

                case CodeElementType.ElseCondition:
                    codeElement = new ElseCondition();
                    break;

                case CodeElementType.WhenCondition:
                    codeElement = new WhenCondition();
                    break;

                case CodeElementType.WhenOtherCondition:
                    codeElement = new WhenOtherCondition();
                    break;

                case CodeElementType.WhenSearchCondition:
                    codeElement = new WhenSearchCondition();
                    break;

                case CodeElementType.AddStatementEnd:
                    codeElement = new AddStatementEnd();
                    break;

                case CodeElementType.CallStatementEnd:
                    codeElement = new CallStatementEnd();
                    break;

                case CodeElementType.ComputeStatementEnd:
                    codeElement = new ComputeStatementEnd();
                    break;

                case CodeElementType.DeleteStatementEnd:
                    codeElement = new DeleteStatementEnd();
                    break;

                case CodeElementType.DivideStatementEnd:
                    codeElement = new DivideStatementEnd();
                    break;

                case CodeElementType.EvaluateStatementEnd:
                    codeElement = new EvaluateStatementEnd();
                    break;

                case CodeElementType.IfStatementEnd:
                    codeElement = new IfStatementEnd();
                    break;

                case CodeElementType.InvokeStatementEnd:
                    codeElement = new InvokeStatementEnd();
                    break;

                case CodeElementType.MultiplyStatementEnd:
                    codeElement = new MultiplyStatementEnd();
                    break;

                case CodeElementType.PerformStatementEnd:
                    codeElement = new PerformStatementEnd();
                    break;

                case CodeElementType.ReadStatementEnd:
                    codeElement = new ReadStatementEnd();
                    break;

                case CodeElementType.ReturnStatementEnd:
                    codeElement = new ReturnStatementEnd();
                    break;

                case CodeElementType.RewriteStatementEnd:
                    codeElement = new RewriteStatementEnd();
                    break;

                case CodeElementType.SearchStatementEnd:
                    codeElement = new SearchStatementEnd();
                    break;

                case CodeElementType.StartStatementEnd:
                    codeElement = new StartStatementEnd();
                    break;

                case CodeElementType.StringStatementEnd:
                    codeElement = new StringStatementEnd();
                    break;

                case CodeElementType.SubtractStatementEnd:
                    codeElement = new SubtractStatementEnd();
                    break;

                case CodeElementType.UnstringStatementEnd:
                    codeElement = new UnstringStatementEnd();
                    break;

                case CodeElementType.WriteStatementEnd:
                    codeElement = new WriteStatementEnd();
                    break;

                case CodeElementType.XmlStatementEnd:
                    codeElement = new XmlStatementEnd();
                    break;

                case CodeElementType.LibraryCopy:
                    codeElement = new LibraryCopyCodeElement();
                    break;

                case CodeElementType.FunctionDeclarationHeader:
                    codeElement = new FunctionDeclarationHeader(null, AccessModifier.Private, FunctionType.Undefined);
                    break;

                case CodeElementType.FunctionDeclarationEnd:
                    codeElement = new FunctionDeclarationEnd();
                    break;

                default:
                    throw new NotImplementedException();
                }
                if (lastTokenBeforeError != null)
                {
                    var missingToken = new MissingToken(TokenType.InvalidToken, informationText, lastTokenBeforeError.TokensLine, lastTokenBeforeError.StopIndex);
                    codeElement.ConsumedTokens.Add(missingToken);
                }
                return(codeElement);
            }
Exemple #9
0
        private void PushBlock(string tag, string markup)
        {
            Condition block;

            if (tag == "else")
            {
                block = new ElseCondition();
            }
            else
            {
                var expressions = R.Scan(markup, s_expressionsAndOperatorsRegex);

                // last item in list
                var syntax = expressions.TryGetAtIndexReverse(0);

                if (string.IsNullOrEmpty(syntax))
                {
                    throw new SyntaxException(_syntaxHelp);
                }

                var syntaxMatch = s_syntax.Match(syntax);
                if (!syntaxMatch.Success)
                {
                    throw new SyntaxException(_syntaxHelp);
                }

                var condition = new Condition(syntaxMatch.Groups[1].Value,
                                              syntaxMatch.Groups[2].Value, syntaxMatch.Groups[3].Value);

                var conditionCount = 1;
                // continue to process remaining items in the list backwards, in pairs
                for (var i = 1; i < expressions.Count; i += 2)
                {
                    var @operator = expressions.TryGetAtIndexReverse(i).Trim();

                    var expressionMatch = s_syntax.Match(expressions.TryGetAtIndexReverse(i + 1));
                    if (!expressionMatch.Success)
                    {
                        throw new SyntaxException(_syntaxHelp);
                    }

                    if (++conditionCount > 500)
                    {
                        throw new SyntaxException(_tooMuchConditionsHelp);
                    }

                    var newCondition = new Condition(expressionMatch.Groups[1].Value,
                                                     expressionMatch.Groups[2].Value, expressionMatch.Groups[3].Value);
                    switch (@operator)
                    {
                    case "and":
                        newCondition.And(condition);
                        break;

                    case "or":
                        newCondition.Or(condition);
                        break;
                    }
                    condition = newCondition;
                }
                block = condition;
            }

            Blocks.Add(block);
        }