/****************************************************************************
|
**
|
** 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.Diagnostics;
|
using System.Linq;
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
namespace QtVsTools.Test.RegExpr
|
{
|
using static SyntaxAnalysis.RegExpr;
|
|
[TestClass]
|
public class Test_XmlIntParser
|
{
|
public const string IdNum = "NUM";
|
public const string IdExpr = "EXPR";
|
public const string IdExprLPar = "EXPR_LPAR";
|
public const string IdTagValue = "TAG_VALUE";
|
public const string IdTagBegin = "TAG_BEGIN";
|
public const string IdTagName = "TAG_NAME";
|
public const string IdTag = "TAG";
|
|
public static Parser GetParser()
|
{
|
// XML chars
|
var charLt = Char['<'];
|
var charGt = Char['>'];
|
var charSlash = Char['/'];
|
|
// int expr chars
|
var charPlus = Char['+'];
|
var charMinus = Char['-'];
|
var charMult = Char['*'];
|
var charDiv = Char['/'];
|
var charLPar = Char['('];
|
var charRPar = Char[')'];
|
var charDigit = Char['0', '9'];
|
var charAddtOper = CharSet[charPlus + charMinus];
|
var charMultOper = CharSet[charMult + charDiv];
|
var charOper = CharSet[charAddtOper + charMultOper];
|
|
// int operator priorities
|
int priorityInfixAddt = 10;
|
int priorityInfixMult = 20;
|
int priorityPrefixAddt = 30;
|
|
// token: number
|
var exprNum = new Token(IdNum,
|
charDigit.Repeat() & !LookAhead[SkipWs & (charDigit | charLPar)])
|
{
|
new Rule<int>
|
{
|
Capture(value => int.Parse(value))
|
}
|
};
|
|
// token: plus (infix or prefix)
|
var exprPlus = new Token(IdExpr,
|
charPlus & !LookAhead[SkipWs & (charOper | charRPar | charLt)])
|
{
|
new PrefixRule<int, int>(
|
priority: priorityPrefixAddt,
|
select: t => (t.IsFirst || t.LookBehind().First().Is(IdExprLPar))
|
&& t.LookAhead().First().Is(IdNum, IdExprLPar))
|
{
|
Create((int x) => +x)
|
},
|
|
new InfixRule<int, int, int>(priority: priorityInfixAddt)
|
{
|
Create((int x, int y) => x + y)
|
}
|
};
|
|
// token: minus (infix or prefix)
|
var exprMinus = new Token(IdExpr,
|
charMinus & !LookAhead[SkipWs & (charOper | charRPar | charLt)])
|
{
|
new PrefixRule<int, int>(
|
priority: priorityPrefixAddt,
|
select: t => (t.IsFirst || t.LookBehind().First().Is(IdExprLPar))
|
&& t.LookAhead().First().Is(IdNum, IdExprLPar))
|
{
|
Create((int x) => -x)
|
},
|
|
new InfixRule<int, int, int>(priority: priorityInfixAddt)
|
{
|
Create((int x, int y) => x - y)
|
}
|
};
|
|
// token: multiplication
|
var exprMult = new Token(IdExpr,
|
charMult & !LookAhead[SkipWs & (charOper | charRPar | charLt)])
|
{
|
new InfixRule<int, int, int>(priority: priorityInfixMult)
|
{
|
Create((int x, int y) => x * y)
|
}
|
};
|
|
// token: division
|
var exprDiv = new Token(IdExpr,
|
charDiv & !LookAhead[SkipWs & (charOper | charRPar | charLt)])
|
{
|
new InfixRule<int, int, int>(priority: priorityInfixMult)
|
{
|
Create((int x, int y) => x / y)
|
}
|
};
|
|
// token: left parenthesis
|
var exprLPar = new Token(IdExprLPar,
|
charLPar & !LookAhead[SkipWs & (charRPar | charLt)])
|
{
|
new LeftDelimiterRule<string>()
|
{
|
Capture(value => value)
|
}
|
};
|
|
// token: right parenthesis
|
var exprRPar = new Token(IdExpr,
|
charRPar & !LookAhead[SkipWs & (charDigit | charLPar)])
|
{
|
new RightDelimiterRule<string, int, int>
|
{
|
Create((string lPar, int n) => n)
|
}
|
};
|
|
// int expression
|
var numExpr = (exprNum
|
| exprPlus
|
| exprMinus
|
| exprMult
|
| exprDiv
|
| exprLPar
|
| exprRPar).Repeat();
|
|
// token: tag value containing int expression
|
var tagValue = new Token(IdTagValue, SkipWs_Disable,
|
LookAhead[SkipWs & CharSet[~(CharSpace + charLt)]] & numExpr & LookAhead[charLt])
|
{
|
new Rule<string>
|
{
|
Create(IdNum, (int expr) => "=" + expr.ToString()),
|
Create(IdExpr, (int expr) => "=" + expr.ToString())
|
}
|
};
|
|
// token: tag open (only tag name, no attribs)
|
var tagBegin = new Token(IdTagBegin,
|
charLt & new Token(IdTagName, CharWord.Repeat()) & charGt)
|
{
|
new LeftDelimiterRule<string>
|
{
|
Create(IdTagName, (string tagName) => tagName)
|
}
|
};
|
|
// token: tag close
|
var tagEnd = new Token(IdTag,
|
charLt & charSlash & new Token(IdTagName, CharWord.Repeat()) & LookAhead[charGt])
|
{
|
new RightDelimiterRule<string, string, string>
|
{
|
Create(IdTagName, (string name) => name),
|
Error(
|
(string tag, string tagName) => tagName != tag,
|
(tag, tagName) => string.Format("Expected {0}, found {1}", tagName, tag)),
|
Create(
|
(string tag, string value) => value.StartsWith("="),
|
(tag, value) => tag + value),
|
Create(
|
(string tag, string value) => !value.StartsWith("="),
|
(tag, value) => tag + ":{" + value + "}")
|
}
|
};
|
|
// token: tag sequence
|
var tagConcat = new Token(IdTag, charGt & LookAhead[SkipWs & charLt & ~charSlash])
|
{
|
new InfixRule<string, string, string>(
|
pre: t => t.LeftOperand.Is(IdTag) && t.RightOperand.Is(IdTag))
|
{
|
Create((string leftTag, string rightTag) => leftTag + "," + rightTag)
|
}
|
};
|
|
// XML containing int expressions
|
var xmlInt = StartOfLine
|
& (tagBegin | tagValue | tagEnd & (tagConcat | charGt)).Repeat()
|
& SkipWs & EndOfFile;
|
|
// generate RegExpr parser
|
return xmlInt.Render(CharSpace.Repeat());
|
}
|
|
Parser Parser = GetParser();
|
|
[TestMethod]
|
public void TestConst()
|
{
|
string testInput = "<x>42</x>";
|
string testOutput = "x=42";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
|
[TestMethod]
|
[ExpectedException(typeof(ParseErrorException))]
|
public void TestConstError()
|
{
|
string testInput = "<x>foo</x>";
|
Parser.Parse(testInput);
|
}
|
|
[TestMethod]
|
public void TestInfix()
|
{
|
string testInput = "<x>2 - 1</x>";
|
string testOutput = "x=1";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
|
[TestMethod]
|
[ExpectedException(typeof(ParseErrorException))]
|
public void TestInfixError()
|
{
|
string testInput = "<x>2 - </x>";
|
Parser.Parse(testInput);
|
}
|
|
[TestMethod]
|
public void TestPrefix()
|
{
|
string testInput = "<x>-2 + 1</x>";
|
string testOutput = "x=-1";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
[TestMethod]
|
[ExpectedException(typeof(ParseErrorException))]
|
public void TestPrefixError()
|
{
|
string testInput = "<x>- + 1</x>";
|
Parser.Parse(testInput);
|
}
|
|
[TestMethod]
|
public void TestPrecedence()
|
{
|
string testInput = "<x>2 + 3 * 4</x>";
|
string testOutput = "x=14";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
|
[TestMethod]
|
public void TestParentheses()
|
{
|
string testInput = "<x>(2 + 3) * 4</x>";
|
string testOutput = "x=20";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
|
[TestMethod]
|
[ExpectedException(typeof(ParseErrorException))]
|
public void TestParenthesesLeftError()
|
{
|
string testInput = "<x>2 + 3) * 4</x>";
|
Parser.Parse(testInput);
|
}
|
|
[TestMethod]
|
[ExpectedException(typeof(ParseErrorException))]
|
public void TestParenthesesRightError()
|
{
|
string testInput = "<x>(2 + 3 * 4</x>";
|
Parser.Parse(testInput);
|
}
|
|
[TestMethod]
|
public void TestParenthesesNested()
|
{
|
string testInput = "<x>(-((2 + 3) * 4) / 5) * 3</x>";
|
string testOutput = "x=-12";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
|
[TestMethod]
|
public void TestNestedTags()
|
{
|
string testInput = "<a><x>(-((2 + 3) * 4) / 5) * 3</x><y>(2 + 3) * 4</y></a>";
|
string testOutput = "a:{x=-12,y=20}";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
|
[TestMethod]
|
[ExpectedException(typeof(ParseErrorException))]
|
public void TestNestedTagsError()
|
{
|
string testInput = "<a><x>1</x><y>2<z><w>";
|
Parser.Parse(testInput);
|
}
|
|
[TestMethod]
|
public void TestMultiLines()
|
{
|
string testInput =
|
"<a>" + "\r\n" +
|
" <x>2 + 3 * 4</x>" + "\r\n" +
|
" <y>(2 + 3) * 4</y>" + "\r\n" +
|
"</a>";
|
string testOutput = "a:{x=14,y=20}";
|
Debug.Assert(Parser.Parse(testInput).GetValues<string>(IdTag).First() == testOutput);
|
}
|
}
|
}
|
