北航编译原理文法代码

㈠ 急求:编译原理判断文法类型的C语言源代码!!!!!!

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/**//*全局变量定义*/
char inputString[10]; /**//*用来存储用户输入的字符串，最长为20个字符*/
char stack[10]; /**//*用来进行语法分析的栈结构*/
int base=0; /**//*栈底指针*/
int top=1; /**//*栈顶指针*/
char VT[4]={'a','d','b','e'}; /**//*用来存放5个终结符*/
char chanShengShi[10]; /**//*用来存放预测分析表M[A,a]中的一条产生式*/
int firstCharIntex=0; /**//*如果a匹配产生式，则每次firstCharIntex 自增 1 */
/**//*firstCharIntex用来存放用户输入串的第一个元素的下标*/

/**//*自定义函数声明*/
char pop() ; /**//*弹出栈顶元素*/

int push(char) ; /**//*向栈内添加一个元素，成功返回1，若栈已满则返回0*/

int search(char temp) ; /**//*查找非终结符集合VT中是否存在变量temp，存在返回1，不存在返回0*/

int M(char A, char a) ; /**//* 若预测分析表M[A,a]中存在产生式，
则将该产生式赋给字符数组chanShengShi[10]，并返回 1，
若M[A,a]中无定义产生式则返回 0
*/

void init() ; /**//*初始化数组inputString[10] 、栈 stack[10] 和 chanShengShi[10]*/

int yuCeFenXi() ; /**//* 进行输入串的预测分析的主功能函数，
若输入串满足文法则返回 1，不满足则返回0
*/
void printStack(); /**//*打印栈内元素 */
void printinputString(); /**//*打印用户输入串 */

/**//*进入主函数*/
void main()
{
system("cls");
yuCeFenXi(); /**//*调用语法预测分析函数*/
system("pause");
}

/**//*函数的定义*/

int yuCeFenXi()
{
char X; /**//*X变量存储每次弹出的栈顶元素*/
char a; /**//*a变量存储用户输入串的第一个元素*/
int i;
int counter=1; /**//*该变量记录语法分析的步骤数*/

init(); /**//*初始化数组*/
printf("wen fa : \n"); /**//*输出文法做为提示*/
printf("S -> aH \n");
printf("H -> aMd | d \n");
printf("M -> Ab | \n");
printf("A -> aM | e \n");

printf("\ninput string ,'#' is a end sign !!(aaabd#) \n"); /**//*提示用户输入将要测试的字符串*/
scanf("%s",inputString);

push('#');
push('S');

printf("\nCounter-----Stack---------------Input string \n"); /**//*输出结果提示语句*/

while(1) /**//*while循环为语法分析主功能语句块*/
{
printf(" ");
printf(" %d",counter); /**//*输出分析步骤数*/
printf(" "); /**//*输出格式控制语句*/
printStack(); /**//*输出当前栈内所有元素*/
X=pop(); /**//*弹出栈顶元素赋给变量X*/
printinputString(); /**//*输出当前用户输入的字符串*/

if( search(X)==0 ) /**//*在终结符集合VT中查找变量X的值，存在返回 1，否则返回 0*/
{
if(X == '#') /**//*栈已经弹空，语法分析结果正确，返回 1*/
{
printf("success \n"); /**//*语法分析结束，输入字符串符合文法定义*/
return 1;
}
else
{
a = inputString[firstCharIntex];
if( M(X,a)==1 ) /**//*查看预测分析表M[A,a]是否存在产生式，存在返回1，不存在返回0*/
{
for(i=0;i<10;i++) /**//* '$'为产生式的结束符,for循环找出该产生式的最后一个元素的下标*/
{
if( chanShengShi[i]=='$' ) break;
}
i-- ; /**//*因为 '$' 不是产生式，只是一个产生式的结束标志，所以i自减1*/

while(i>=0)
{
push( chanShengShi[i] ); /**//*将当前产生式逆序压入栈内*/
i-- ;
}
}
else
{
printf(" error(1) !!\n"); /**//*若预测分析表M[A,a]不存在产生式，说明语法错误*/
return 0;
}
}
}
else /**//*说明X为终结符*/
{
if( X==inputString[firstCharIntex] ) /**//*如果X等于a,说明a匹配*/
{
firstCharIntex++; /**//*输入串的第一个元素被约去，下一个元素成为新的头元素*/
}
else
{
printf(" error(2) !! \n");
return 0;
}
}
counter++;
}
}

