语法分析程序

工程代码http://download.csdn.net/detail/fulianzhou/9541833

config.h

/*****  *********/
#ifndef _CONFIG_H_
#define _CONFIG_H_

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

//#define LEX_OUTPUT

#define MAXSTRLEN        1024
#define UNDEFINE_DATA    -1

// 单词类型
const enum TYPE{
em_start = 1,// #
em_add,  // +
em_sub,  // -
em_mul,  // *
em_div,  // /
em_equ,  // =

em_left, // (
em_right, // )

em_int,  // int
em_real, // real

em_mark, // mark

em_sem,  // ;
em_com,  // ,

em_default, // 无法识别
};

// 元素数据
typedef struct {
TYPE type;
char *name;
union{
int int_dat;
double real_dat;
}value;
}ElemType;

// 优先关系表
const char g_cPriorList[10][10]={
/*     +    -    *    /    =    (    )    i    V    #      */
/* + */   '>', '>', '<', '<', ' ', '<', '>', '<', '<', ' ',        // 0
/* - */   '>', '>', '<', '<', ' ', '<', '>', '<', '<', ' ',        // 1
/* * */   '>', '>', '>', '>', ' ', '<', '>', '<', '<', ' ',        // 2
/* / */   '>', '>', '>', '>', ' ', '<', '>', '<', '<', ' ',        // 3
/* = */   '<', '<', '<', '<', ' ', '<', '>', '<', '<', ' ',        // 4
/* ( */   '<', '<', '<', '<', ' ', '<', '=', '<', '<', ' ',        // 5
/* ) */   '>', '>', '>', '>', ' ', ' ', '>', ' ', ' ', '>',        // 6
/* i */   '>', '>', '>', '>', ' ', ' ', '>', ' ', ' ', '>',        // 7
/* V */   '>', '>', '>', '>', '=', ' ', '>', ' ', ' ', '>',        // 8
/* # */   '>', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '<', '=',        // 9
};

// 查询优先关系表,得优先关系
char GetPrior(TYPE left,TYPE right);
// 形成数据
ElemType FormElemData(char *name,TYPE type,double data);
// 显示元素内容
void DispElem(ElemType item);

#endif

config.cpp

#include "config.h"

// 形成数据结点
ElemType FormElemData(char *name,TYPE type,double data){
ElemType item;
item.name = (char*)calloc(sizeof(char),strlen(name)+1);
strcpy(item.name,name);
item.type = type;
if(item.type == em_int) item.value.int_dat = (int)data;
else if(item.type == em_real) item.value.real_dat = data;
else item.value.real_dat = data;

return item;
}

// 显示元素内容
void DispElem(ElemType item){
printf("(%s,%d,%g)\n",item.name,item.type,item.type == em_int ? item.value.int_dat : item.value.real_dat);
}

// 根据有限关系表获取坐标值
static int GetPos(TYPE type){
switch(type){
case em_add:return 0;
case em_sub:return 1;
case em_mul:return 2;
case em_div:return 3;
case em_equ:return 4;
case em_left:return 5;
case em_right:return 6;
case em_int:
case em_real:return 7;
case em_mark:return 8;
case em_start:return 9;
}
return -1;
}

// 查询优先关系表,得优先关系
char GetPrior(TYPE left,TYPE right){
int iLeft = GetPos(left);
int iRight = GetPos(right);
if(iLeft >= 0 && iRight >= 0){
return g_cPriorList[iLeft][iRight];
}
else{
printf("Error, can not recognition type.\n");
return '-';
}
}

grammar_analysis.h

#ifndef _GRAMMAR_ANALYSIS_H_
#define _GRAMMAR_ANALYSIS_H_

#include "config.h"
#include "linklist.h"
#include "linkstack.h"

// 语法分析
int Grammar_Analysis(PT_List list);

#endif

grammar_analysis.cpp

#include "grammar_analysis.h"

