Tôi đã viết một trình phân tích cú pháp đơn giản, mà tôi đã thử nghiệm dựa trên ví dụ bạn đã cung cấp. Nếu bạn muốn biết thêm về phân tích cú pháp tôi đề nghị bạn đọc Compiler Construction từ Niklaus Wirth.
Bước đầu tiên là luôn viết ra cú pháp ngôn ngữ của bạn theo cách thích hợp. Tôi đã chọn EBNF, điều này rất đơn giản để hiểu.
|
tách các lựa chọn thay thế.
[
và ]
tùy chọn kèm theo.
{
và }
biểu thị sự lặp lại (số không, một hoặc nhiều).
(
và )
cụm từ nhóm (không được sử dụng tại đây).
Mô tả này chưa hoàn chỉnh nhưng liên kết tôi đã cung cấp mô tả chi tiết hơn.
Các EBNF cú pháp
LineSequence = { TextLine | IfStatement }.
TextLine = <string>.
IfStatement = IfLine LineSequence { ElseIfLine LineSequence } [ ElseLine LineSequence ] EndLine.
IfLine = "#if" "(" Condition ")".
ElseLine = "#else".
ElseIfLine = "#else" "if" "(" Condition ")".
EndLine = "#end".
Condition = Identifier "=" Identifier.
Identifier = <letter_or_underline> { <letter_or_underline> | <digit> }.
Các phân tích cú pháp sau chặt chẽ cú pháp, tức là một sự lặp lại được dịch sang một vòng, một sự thay thế vào một tuyên bố if-else, và vân vân.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Windows.Forms;
namespace Example.SqlPreprocessor
{
class Parser
{
enum Symbol
{
None,
LPar,
RPar,
Equals,
Text,
NumberIf,
If,
NumberElse,
NumberEnd,
Identifier
}
List<string> _input; // Raw SQL with preprocessor directives.
int _currentLineIndex = 0;
// Simulates variables used in conditions
Dictionary<string, string> _variableValues = new Dictionary<string, string> {
{ "VariableA", "Case1" },
{ "VariableB", "CaseX" }
};
Symbol _sy; // Current symbol.
string _string; // Identifier or text line;
Queue<string> _textQueue = new Queue<string>(); // Buffered text parts of a single line.
int _lineNo; // Current line number for error messages.
string _line; // Current line for error messages.
/// <summary>
/// Get the next line from the input.
/// </summary>
/// <returns>Input line or null if no more lines are available.</returns>
string GetLine()
{
if (_currentLineIndex >= _input.Count) {
return null;
}
_line = _input[_currentLineIndex++];
_lineNo = _currentLineIndex;
return _line;
}
/// <summary>
/// Get the next symbol from the input stream and stores it in _sy.
/// </summary>
void GetSy()
{
string s;
if (_textQueue.Count > 0) { // Buffered text parts available, use one from these.
s = _textQueue.Dequeue();
switch (s.ToLower()) {
case "(":
_sy = Symbol.LPar;
break;
case ")":
_sy = Symbol.RPar;
break;
case "=":
_sy = Symbol.Equals;
break;
case "if":
_sy = Symbol.If;
break;
default:
_sy = Symbol.Identifier;
_string = s;
break;
}
return;
}
// Get next line from input.
s = GetLine();
if (s == null) {
_sy = Symbol.None;
return;
}
s = s.Trim(' ', '\t');
if (s[0] == '#') { // We have a preprocessor directive.
// Split the line in order to be able get its symbols.
string[] parts = Regex.Split(s, @"\b|[^#_a-zA-Z0-9()=]");
// parts[0] = #
// parts[1] = if, else, end
switch (parts[1].ToLower()) {
case "if":
_sy = Symbol.NumberIf;
break;
case "else":
_sy = Symbol.NumberElse;
break;
case "end":
_sy = Symbol.NumberEnd;
break;
default:
Error("Invalid symbol #{0}", parts[1]);
break;
}
// Store the remaining parts for later.
for (int i = 2; i < parts.Length; i++) {
string part = parts[i].Trim(' ', '\t');
if (part != "") {
_textQueue.Enqueue(part);
}
}
} else { // We have an ordinary SQL text line.
_sy = Symbol.Text;
_string = s;
}
}
void Error(string message, params object[] args)
{
// Make sure parsing stops here
_sy = Symbol.None;
_textQueue.Clear();
_input.Clear();
message = String.Format(message, args) +
String.Format(" in line {0}\r\n\r\n{1}", _lineNo, _line);
Output("------");
Output(message);
MessageBox.Show(message, "Error");
}
/// <summary>
/// Writes the processed line to a (simulated) output stream.
/// </summary>
/// <param name="line">Line to be written to output</param>
void Output(string line)
{
Console.WriteLine(line);
}
/// <summary>
/// Starts the parsing process.
/// </summary>
public void Parse()
{
// Simulate an input stream.
_input = new List<string> {
"select column1",
"from",
"#if(VariableA = Case1)",
" #if(VariableB = Case3)",
" table3",
" #else",
" table4",
" #end",
"#else if(VariableA = Case2)",
" table2",
"#else",
" defaultTable",
"#end"
};
// Clear previous parsing
_textQueue.Clear();
_currentLineIndex = 0;
// Get first symbol and start parsing
GetSy();
if (LineSequence(true)) { // Finished parsing successfully.
//TODO: Do something with the generated SQL
} else { // Error encountered.
Output("*** ABORTED ***");
}
}
// The following methods parse according the the EBNF syntax.
bool LineSequence(bool writeOutput)
{
// EBNF: LineSequence = { TextLine | IfStatement }.
while (_sy == Symbol.Text || _sy == Symbol.NumberIf) {
if (_sy == Symbol.Text) {
if (!TextLine(writeOutput)) {
return false;
}
} else { // _sy == Symbol.NumberIf
if (!IfStatement(writeOutput)) {
return false;
}
}
}
return true;
}
bool TextLine(bool writeOutput)
{
// EBNF: TextLine = <string>.
if (writeOutput) {
Output(_string);
}
GetSy();
return true;
}
bool IfStatement(bool writeOutput)
{
// EBNF: IfStatement = IfLine LineSequence { ElseIfLine LineSequence } [ ElseLine LineSequence ] EndLine.
bool result;
if (IfLine(out result) && LineSequence(writeOutput && result)) {
writeOutput &= !result; // Only one section can produce an output.
while (_sy == Symbol.NumberElse) {
GetSy();
if (_sy == Symbol.If) { // We have an #else if
if (!ElseIfLine(out result)) {
return false;
}
if (!LineSequence(writeOutput && result)) {
return false;
}
writeOutput &= !result; // Only one section can produce an output.
} else { // We have a simple #else
if (!LineSequence(writeOutput)) {
return false;
}
break; // We can have only one #else statement.
}
}
if (_sy != Symbol.NumberEnd) {
Error("'#end' expected");
return false;
}
GetSy();
return true;
}
return false;
}
bool IfLine(out bool result)
{
// EBNF: IfLine = "#if" "(" Condition ")".
result = false;
GetSy();
if (_sy != Symbol.LPar) {
Error("'(' expected");
return false;
}
GetSy();
if (!Condition(out result)) {
return false;
}
if (_sy != Symbol.RPar) {
Error("')' expected");
return false;
}
GetSy();
return true;
}
private bool Condition(out bool result)
{
// EBNF: Condition = Identifier "=" Identifier.
string variable;
string expectedValue;
string variableValue;
result = false;
// Identifier "=" Identifier
if (_sy != Symbol.Identifier) {
Error("Identifier expected");
return false;
}
variable = _string; // The first identifier is a variable.
GetSy();
if (_sy != Symbol.Equals) {
Error("'=' expected");
return false;
}
GetSy();
if (_sy != Symbol.Identifier) {
Error("Value expected");
return false;
}
expectedValue = _string; // The second identifier is a value.
// Search the variable
if (_variableValues.TryGetValue(variable, out variableValue)) {
result = variableValue == expectedValue; // Perform the comparison.
} else {
Error("Variable '{0}' not found", variable);
return false;
}
GetSy();
return true;
}
bool ElseIfLine(out bool result)
{
// EBNF: ElseIfLine = "#else" "if" "(" Condition ")".
result = false;
GetSy(); // "#else" already processed here, we are only called if the symbol is "if"
if (_sy != Symbol.LPar) {
Error("'(' expected");
return false;
}
GetSy();
if (!Condition(out result)) {
return false;
}
if (_sy != Symbol.RPar) {
Error("')' expected");
return false;
}
GetSy();
return true;
}
}
}
Lưu ý rằng lồng if-báo cáo được xử lý tự động theo một cách hoàn toàn tự nhiên. Đầu tiên, ngữ pháp được biểu diễn đệ quy. A LineSequence
có thể chứa IfStatment
s và IfStatment
s chứa LineSequence
s. Thứ hai, điều này dẫn đến các phương thức xử lý cú pháp gọi cho nhau theo cách đệ quy. Do đó, việc lồng ghép các phần tử cú pháp được dịch thành các cuộc gọi phương thức đệ quy.
Chờ, bạn đang phân tích chuỗi hoặc tạo chuỗi? – Jay
Tôi đang phân tích chuỗi và tạo chuỗi. Đầu ra của phân tích cú pháp sẽ là một chuỗi mới chứa các phần mong muốn của truy vấn SQL. – ChandlerPelhams
Có lý do nào khiến bạn tự tạo ngôn ngữ của mình và không sử dụng ngôn ngữ hiện có, như C#? – svick