我的日常工作包括开发类似Pascal的编译器。我一直在努力优化和代码生成。
我还想开始学习为同一种语言构建一个简单的解析器。但是，我不太确定如何解决这个问题。 Flex和Bison似乎是首选。但是，是不是可以使用C ++或C＃编写解析器？我对C有点不满意。
Yacc ++支持C＃，但它是获得许可的。我正在寻找在这方面能找到的所有帮助。建议将受到高度赞赏。
答案 0 :(得分：6)
我相信你可以在C＃中使用ANTLR。我自己从未尝试过（但是），但有一个教程here可能会指向正确的方向。
答案 1 :(得分：5)
就个人而言，我推出自己的词法分析器和解析器（LL）。这是一个非常简短的例子。它是用C ++编写的，但希望你能适应它。它利用宏PARSE_HIGHER，可以轻松地在不同的优先级别插入运算符，而无需更改代码。
// routine to scan over whitespace/comments
void ScanWhite(const char* &pc){
while(true){
if(0);
else if (WHITESPACE(*pc)) pc++;
else if (pc[0]=='/' && pc[1]=='/'){
while(*pc && *pc++ != '\n');
}
else break;
}
}
// routine to lex an identifier
bool SeeId(const char* &pc, string sId){
ScanWhite(pc);
const char* pc0 = pc;
if (alpha(*pc)){
sId = "";
while(alphanum(*pc)) sId += (*pc++);
return true;
}
pc = pc0;
return false;
}
// routine to lex a number
bool SeeNum(const char* &pc, double &dNum){
ScanWhite(pc);
const char* pc0 = pc;
if (digit(*pc)){
dNum = 0;
while(digit(*pc)) dNum = dNum * 10 + (*pc++ - '0');
if (*pc == '.'){
double divisor = 1, frac = 0;
while(digit(*pc)){
divisor *= 0.1;
frac += (*pc++ - '0') * divisor;
}
dNum += frac;
}
return true;
}
pc = pc0;
return false;
}
// routine to lex some constant word
bool SeeWord(const char* &pc, const char* sWord){
ScanWhite(pc);
const char* pc0 = pc;
int len = strlen(sWord);
if (strncmp(pc, sWord, len)==0 && !alphanum(pc[len])){
pc += len;
return true;
}
pc = pc0;
return false;
}
// routine to lex a single character like an operator
bool SeeChar(const char* &pc, const char c){
ScanWhite(pc);
const char* pc0 = pc;
if (*pc == c){
pc++;
return true;
}
pc = pc0;
return false;
}
// primitive expression parser
void ParsePrimitiveExpr(const char* &pc, CNode* &p){
double dNum;
char sId[100];
if (0);
else if (SeeNum(pc, dNum)){
p = new CNode(dNum);
}
else if (SeeId(pc, sId)){
// see if its a function call
if (SeeChar(pc, '(')){
p = MakeNewFunctionCallNode(sId);
while(!SeeChar(pc, ')')){
CNode* p1 = null;
ParseExpression(pc, p1);
AddArgumentExprToFunctionCallNode(p, p1);
SeeChar(pc, ','); /* optional comma separator */
}
}
// otherwise its just a variable reference
else {
p = new CNode(sId);
}
}
// handle embedded expressions
else if (SeeChar(pc, '(')){
ParseExpression(pc, p);
if (!SeeChar(pc, ')')) /* deal with syntax error */
}
}
#define PARSE_HIGHER ParsePrimitiveExpr
// product parser
void ParseProduct(const char* &pc, CNode* &p){
PARSE_HIGHER(pc, p);
while(true){
if (0);
else if (SeeChar(pc, '*')){
CNode p1 = null;
PARSE_HIGHER(pc, p1);
p = new CNode('*', p, p1);
}
else if (SeeChar(pc, '/')){
CNode p1 = null;
PARSE_HIGHER(pc, p1);
p = new CNode('/', p, p1);
}
else break;
}
}
#undef PARSE_HIGHER
#define PARSE_HIGHER ParseProduct
// sum parser
void ParseSum(const char* &pc, CNode* &p){
PARSE_HIGHER(pc, p);
while(true){
if (0);
else if (SeeChar(pc, '+')){
CNode p1 = null;
PARSE_HIGHER(pc, p1);
p = new CNode('+', p, p1);
}
else if (SeeChar(pc, '-')){
CNode p1 = null;
PARSE_HIGHER(pc, p1);
p = new CNode('-', p, p1);
}
else break;
}
}
#undef PARSE_HIGHER
// can insert more routines like the above
// to handle move operators
#define PARSE_HIGHER ParseSum
// overall expression parser
void ParseExpression(const char* &pc, CNode* &p){
PARSE_HIGHER(pc, p);
}
添加了一些Pascal风格的语句语法：
void ParseStatement(const char* &pc){
char sId[100];
if(0);
else if (SeeWord(pc, "begin")){
while(!SeeWord(pc, "end")){
ParseStatement(pc);
SeeChar(pc, ';');
}
}
else if (SeeWord(pc, "while")){
CNode* p1 = null;
ParseExpression(pc, p1);
ParseStatement(pc);
/* semantics for while statement */
}
else if (SeeWord(pc, "if")){
CNode* p1 = null;
ParseExpression(pc, p1);
ParseStatement(pc);
if (SeeWord(pc, "else")){
ParseStatement(pc);
}
/* semantics for if statement */
}
else if (SeeWord(pc, "for")){
/* you do it */
}
// handle assignments and subroutine calls
else if (SeeId(pc, sId)){
if(0);
else if (SeeChar(pc, '=')){
CNode* p1 = null;
ParseExpression(pc, p1);
/* semantics for assignment statement */
}
else if (SeeChar(pc, '(')){
CNode* p = MakeNewFunctionCallNode(sId);
while(!SeeChar(pc, ')')){
CNode* p1 = null;
ParseExpression(pc, p1);
AddArgumentExprToFunctionCallNode(p, p1);
SeeChar(pc, ','); /* optional comma separator */
}
}
else {
/* we have a 1-word statement, which is OK in pascal */
}
}
else {
/* syntax error */
}
}
它仍然需要数组索引，变量声明和函数定义的语法，但我希望很清楚如何做到这一点。
答案 2 :(得分：1)
在他的经典编程文本算法+数据结构=程序中，Niklaus Wirth开发了一个完整的递归下降解析器（在Pascal中），用于简单的Pascal0类语言。
答案 3 :(得分：0)
如果你用Java编写，我建议使用ANTLR。这是一个用Java编写的很好的LL（*）解析器生成器。在亚马逊上也有一本很棒的书。
答案 4 :(得分：0)
野牛＆amp; flex是规范的解析器生成器。如果你对C ++感兴趣，我发现boost spirit很有用。我从来没有将它用于任何像编译器这样复杂的东西。我相信其他人会对其他语言提出有趣的建议，例如C＃...
答案 5 :(得分：0)
你实际上可以使用flex＆amp;野牛与C ++。例如，在this tutorial中，您可以看到第5部分专门用于此事。只是google for it，我相信你会找到很多例子。
答案 6 :(得分：0)
当你使用Lex和Yacc时，你实际上并没有在C中写任何东西。Lex是它自己的语言，就像Yacc一样。所以你在Lex和Yacc中的解析器中编写词法分析器。但是，对于Pascal，Lex和Yacc输入为already available。
生成的解析器和词法分析器有C接口，这是真的。但是，大多数语言（包括C ++）都有简单的方法来调用（或包装）C接口。
我不是它的专家，但我确信所有上述内容都适用于ANTLR。
如果您要求使用“纯C ++”（无论这意味着什么），请查看使用boost spirit。如果能引起更多的工作，我真的没有看到理论纯度的重点。
手工编写自己的词法分析器和解析器实际上很有趣。词法分析器是极少数可以证明使用 goto 和预处理器的情况之一。但是，如果你能避免它，我不会建议像帕斯卡那样成熟的语言。那将是很多工作。我说的是人年。
答案 7 :(得分：0)
我已经编写了一个带有flex和bison的XSLT解析器。最近，我正在使用ANTLR做一个项目：
is JFig language syntax efficient and clear (and better than Spring-Framework’s XML DSL)?
我喜欢在ANTLR工作，而不是Flex和Bison。 ANTLR在某些方面使您处于更高的抽象层次。词法定义和解析器语法都可以放在一个文件中。 （ANTLR将生成令牌文件。）
其中一个关键项目是定义树语法的能力。基本上，您对输入语言进行语法分析，并将操作重写为高度优化的AST树输出（在内存中保留为链接数据结构）。然后，您可以将此树传递给在单独的树解析器文件中定义的另一个解析器。树解析器是您执行所需操作项的实际工作的地方。
这是一个很好的方法，因为您可以保留AST表单并根据需要重复处理它 - 根据后面的操作剥离特定的子树节点以进行处理等。想想像语言解释器这样的东西。而不是进入for循环并一遍又一遍地从头开始处理语言，而只是处理它的AST表示。
在我的情况下，我设计了一个bean工厂来进行IoC依赖注入。我的bean工厂在运行时保留bean描述符的AST。当它需要创建（或检索）一个新的bean实例时，我只是将bean描述符AST子树传递给我的树解析器 - 结果是所需的bean实例（有很多因素可用于确定如何实例化请求bean，包括通过元属性生成任何其他引用的bean和/或应用其他特殊行为。
最后，我当前的bean工厂以Java为目标，但我希望以ActionScript3和C＃.NET为目标。 ANTLR支持这样做。
如上所述，Terrence Parr写了一本关于如何使用ANTLR的书。它面向需要用ANTLR做一些实际工作的工作程序员（而不是对该主题的学术处理）。
答案 8 :(得分：0)
如果您希望C＃按此Question尝试使用Gardens Point GPPG和GPLEX。