static int Grammar_CheckFormat(PT_List list){
int i;
TYPE t1,t2;
int l = LinkList_GetLength(list);
TYPE t = LinkList_GetNode(list,1)->data.type;
if(!(t == em_int || t==em_real || t==em_left)) return 0;

for(i=1;i < l;i++){

if(LinkList_GetNode(list,i)->data.type == em_mark) return 0;
if(LinkList_GetNode(list,i)->data.type == em_default) return 0;
if(LinkList_GetNode(list,i)->data.type == em_equ) return 0;
if(i>1 && i < l){
t1 = LinkList_GetNode(list,i-1)->data.type;
t2 = LinkList_GetNode(list,i)->data.type;
if((t1 == em_left && t2 == em_right) || (t1 == em_right && t2 == em_left))  // (),)(
return 0;
if((t1 == em_add || t1 == em_sub || t1 == em_mul || t1 == em_div) &&
(t2 == em_add || t2 == em_sub || t2 == em_mul || t2 == em_div)) // ++,+-,+/...
return 0;
if(t1 == em_int || t1 == em_real){
if(t2 == em_add || t2 == em_sub || t2 == em_mul || t2 == em_div || t2 == em_right)
{}
else // 2 2,2(,
return 0;
}
if(t1 == em_add || t1 == em_sub || t1 == em_mul || t1 == em_div){
if(t2 == em_int || t2 == em_real || t2 == em_left){
}
else // +),++,...
return 0;
}
}
}
return 1;
}

// 计算
Data EvaluateExpression(PT_List ptlist,int *flag)
{
int iIndex = 3;
int len = LinkList_GetLength(ptlist);
//printf("len = %d\n",len);
*flag = 1;     // 先置为合格

ElemType tmpData;
LinkList OPTR,OPND;
ListInit(OPTR);            //寄存运算符
ListInit(OPND);            // 寄存数字

Push_sign(OPTR,em_start);
/* 获取下一个 */
if(iIndex < len){ /*  */
tmpData = LinkList_GetNode(ptlist,iIndex)->data;
//printf("GetNode: iIndex:%d,name:%s\n",iIndex,tmpData.name);
iIndex++;
}
else{
tmpData.type = em_start;
}
if(tmpData.type == em_int || tmpData.type == em_real){
Push_num(OPND,tmpData.type == em_int ? atoi(tmpData.name):atof(tmpData.name));//Push_num(OPND,tmpData.value.real_dat);

/* 获取下一个 */
if(iIndex < len){ /*  */
tmpData = LinkList_GetNode(ptlist,iIndex)->data;
//printf("GetNode: iIndex:%d,name:%s\n",iIndex,tmpData.name);
iIndex++;
}
else{
tmpData.type = em_start;
}
}
while(tmpData.type != em_start || Get_top_sign(OPTR) != em_start)
{
if(tmpData.type == em_int || tmpData.type == em_real){
Push_num(OPND,tmpData.type == em_int ? atoi(tmpData.name):atof(tmpData.name));

/* 获取下一个 */
if(iIndex < len){ /*  */
tmpData = LinkList_GetNode(ptlist,iIndex)->data;
//printf("GetNode: iIndex:%d,name:%s\n",iIndex,tmpData.name);
iIndex++;
}
else{
tmpData.type = em_start;
}
}
switch(/*GetPrior*/Precede(Get_top_sign(OPTR),tmpData.type))
{
case '<':
Push_sign(OPTR,tmpData.type);

/* 获取下一个 */
if(iIndex < len){ /*  */
tmpData = LinkList_GetNode(ptlist,iIndex)->data;
//printf("GetNode: iIndex:%d,name:%s\n",iIndex,tmpData.name);
iIndex++;
}
else{
tmpData.type = em_start;
}
break;
case '=':
Pop_sign(OPTR);

/* 获取下一个 */
if(iIndex < len){ /*  */
tmpData = LinkList_GetNode(ptlist,iIndex)->data;
//printf("GetNode: iIndex:%d,name:%s\n",iIndex,tmpData.name);
iIndex++;
}
else{
tmpData.type = em_start;
}
break;
case '>':{
double s = Operate(Pop_num(OPND),Pop_sign(OPTR),Pop_num(OPND));
//printf("s = %g\n",s);
Push_num(OPND,s);
break;
}
case '-':
case ' ': // 出现不合法的语法单元,退出
*flag = 0;
break;
}
if(*flag == 0) {
//printf("flag = 0,break;\n");
break;
}
}
//printf("Out!tmpdata.type = %d,top sign=%d\n",tmpData.type,Get_top_sign(OPTR));
return Pop_num(OPND);
}

// 语法分析
int Grammar_Analysis(PT_List list){
PT_List  ptlist = list;
if(!(LinkList_GetNode(ptlist,1)->data.type == em_mark && LinkList_GetNode(ptlist,2)->data.type == em_equ)){
LinkList_DispAllRaw(list);
printf("\t --> can not calculate.\n");
return 0;
}
else
{
ptlist=ptlist->next;
ptlist=ptlist->next;
if(Grammar_CheckFormat(ptlist) == 0) {
LinkList_DispAllRaw(list);
printf("\t --> can not calculate.\n");
return 0;
}
}
int flag = 1;
double sum = EvaluateExpression(list,&flag);

LinkList_DispAllRaw(list);
if(flag){
printf("\t --> %s%s%g;\n",LinkList_GetNode(list,1)->data.name,LinkList_GetNode(list,2)->data.name,sum);
}
else puts("\t --> can not calculate.\n");
return 0;
}

lexical_analysis.h 

#ifndef _LEXICAL_ANALYSIS_
#define _LEXICAL_ANALYSIS_

#include "config.h"
#include "linklist.h"

// 词法分析
PT_List ParseWord(char strInput[]);
#endif

Lexical_analysis.cpp

/*
输入串必须以'#'号结尾
*/

#include "lexical_analysis.h"
#include "linklist.h"

/* 类别标志 */
TYPE g_type = em_default;

void OutputStr(char str[],int flag){
switch(flag){
case em_int:fprintf(stdout,"(%s,%d)\t整数\n",str,flag);break;
case em_real:fprintf(stdout,"(%s,%d)\t实数\n",str,flag);break;
case em_default:fprintf(stdout,"(%s,%d)\t无法识别\n",str,flag);break;
case em_mark:fprintf(stdout,"(%s,%d)\t标识符\n",str,flag);break;
}
}

// 解析单词
PT_List ParseWord(char strInput[]){
int i,j;
char strTemp[MAXSTRLEN] = { 0 };        // 临时数组,用于保存单词
int iLen = 0;                           // 临时数组长度
int iDot;                               // 小数点出现标识符
PT_List ptlist = (PT_List)calloc(sizeof(T_List),1);
LinkList_Init(ptlist);

g_type = em_default;                    // 标志为未处理

for(i=0;strInput[i] && strInput[i] != '#';i++){
if(isdigit(strInput[i])){                  // 如果是数字
iDot = 0;                              // 小数点没有出现过
memset(strTemp,0,sizeof(strTemp));     // 清空临时数组
iLen = 0;                              // 临时数组长度为0
g_type = em_int;                       // 标志为整数

for(j=i;strInput[i] && strInput[j] != '#';j++){
if(strInput[j] == '.'){            // 如果出现小数点x
if(iDot == 0){                 // 如果小数点没有出现过
iDot = 1;                  // 标识为小数点已经出现
strTemp[iLen++] = strInput[j];  // 存在临时数组中
g_type = em_default;            // 标志为无法识别
}
else{                                // 第二次出现小数点出错
j--;
break;
}
}
else if(isdigit(strInput[j])){     // 如果是数字
strTemp[iLen++] = strInput[j];
if(g_type == em_default)
g_type = em_real;
}
else{
j--;
break;
}
}
#ifdef LEX_OUTPUT
OutputStr(strTemp,g_type);
#endif
if(g_type == em_default){
LinkList_AddNode(ptlist,FormElemData(strTemp,g_type,UNDEFINE_DATA));
}
else{
LinkList_AddNode(ptlist,FormElemData(strTemp,g_type,g_type == em_int ? atoi(strTemp) : atof(strTemp)));
}
memset(strTemp,0,sizeof(strTemp));     // 清空临时数组
iLen = 0;                              // 临时数组长度为0
i = j;
}
else if(isalpha(strInput[i])){             // 如果是以字母开头
memset(strTemp,0,sizeof(strTemp));
iLen = 0;
g_type = em_mark;                   // 标记为标识符
for(j=i;strInput[i] && strInput[j] != '#';j++){
if(isalpha(strInput[j]) || isdigit(strInput[j])){        // 如果是数字或者字母
strTemp[iLen++] = strInput[j];
}
else{
j--;// 否则
break;
}
}
#ifdef LEX_OUTPUT
OutputStr(strTemp,g_type);
#endif
LinkList_AddNode(ptlist,FormElemData(strTemp,g_type,UNDEFINE_DATA));
iLen = 0;
memset(strTemp,0,sizeof(strTemp));
i = j;
}
else if(isspace(strInput[i])) continue;
else{
switch(strInput[i]){
case '+':g_type = em_add;break;
case '-':g_type = em_sub;break;
case '*':g_type = em_mul;break;
case '/':g_type = em_div;break;
case '=':g_type = em_equ;break;
case ';':g_type = em_sem;break;
case ',':g_type = em_com;break;
case '(':g_type = em_left;break;
case ')':g_type = em_right;break;
default:g_type = em_default;
}
strTemp[0] = strInput[i];
strTemp[1] = '\0';
LinkList_AddNode(ptlist,FormElemData(strTemp,g_type,UNDEFINE_DATA));
#ifdef LEX_OUTPUT
fprintf(stdout,"(%c,%d)",strInput[i],g_type);
if(g_type == em_add  || g_type == em_sub || g_type == em_mul || g_type == em_div || g_type == em_equ)
printf("\t运算符\n");
else if(g_type == em_sem || g_type == em_com)
printf("\t界符\n");
else
printf("\t无法识别\n");
#endif
}
}
return ptlist;
}

linklist.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_
#include "config.h"

typedef struct tLNode{
tLNode *next;
ElemType data;
}T_List,*PT_List;

// 添加结点
int LinkList_AddNode(PT_List ptlist,ElemType item);
// 初始化链表
void LinkList_Init(PT_List ptlist);
// 添加结点
int LinkList_AddNode(PT_List ptlist,ElemType item);
// 显示所有节点
void LinkList_DispAll(PT_List ptlist);
// 获取链表长度
int LinkList_GetLength(PT_List ptlist);
// 获取指定位置结点
PT_List LinkList_GetNode(PT_List ptlist,int pos);
// 显示所有节点名字
void LinkList_DispAllRaw(PT_List ptlist);
// 销毁链表
void LinkList_Destroy(PT_List ptlist);
#endif

Linklist.cpp

#include "linklist.h"

// 初始化链表
void LinkList_Init(PT_List ptlist){
ptlist->data = FormElemData("<head>",em_default,UNDEFINE_DATA);
ptlist->next = NULL;
}

// 添加结点
int LinkList_AddNode(PT_List ptlist,ElemType item){
PT_List tmplist = ptlist;
while(tmplist->next != NULL){
tmplist = tmplist->next;
}
PT_List newNode = (PT_List)calloc(sizeof(T_List),1);
newNode->next = NULL;
newNode->data = item;

tmplist->next = newNode;
return 1;
}

// 显示所有节点
void LinkList_DispAll(PT_List ptlist){
PT_List tmplist = ptlist;
while(tmplist->next != NULL){
tmplist = tmplist->next;
DispElem(tmplist->data);
}
}
// 显示所有节点名字
void LinkList_DispAllRaw(PT_List ptlist){
PT_List tmplist = ptlist;
while(tmplist->next != NULL){
tmplist = tmplist->next;
//DispElem(tmplist->data);
printf("%s",tmplist->data.name);
}
}
// 获取链表长度
int LinkList_GetLength(PT_List ptlist){
int len = 0;
PT_List tmplist = ptlist;
while(tmplist->next != NULL){
tmplist = tmplist->next;
len++;
}
return len;
}

// 获取指定位置结点
PT_List LinkList_GetNode(PT_List ptlist,int pos){
if(pos <= 0 || pos > LinkList_GetLength(ptlist)){
printf("Out of range.\n");
return NULL;
}
int num = 1;
PT_List tmpList = ptlist;
while(tmpList->next != NULL && num <= pos){
tmpList = tmpList->next;
num++;
}
return tmpList;
}

// 获取下一个
PT_List LinkList_GetNext(PT_List ptlist){
if(ptlist->next != NULL){
PT_List tmpList = ptlist;
ptlist = ptlist->next;
return tmpList;
}
return NULL;
}

// 销毁链表
void LinkList_Destroy(PT_List ptlist){
while(ptlist->next){
PT_List tmplist = ptlist;
ptlist = ptlist->next;
free(tmplist);
}
free(ptlist);
}

linkstack.h

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

#define OK 1
#define NO 0
#define ERROR 0
#define OVERFLOW -1
typedef TYPE   Sign;
typedef int    Status;
typedef double Data;

typedef struct LNode
{
Sign sign;
Data num;
struct LNode *prior;
}LNode,*LinkList;