void init()
{
int i;
for(i=0;i<10;i++)
{
inputString[i]=NULL; /**//*初始化数组inputString[10] */
stack[i]=NULL; /**//*初始化栈stack[10] */
chanShengShi[i]=NULL; /**//*初始化数组chanShengShi[10]*/
}
}

int M(char A, char a) /**//*文法定义因实际情况而定，该文法为课本例题的文法*/
{ /**//*该函数模拟预测分析表中的二维数组 */
if( A=='S'&& a=='a' ) { strcpy(&chanShengShi[0],"aH$"); return 1; }
if( A=='H'&& a=='a' ) { strcpy(&chanShengShi[0],"aMd$"); return 1; }
if( A=='H'&& a=='d' ) { strcpy(&chanShengShi[0],"d$"); return 1; }
if( A=='M'&& a=='a' ) { strcpy(&chanShengShi[0],"Ab$"); return 1; }
if( A=='M'&& a=='d' ) { strcpy(&chanShengShi[0],"$"); return 1; }
if( A=='M'&& a=='b' ) { strcpy(&chanShengShi[0],"$"); return 1; }
if( A=='M'&& a=='e' ) { strcpy(&chanShengShi[0],"Ab$"); return 1; }
if( A=='A'&& a=='a' ) { strcpy(&chanShengShi[0],"aM$"); return 1; }
if( A=='A'&& a=='e' ) { strcpy(&chanShengShi[0],"e$"); return 1; }
else return 0; /**//*没有定义产生式则返回0*/
}

char pop() /**//*弹出栈顶元素，用topChar返回*/
{
char topChar;
topChar=stack[--top];
return topChar;
}

int push(char ch)
{
if( top>9 )
{
printf(" error : stack overflow "); /**//*栈空间溢出*/
return 0;
}
else
{
stack[top]=ch; /**//*给栈顶空间赋值*/
top++;
return 1;
}
}

int search(char temp)
{
int i,flag=0; /**//*flag变量做为标志，若找到temp则赋1，否则赋0*/
for(i=0;i<4;i++)
{
if( temp==VT[i] ) /**//*终结符集合中存在temp*/
{
flag=1;
break;
}
}

if(flag==1) return 1; /**//*flag==1说明已找到等于temp的元素*/
else return 0;

}

void printStack() /**//*输出栈内内容*/
{
int temp;
for(temp=1;temp<top;temp++)
{
printf("%c",stack[temp]);
}
}

void printinputString() /**//*输出用户输入的字符串*/
{
int temp=firstCharIntex ;
printf(" "); /**//*该句控制输出格式*/
do{
printf("%c",inputString[temp]);
temp++;
}while(inputString[temp-1]!='#');
printf(" \n");
}

㈡ 请教高人 编译原理--正规文法

对于该文法写出的正规式:
S=0A1B
A=0|A
B=1|B

㈢ 编译原理文法分析

改完了,能文法分析出来了!!
大概 跟你说下 你的错误吧:
出错地点:
1.声明的stack[50]没有初始化;
2.stack的入栈是错误的,按照你的方式,如果原来有TM,再加入T->FN,则M就被挤出来了.(这里很关键,你对照我给你改的再看看)
3.s指针在你入栈操作以后并没有指向栈顶,而是保持了不变,这肯定是有问题的.(传入push函数的时候直接传参数s就好了.)
4.if(*s==*p){***}else{}的else的右括号管辖的范围 有错误

不嫌弃的话,可以去http://blog.csdn.net/fangguanya,我的BLOG,不怎么充实,呵呵,有这个程序的运行结果的. 谢谢 呵呵.
总之你对照我给你改的再看看吧. 我把我的测试输出 也给保留了.你好对照点.
(PS.我用的vs2005,用的时候你改下头申明,其他一样)

// grammar.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include<iostream>
using namespace std;

char * spush(char *stack,char *pt);
bool analyse(char *p);

void main()
{
//将分析串存放在二维数组中
char input[5][10]={"i+i#",
"i*(i+i)#",
"i*i+i#",
"i+*#",
"+i*i#"};
bool flag; //定义一个布尔型的标记量
for(int h=0;h<5;++h)
{
flag=analyse(input[h]);
if(flag) cout<<"恭喜你！"<<input[h]<<"语法分析成功，合法！"<<endl;
else cout<<"对不起！"<<input[h]<<"语法分析失败，非法！"<<endl;
}
int aaa;
cin>>aaa;
}
//定义各一将串逆序入栈的函数
char * spush(char *stack,char *pt)
{
int l=0;
//while循环的作用是将指针指向字符串的末尾，然后再由后向前入栈，从而实现逆序
while(*pt!='\0')
{
pt++;
l++;
}

if (*stack == '#')
{
stack++;
}
while(l)
{
pt--;
char cTempIntoStack = (*pt);
*stack=cTempIntoStack;
stack++;
l--;
}
stack--; //由于前面向前加了一位,要返回
////////////////
return stack;
///////////////////////////////////

}

