Разбор сложной строки в C #.

1

Я сейчас поддерживаю приложение, написанное на С#. Есть новая функция, которую мне нужно закодировать, и я ударил стену.

Я извлекаю данные из базы данных для другого приложения, написанного на VB6. Существует поле, в котором хранятся данные для списка деревьев. Мне нужно воссоздать это дерево в моем приложении. Данные выглядят так:

{
    {
        table1~col_b^table1~colc^= 
    }|
    {
        {
            table1~col_b^table2~col_b^=
        }|{
            table2~col_a^table3~cola^=
        }|AND
    }|OR
}

Я даже не знаю, с чего начать. Я должен это сделать. {} обозначает выражение, | отдельные выражения. в основном это дерево должно выглядеть так:

OR
-- table1~col_b^table1~colc^= 
-- AND
---- table1~col_b^table2~col_b^=
---- table2~col_a^table3~cola^=

Любая помощь или направление в решении этой проблемы было бы здорово!

Благодаря,

Doug

  • 0
    Если вы хотите начать, проверьте наличие REGEX
  • 4
    Начните с определения грамматики в деталях. Использование синтаксического анализатора на одной или нескольких выборочных строках приводит к большим несчастьям.
Показать ещё 1 комментарий
Теги:
vb6
parsing

3 ответа

3

Когда вы определите грамматику, я предлагаю вам посмотреть на Irony.net. Это позволяет легко писать парсеры. Образец.

И это грубая грамматика для вашего кода:

    [Language("ExpressionEvaluator", "1.0", "Multi-line expression evaluator")]
    public class ExpressionEvaluatorGrammar : Grammar
    {
        public ExpressionEvaluatorGrammar()
        {
            // 1. Terminals

            var identifier = new RegexBasedTerminal("identifier", "[a-z\\d_^~]+");


            // 2. Non-terminals
            var root = new NonTerminal("root");
            var block = new NonTerminal("block");
            var expression = new NonTerminal("expression");
            var expressions = new NonTerminal("expressions");

            var prop = new NonTerminal("prop");
            var op = new NonTerminal("op");

            // 3. BNF rules
            op.Rule = ToTerm("OR") | "AND";
            prop.Rule = identifier + "=" ;


            expression.Rule = "{" + (prop | block) + "}" + "|" ;
            expressions.Rule = MakeStarRule(expressions,  expression);
            block.Rule = expressions  + op;
            root.Rule = "{" + block +"}";

            Root = root;
            //automatically add NewLine before EOF so that our BNF rules work correctly when there no final line break in source
            this.LanguageFlags =  LanguageFlags.NewLineBeforeEOF;
        }
    }
} //namespace

Он разбирает все, все, что вам нужно сделать, это добавить дерево AST и использовать его.

Изображение 174551

Поделиться
0

Вы можете использовать regexp для tokenize и стек для рекурсивного анализа таким образом

        internal class Node
        {
            public string Terminal { get; set; }
            public List<Node> Operands { get; set; }
        }

        internal static readonly Regex TokensPattern = new Regex(@"(?<ws>\s+)|{\s*(?<value>[^\s}]+)\s*}|(?<token>OR|AND|.)", RegexOptions.Compiled);

        static Node parseData(string str)
        {
            // init stack
            var stack = new Stack<Node>();
            stack.Push(new Node() { Operands = new List<Node>() });
            // define parser
            var parser = new Dictionary<string, Action<string>>();
            parser.Add("{", _ => stack.Push(new Node() { Operands = new List<Node>() }));
            parser.Add("}", _ => { var top = stack.Pop(); stack.Peek().Operands.Add(top); });
            parser.Add("|", _ => { });
            parser.Add("AND", _ => stack.Peek().Terminal = "AND");
            parser.Add("OR", _ => stack.Peek().Terminal = "OR");
            parser.Add("", value => stack.Peek().Operands.Add(new Node { Terminal = value }));
            // execute parser
            TokensPattern.Matches(str).Cast<Match>()
                .Where(m => string.IsNullOrEmpty(m.Groups["ws"].Value))
                .Count(m => { parser[m.Groups["token"].Value](m.Groups["value"].Value); return false; });
            // return top of the tree
            return stack.Peek().Operands[0];
        }

        static void Main(string[] args)
        {
            const string str = @"{
    {
        table1~col_b^table1~colc^= 
    }|
    {
        {
            table1~col_b^table2~col_b^=
        }|{
            table2~col_a^table3~cola^=
        }|{cccc}|AND
    }|OR
}";            
            // print tree function
            Action<int, Node> dump = null;
            dump = new Action<int, Node>((level, node) =>
            {
                Console.WriteLine("{0}{1}", new string(' ', level * 2), node.Terminal);
                if (node.Operands != null)
                    node.Operands.ForEach(el => dump(level + 1, el));
            });
            dump(0, parseData(str));
        }
Поделиться
0

Без каких-либо дополнительных библиотек, это не слишком сложно разобрать это в дереве выражений в чистом коде С#:

class TreeNode
{
    private enum ParseState
    {
        Operator,
        Expression
    }
    public static TreeNode ParseTree(string treeData)
    {
        Stack<TreeNode> parsed = new Stack<TreeNode>();
        StringBuilder nodeData = new StringBuilder();
        ParseState state = ParseState.Operator;

        for (int charIndex = 0; charIndex < treeData.Length; charIndex++)
        {
            switch (treeData[charIndex])
            {
                case '{':
                    nodeData.Clear();
                    state = ParseState.Expression;
                    break;
                case '\t':
                case ' ':
                case '\r':
                case '\n':
                case '|':
                    // ignore whitespace and |
                    break;
                case '}':
                    {
                        if (state == ParseState.Expression)
                        {
                            state = ParseState.Operator;
                            parsed.Push(new TreeNodeData(nodeData.ToString()));
                        }
                        else // Operator
                        {
                            TreeNodeOperators op = (TreeNodeOperators)(Enum.Parse(typeof(TreeNodeOperators), nodeData.ToString()));
                            TreeNodeExpression exp = new TreeNodeExpression();
                            exp.Operator = op;
                            exp.Right = parsed.Pop();
                            exp.Left = parsed.Pop();
                            parsed.Push(exp);
                        }
                        nodeData.Clear();
                    }
                    break;
                default:
                    nodeData.Append(treeData[charIndex]);
                    break;
            }
        }
        return parsed.Pop();
    }
}

enum TreeNodeOperators
{
    AND,
    OR
}

class TreeNodeExpression : TreeNode
{
    public TreeNodeOperators Operator {get; set;}
    public TreeNode Left { get; set; }
    public TreeNode Right { get; set; }
}

class TreeNodeData : TreeNode
{
    public string Data {get; set;}
    public TreeNodeData(string data)
    {
        Data = data;
    }
}
Поделиться
  • 0
    Вы предполагаете, что AND / OR являются бинарными операторами, что, скорее всего, не так.
  • 0
    Да, этот код делает некоторые допущения, основанные на доступной ограниченной информации, но его было бы несложно откорректировать для учета случаев, которые не соответствуют этим допущениям.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню