public List<AsbtractCodeFragment> Parse(FileLine line, IMessageHandler messageHandler)
        {
            List<AsbtractCodeFragment> fragments = new List<AsbtractCodeFragment>();

            while (true) {
                var index = (line.BeginIndexNonSpace + 1); // Skip #

                // Find 'pragma'
                string preproDirective;
                index = this.MatchNextToken(line.Text, index, line.EndIndex, out preproDirective);
                if (index == -1) {
                    break;
                }
                if (string.Compare(preproDirective, "pragma") != 0) {
                    break;
                }

                // Find 'include'
                string pragmaName;
                index = this.MatchNextToken(line.Text, index, line.EndIndex, out pragmaName);
                if (index == -1) {
                    break;
                }
                if (string.Compare(pragmaName, "include") != 0) {
                    break;
                }

                // Find '"<Filename>"'
                var pragmaArgIndex = line.Text.IndexOf(index, line.EndIndex, ch => ch == '"');
                if (pragmaArgIndex == -1) {
                    break;
                }
                index = (pragmaArgIndex + 1);

                var pragmaArgEndIndex = BraceCounter.FindQuoteEnd(index, line.EndIndex, line.Text);
                if (pragmaArgEndIndex == -1) {
                    break;
                }
                index = (pragmaArgEndIndex + 1);

                string pragmaArgument = line.Text.Substring(pragmaArgIndex + 1, (pragmaArgEndIndex - pragmaArgIndex - 1));
                var textSpan = new TextSpan(line.BeginIndex, line.EndIndex, line.Text);
                fragments.Add(new OriginPragma(pragmaName, pragmaArgument, line, textSpan));

                break;
            }

            fragments.Add(new OriginScript(line, new TextSpan(line.BeginIndex, line.EndIndex, line.Text)));
            return fragments;
        }
        public List<AsbtractCodeFragment> Parse(FileLine line, IMessageHandler messageHandler)
        {
            List<AsbtractCodeFragment> fragments = new List<AsbtractCodeFragment>();

            var indexBeginIndent = (line.BeginIndexNonSpace + 1); //skip matched character
            var scriptBeginIndex = line.Text.IndexOfNot(indexBeginIndent, line.EndIndex, CharExtensions.IsSpace);
            if (scriptBeginIndex == -1) {
                return fragments;
            }

            fragments.Add(new TargetPushIndentation(line, new TextSpan(indexBeginIndent, scriptBeginIndex, line.Text)));
            fragments.Add(new OriginScript(line, new TextSpan(scriptBeginIndex, line.EndIndex, line.Text)));
            fragments.Add(new TargetPopIndentation(line, new TextSpan(indexBeginIndent, scriptBeginIndex, line.Text)));
            return fragments;
        }
        public List<AsbtractCodeFragment> Parse(FileLine line, IMessageHandler messageHandler)
        {
            List<AsbtractCodeFragment> fragments = new List<AsbtractCodeFragment>();

            var beginIndexIndent = (line.BeginIndexNonSpace + 1); //skip matched character
            var index = line.Text.IndexOfNot(beginIndexIndent, line.EndIndex, CharExtensions.IsSpace);
            if (index == -1) {
                index = line.EndIndex;
            }
            fragments.Add(new TargetIndentation(line, new TextSpan(beginIndexIndent, index, line.Text)));

            var endIndex = index;
            while (index < line.EndIndex) {
                index = line.Text.IndexOf(index, line.EndIndex, (ch) => ch == '#');
                if (index == -1) { // reached line end
                    break;
                }

                var expressionBeginIndex = index + 1; //skip #
                if (expressionBeginIndex == line.EndIndex) { // reached line end
                    break;
                }

                switch (line.Text[expressionBeginIndex]) {
                    case '#':
                        fragments.Add(new OriginText(line, new TextSpan(expressionBeginIndex, expressionBeginIndex + 1, line.Text)));
                        index = endIndex = expressionBeginIndex + 1;
                        continue;

                    case '{':
                        var expressionEndIndex = BraceCounter.MatchBraces(expressionBeginIndex, line.EndIndex, line.Text);
                        if (expressionEndIndex == -1) {
                            endIndex = line.EndIndex;
                            messageHandler.TemplateMessage(TraceLevel.Error, line.Position, "Missing a closing '}'.");
                            break;
                        }
                        fragments.Add(new OriginExpression(line, new TextSpan(expressionBeginIndex + 1, expressionEndIndex - 1, line.Text)));
                        index = endIndex = expressionEndIndex + 1;
                        continue;

                    default:
                        index = endIndex = expressionBeginIndex + 1;
                        continue;
                }
            }
            fragments.Add(new OriginText(line, new TextSpan(endIndex, line.EndIndex, line.Text)));
            return fragments;
        }
        public List<AsbtractCodeFragment> Parse(string sourceName, string text)
        {
            List<AsbtractCodeFragment> fragments = new List<AsbtractCodeFragment>();
            FileLine fileLine = new FileLine(text, 0, 0, 0, new TextFilePosition(sourceName, new TextPosition(0, 0)));

            while (fileLine.BeginIndex < text.Length) {
                ++fileLine.Position.Line;

                fileLine.BeginIndexNonSpace = text.IndexOfNot(fileLine.BeginIndex, text.Length, CharExtensions.IsSpace);
                if (fileLine.BeginIndexNonSpace == -1) {
                    fileLine.BeginIndexNonSpace = text.Length;
                }

                fileLine.EndIndex = text.IndexOf(fileLine.BeginIndexNonSpace, text.Length, CharExtensions.IsNewline);
                if (fileLine.EndIndex == -1) {
                    fileLine.EndIndex = text.Length;
                }

                IParserRule parserRule;
                List<AsbtractCodeFragment> ruleFragments;
                if (parseRules.TryGetValue(text[fileLine.EndIndex], out parserRule)) {
                    ruleFragments = parserRule.Parse(fileLine, messageHandler);
                }
                else {
                    ruleFragments = fallbackRule.Parse(fileLine, messageHandler);
                }
                fragments.AddRange(ruleFragments);

                if (fileLine.EndIndex == text.Length) {
                    break;
                }

                char complementaryNewLineChar = ((text[fileLine.EndIndex] == '\n') ? '\r' : '\n');
                fileLine.BeginIndex = text.IndexOfNot(fileLine.EndIndex + 1, text.Length, c => c == complementaryNewLineChar);
                if (fileLine.BeginIndex == -1) {
                    fileLine.BeginIndex = text.Length;
                }
            }
            return fragments;
        }
 public new List<AsbtractCodeFragment> Parse(FileLine line, IMessageHandler messageHandler)
 {
     List<AsbtractCodeFragment> fragments = base.Parse(line, messageHandler);
     fragments.Add(new TargetNewLine(line, new TextSpan(line.EndIndex, line.EndIndex, line.Text)));
     return fragments;
 }
 public List<AsbtractCodeFragment> Parse(FileLine line, IMessageHandler messageHandler)
 {
     List<AsbtractCodeFragment> fragments = new List<AsbtractCodeFragment>();
     fragments.Add(new OriginScript(line, new TextSpan(line.BeginIndex, line.EndIndex, line.Text)));
     return fragments;
 }