//初始化
Status ListInit(LinkList &L);
//数字入栈
Status Push_num(LinkList &L,Data e);
//字符入栈
Status Push_sign(LinkList &L,Sign e);
// 字符出栈
Sign Pop_sign(LinkList &L);
//数字出栈
Data Pop_num(LinkList &L);
// 判断栈空
Status Empty(LinkList L);
// 得栈顶字符元素
Sign Get_top_sign(LinkList L);
// 判断优先性
char Precede(TYPE c1,TYPE c2);
// 运算
double Operate(double x,TYPE c,double y);
#endif

linkstack.cpp

#include "config.h"
#include "linkstack.h"

Status ListInit(LinkList &L)    ///初始化
{
L=(LinkList)malloc(sizeof(LNode));
L->prior=NULL;
return OK;
}

Status Push_num(LinkList &L,double e)         ///数字入栈
{
LinkList p=(LinkList)malloc(sizeof(LNode));
p->num=e;
p->prior=L;
L=p;
//printf("Push_num:%.2f\n",e);
return OK;
}
Status Push_sign(LinkList &L,Sign e)          /// 字符入栈
{
LinkList p=(LinkList)malloc(sizeof(LNode));
p->sign=e;
p->prior=L;
L=p;
//printf("Push_sign:%d\n",e);
return OK;
}
Sign Pop_sign(LinkList &L)                      /// 字符出栈
{
if(L->prior!=NULL)
{
LinkList p=L;
Sign x=L->sign;
L=L->prior;
free(p);
//printf("Pop_sign:%d\n",x);
return x;
}
}
Data Pop_num(LinkList &L)                   ///数字出栈
{
if(L->prior!=NULL)
{
LinkList p=L;
Data a=L->num;
L=L->prior;
free(p);
//printf("Pop_num:%g\n",a);
return a;
}
}
Status Empty(LinkList L)                    /// 判断栈空
{
if(L->prior==NULL) return 1;
return 0;
}
Sign Get_top_sign(LinkList L)               /// 得栈顶字符元素
{
if(L->prior!=NULL)
return L->sign;
}
char Precede(TYPE c1,TYPE c2)                 /// 判断优先性
{
if((c1==em_add||c1== em_sub) && (c2==em_add||c2==em_sub||c2==em_right||c2==em_start))
return '>';
else if((c1==em_add||c1==em_sub) && (c2==em_mul||c2==em_div||c2==em_left))
return '<';

if((c1==em_mul||c1==em_div) && (c2==em_add||c2==em_sub||c2==em_mul||c2==em_div||c2==em_right||c2==em_start))
return '>';
else if((c1==em_mul||c1==em_div) && c2==em_left )
return '<';

if(c1==em_left && (c2==em_add||c2==em_sub||c2==em_mul||c2==em_div||c2==em_left))
return '<';
else if(c1==em_left && c2==em_right)
return '=';

if(c1==em_right)
return '>';

if(c1==em_start && c2==em_start)
return '=';
else
return '<';
}

// 运算
double Operate(double x,TYPE type,double y){
double s = 0;
switch(type){
case em_add:s = x + y;break;
case em_sub:s = x - y;break;
case em_mul:s = x * y;break;
case em_div:s = x / y;break;
}
return s;
}

main.cpp

#include "lexical_analysis.h"
#include "grammar_analysis.h"

int main(int argc,char *argv[]){
char strInput[MAXSTRLEN] = { 0 };
char c;
int  iLen = 0;

printf("Input lines.\n\tevery sentence end by ';',end of '#':\n");

while(1){
memset(strInput,0,sizeof(strInput));
iLen = 0;
c = 0;
while((c = (char)getc(stdin)) != '#') strInput[iLen++] = c;
strInput[iLen] = '\0';
PT_List ptList = ParseWord(strInput);
int listlen = LinkList_GetLength(ptList);
//printf("length = %d\n",listlen);
puts("lexical analysis:");
LinkList_DispAll(ptList);

puts("");
puts("grammar analysis:");
int n = 1;
ElemType e;
while(n <= LinkList_GetLength(ptList)){
PT_List list = (PT_List)calloc(sizeof(T_List),1);
LinkList_Init(list);
while(n < listlen && (e = LinkList_GetNode(ptList,n)->data).type != em_sem){                 // 找出一句
LinkList_AddNode(list,e);
n++;
}
LinkList_AddNode(list,LinkList_GetNode(ptList,n)->data);
n++;
/* 开始语法分析 */
Grammar_Analysis(list);
LinkList_Destroy(list);
}
printf("\ninput new lines:\n");
}
return 0;
}