/****************************************************************************
|
**
|
** Copyright (C) 2019 The Qt Company Ltd.
|
** Contact: https://www.qt.io/licensing/
|
**
|
** This file is part of the Qt VS Tools.
|
**
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
** Commercial License Usage
|
** Licensees holding valid commercial Qt licenses may use this file in
|
** accordance with the commercial license agreement provided with the
|
** Software or, alternatively, in accordance with the terms contained in
|
** a written agreement between you and The Qt Company. For licensing terms
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
** information use the contact form at https://www.qt.io/contact-us.
|
**
|
** GNU General Public License Usage
|
** Alternatively, this file may be used under the terms of the GNU
|
** General Public License version 3 as published by the Free Software
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
** included in the packaging of this file. Please review the following
|
** information to ensure the GNU General Public License requirements will
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
**
|
** $QT_END_LICENSE$
|
**
|
****************************************************************************/
|
|
using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Text.RegularExpressions;
|
|
namespace QtVsTools.SyntaxAnalysis
|
{
|
public abstract partial class RegExpr
|
{
|
////////////////////////////////////////////////////////////////////////////////////////////
|
///
|
/// RegExpr.ParseTree
|
///
|
////////////////////////////////////////////////////////////////////////////////////////////
|
/// <summary>
|
/// Result of processing input text with a pattern rendered from a RegExpr.
|
/// </summary>
|
/// <remarks>
|
/// Nodes in a ParseTree correspond to captured tokens. The parent-child relationship
|
/// between nodes reflects token embedding.
|
/// </remarks>
|
public class ParseTree
|
{
|
public Node Root { get; set; }
|
public const string KeyRoot = "0";
|
|
public class Node : IOperatorCapture, IOperandCapture
|
{
|
public string CaptureId { get; set; }
|
public string Value { get; set; }
|
public int Begin { get; set; }
|
public int End { get; set; }
|
public int GroupIdx { get; set; }
|
public int CaptureIdx { get; set; }
|
|
class NodeComparer : IComparer<Node>
|
{
|
public int Compare(Node x, Node y)
|
{
|
return Comparer<int>.Default.Compare(x.Begin, y.Begin);
|
}
|
}
|
|
static NodeComparer _Comparer = new NodeComparer();
|
public static IComparer<Node> Comparer { get { return _Comparer; } }
|
|
public Token Token { get; set; }
|
public string TokenId { get { return Token.Id; } }
|
|
public object Production { get; set; }
|
|
public Node Parent { get; set; }
|
|
SortedList<int, Node> _ChildNodes = new SortedList<int, Node>();
|
public SortedList<int, Node> ChildNodes { get { return _ChildNodes; } }
|
|
ProductionObjects _ChildProductions = new ProductionObjects();
|
public ProductionObjects ChildProductions { get { return _ChildProductions; } }
|
|
public Queue<Node> TokenStream { get; set; }
|
public Stack<Node> OperatorStack { get; set; }
|
public Stack<Node> OperandStack { get; set; }
|
|
IProductionRule _Rule = null;
|
public IProductionRule Rule
|
{
|
get
|
{
|
if (_Rule == null)
|
_Rule = Token.SelectRule(this);
|
return _Rule;
|
}
|
}
|
|
public string Key
|
{
|
get
|
{
|
if (CaptureId == KeyRoot)
|
return KeyRoot;
|
return string.Format("{0}:{1}:{2}", CaptureId, Begin, End);
|
}
|
}
|
|
public override string ToString()
|
{
|
return string.Format("{0}[{1}]", TokenId, Value);
|
}
|
|
public static implicit operator ParseTree(Node node)
|
{
|
return new ParseTree { Root = node };
|
}
|
|
int SiblingIdx
|
{
|
get
|
{
|
if (Parent == null)
|
return 0;
|
return Parent.ChildNodes.IndexOfKey(Begin);
|
}
|
}
|
|
int SiblingCount
|
{
|
get
|
{
|
if (Parent == null)
|
return 1;
|
return Parent.ChildNodes.Count;
|
}
|
}
|
|
public bool IsFirst { get { return SiblingIdx == 0; } }
|
|
public bool IsLast { get { return SiblingIdx == SiblingCount - 1; } }
|
|
public IEnumerable<ITokenCapture> LookAhead(params TokenGroup[] ids)
|
{
|
if (Parent == null)
|
return Empty<ITokenCapture>();
|
var lookAhead = Parent.ChildNodes.Values
|
.Skip(SiblingIdx + 1);
|
if (ids.Any())
|
lookAhead = lookAhead.Where(x => ids.Any(g => g.Contains(x.TokenId)));
|
return lookAhead.Cast<ITokenCapture>().Concat(Items(EndOfList));
|
}
|
|
public IEnumerable<ITokenCapture> LookBehind(params TokenGroup[] ids)
|
{
|
if (Parent == null)
|
return Empty<ITokenCapture>();
|
var lookBehind = Parent.ChildNodes.Values
|
.Take(SiblingIdx)
|
.Reverse();
|
if (ids.Any())
|
lookBehind = lookBehind.Where(x => ids.Any(g => g.Contains(x.TokenId)));
|
return lookBehind.Cast<ITokenCapture>().Concat(Items(EndOfList));
|
}
|
|
public bool Is(params TokenGroup[] tokenIds)
|
{
|
return tokenIds.Any(g => g.Contains(TokenId));
|
}
|
|
public bool IsNot(params TokenGroup[] tokenIds)
|
{
|
return !tokenIds.Any(g => g.Contains(TokenId));
|
}
|
|
public IOperandCapture Operand
|
{
|
get
|
{
|
if (Parent == null)
|
return EndOfList;
|
if (Parent.OperandStack == null)
|
return EndOfList;
|
if (!Parent.OperandStack.Any())
|
return EndOfList;
|
return Parent.OperandStack.Peek();
|
}
|
}
|
|
public IOperandCapture LeftOperand
|
{
|
get
|
{
|
if (Parent == null)
|
return EndOfList;
|
if (Parent.OperandStack == null)
|
return EndOfList;
|
if (Parent.OperandStack.Count() < 2)
|
return EndOfList;
|
return Parent.OperandStack.Skip(1).First();
|
}
|
}
|
|
public IOperandCapture RightOperand
|
{
|
get
|
{
|
if (Parent == null)
|
return EndOfList;
|
if (Parent.OperandStack == null)
|
return EndOfList;
|
if (Parent.OperandStack.Count() < 2)
|
return EndOfList;
|
return Parent.OperandStack.Peek();
|
}
|
}
|
|
public bool HasOperand
|
{
|
get { return Operand != EndOfList; }
|
}
|
|
public bool HasLeftOperand
|
{
|
get { return LeftOperand != EndOfList; }
|
}
|
|
public bool HasRightOperand
|
{
|
get { return RightOperand != EndOfList; }
|
}
|
}
|
}
|
}
|
}
|