/*LL(1)分析表
i + * ( ) #
E TM +TM
F i (E)
M TM e e
N e *FN e e
T FN FN
*/

//分析函数
bool analyse(char *p){
char analyseTable[5][6][4]={
"TM", "", "", "TM", "", "",
"i", "", "", "(E)", "", "",
"", "+TM", "", "", "e", "e",
"", "e", "*FN", "", "e", "e",
"FN", "", "", "TN", "", ""
};
char *stack = new char[50]; //定义一个栈空间
for (int iStack = 0;iStack<50 ;iStack++)
{
stack[iStack] = 0;
}
char *s=stack; //用指针*s指向栈的起始地址
*s='#'; //将“#”入栈
s++; //指针加1
*s='E'; //将“E”入栈
//下面的while循环实现字符串的词法分析操作

int count = 0;

while(*s!='#' || *p!='#'){
count++;
char * temp = s;
cout<<"NO."<<count<<endl;
cout<<"STACK"<<endl;
while (*temp != '#')
{
cout<<*temp<<" ";
temp--;
}
cout<<endl;

int x,y;
//若果栈顶数据和分析串的字符匹配，则将符号栈的栈顶数据出栈（即将栈顶指针减1）
if(*s==*p){
cout<<"Before :"<<*s<<endl;
s--;
p++;
cout<<"After :"<<*s<<endl;
}
//当符号栈和分析串的字符不匹配时，查分析表
else {
switch(*s){
case 'E':x=0;break;
case 'F':x=1;break;
case 'M':x=2;break;
case 'N':x=3;break;
case 'T':x=4;break;
default:return false;
}
switch(*p){
case 'i':y=0;break;
case '+':y=1;break;
case '*':y=2;break;
case '(':y=3;break;
case ')':y=4;break;
case '#':y=5;break;
default:return false;
}
//若果对应的为空，则分析串非法，退出
if(analyseTable[x][y][0]=='\0') return false;
//若查表所对应的为'e'，则将符号栈的栈顶数据出栈
else if(analyseTable[x][y][0]=='e') s--;
//其它，这时将查表所得的项逆序入符号栈
else {
s=spush(s,analyseTable[x][y]);
}
}
}
return true; //分析成功，返回
}

㈣ LL（1）文法-------编译原理

我正在写一个编译器，源代码在这里：
http://code.google.com/p/bellman/source/browse
其中词法规则在lex.l文件中，语法规则在grammer.y中，分别用flex和bison的输入文件的格式写的。我实现了一个类似C/C++的语法

地址如下：
http://code.google.com/p/bellman/source/browse/trunk/lib/bellman/lex.l
http://code.google.com/p/bellman/source/browse/trunk/lib/bellman/grammer.y
具体有什么问题可以发邮件[email protected]

㈤ 编译原理中文法G[E]:E::=E+T|T T::=T*F|F F::=(E)|i输入输出的程序实现代码，急！！！！！

我这里有个差不多的，不过加减乘除都有namespace 递归下降调用子程序法

你给我邮箱发个邮件 我吧程序法给你吧
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
textBox2.Select();
}
// A → BC
// C → (+|-)BC | ε
// B → ED
// E → (A)| i
// D → *ED | ε
private Stack<char> st = new Stack<char>();
bool j_j = false;//标识外层是否是减法，若是，则内层加减互换
bool c_c = false;//标识乘除的
private float A()
{
result += "A → BC\n";
float m = B();
if (st.Count != 0)
{
if (st.Peek() == '+')
{
return m + C();
}
else
if (st.Peek() == '-')
{
j_j = true;
return m - C();
}
else
{
C();
return m;
}
}
C();
return m;

}
private float B()
{
result += "B → ED\n";
float m = E();
if (st.Count != 0 && st.Peek() == '*')
return m * D();
else
if (st.Count != 0 && st.Peek() == '/')
{
c_c = true;
return m/D() ;
}
else
{
D();
return m;
}
}
private float C()
{
if (st.Count == 0)
result += "C →ε\n";
else
if (st.Peek() == '+' || st.Peek() == '-')
{
result += "C→" + st.Pop() + "BC\n";

float m = B();
if (st.Count != 0 && st.Peek() == '+')
{
if (j_j)//外层减法
{
j_j = false;//内层
return m - C();
}
else
return m + C();
}
else
if (st.Count != 0 && st.Peek() == '-')
{
if (j_j)
{
return m + C();
}
else
{
j_j = true;
return m - C();
}
}
else
{
C();
return m;
}
}
else //if(st.Peek()
result += "C →ε\n";
return 0;
}
private float D()
{
if (st.Count == 0)
{
result += "D →ε\n";
return 0;
}
if ((st.Peek() == '*') || (st.Peek() == '/'))
{
result += "D→" + st.Pop() + "ED\n";

float m = E();
if (st.Count != 0 && st.Peek() == '*')
{
if (c_c)
{
c_c = false;
return m / D();
}
else
return m * D();
}
else
if (st.Count != 0 && st.Peek() == '/')
{
if (c_c)
{
return m * D();
}
else
{
c_c = true;
return m / D();
}
}
else
{
D();
return m;
}
}
else
{
result += "D →ε\n";
}
return 0;
}
private float E()
{
if (st.Count == 0)
{
result += "错误，结尾应有数字或'（'\n";
return 0;
}
if (isdigit(st.Peek()))
{
result += "E→i\n";
float num = 0;
while (st.Count != 0 && isdigit(st.Peek()))
{
num = num * 10 + float.Parse(st.Pop().ToString());
}
return num;
}
else
if (st.Peek() == '(')
{
result += "E→(A)\n";
st.Pop();
float m = A();
if (st.Count != 0)
{
if (st.Peek() == ')')
{
st.Pop();
}
else
result += "非法字符！";
}
else
result += "缺少“）”";

return m;
}
else
result += "错误，第" +(codeLength- st.Count+1).ToString() + "个字应有数字或'（'\n";
return 0;
}
private bool isdigit(char d)
{
return d >= '0' && d <= '9';
}
private string result;
private int codeLength;
private void startbtn_Click(object sender, EventArgs e)
{
j_j = false;
c_c = false;
result = "";
label2.Text = "";
string s = textBox2.Text;
codeLength = textBox2.Text.Length;
for (int i = s.Length - 1; i >= 0; i--)
{
st.Push(s[i]);
}
string res = null;
try
{
res = A().ToString();
}
catch (Exception e1)
{
label2.Text = "出现错误：" + e1.Message;
return;
}
if (st.Count != 0)
label2.Text += result + "第" + (textBox2.Text.Length - st.Count + 1) + "个字符处有错误，请仔细查看\n";
else
label2.Text += result + "最终结果是：" + res;
}
}
}

㈥ 编译原理中 文法 文法G定义为四元组（Vn ,Vt,P,S）这4个是什么意思 另外 终结符和非终结符是什么意思

文法G是一个四元式（Vt,Vn,S,P）
其中Vt是一个非空有限集，它的每个元素称为终结符号
Vn是一个非空有限集，它的每个元素称为非终结符号（Vt和Vn的交集为空）
S是一个非终结符号，称为开始符号
P是一个产生式集合（有限），每个产生式的形式是P-->a

开始S必须在某个产生式的左部出现一次

终结符指组成语言的基本符号（如基本字、标识符、常数、算符、界符）
非终结符号（也称语法变量）表示一定符号串的集合。

你看到小写字母一般是终结符，大写字母肯定是非终结符

不明白可以联系。

㈦ 求C语言编译原理语法分析程序

一继承的词法来自

http://blog.sina.com.cn/s/blog_67c9fc300100srad.html
二语法

用扩充的BNF表示如下：

⑴<程序>：：=begin<语句串>end

⑵<语句串>：：=<语句>{；<语句>}

⑶<语句>：：=<赋值语句>

⑷<赋值语句>：：=ID：=<表达式>

⑸<表达式>：：=<项>{+<项> | -<项>}

⑹<项>：：=<因子>{*<因子> | /<因子>

⑺<因子>：：=ID | NUM | （<表达式>）

三要求

输入单词串，以“#”结束，如果是文法正确的句子，则输出成功信息，打印“success”，否则输出“error”。

例如：

输入 begin a:=9; x:=2*3; b:=a+x end #

输出 success！

输入 x:=a+b*c end #

输出 error!

㈧ 求 编译原理 语法分析程序

可以参考我的空间，我在三年前写过类似代码。
http://hi..com/逄韶华/ihome/myblog

㈨ 编译原理的文法是什么

文法是描述语言规则的形式规则。实际上就是用一个四元组G=(VT,VN,S,P)定义的一个推理方式。其中VT是终结符，VN是非终结符，S是开始符号，P是一组产生规则。