假条，今天要写编译原理，来不及更新啦

　　//ConsoleApplication14.cpp:
　　//
　　#include“stdafx.h“
　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　usingnamespac
　　#defineMAXSIZE0xffff
　　intip=0;
　　intN=0;
　　intn=0;//stacknumber
　　boolflag=1;
　　inttop=0;//变量存储
　　structnode{
　　node*i
　　node*bro=
　　node*child=
　　i
　　string
　　boolhasval=
　　doubl
　　}S，A，B，C，D，E，F，G，H，I，J，*sheet，*p，*s
　　structvariable{
　　string
　　doubl
　　}var[20];
　　intfind_var(stringa){
　　for(inti=0;i　　if(var[i].name==a)
　　ret
　　return-1;
　　}
　　template
　　classmy_stack
　　{
　　in
　　type*
　　intmax
　　public:
　　my_stack():top(-1)，maxsize(MAXSIZE)
　　{
　　my_s=newtype[maxsize];
　　if(my_s==NULL)
　　{
　　cerr<“动态存储分配失败!“<
　　exit(1);
　　}
　　}
　　my_stack(intsize):top(-1)，maxsize(size)
　　{
　　my_s=newtype[maxsize];
　　if(my_s==NULL)
　　{
　　cerr<“动态存储分配失败!“<
　　exit(1);
　　}
　　}
　　~my_stack()
　　{
　　delete[]
　　}
　　//是否为空
　　boolEmpty();
　　//压栈
　　node*Push(typetp);
　　//返回栈顶元素
　　typeTop();
　　//返回第n个栈顶元素
　　typeTop(intn);
　　//出栈
　　voidPop();
　　//栈大小
　　intSize();
　　stringShow();
　　stringshow();
　　intNum();
　　};
　　template
　　boolmy_stack::Empty()
　　{
　　if(top==-1){
　　return
　　}
　　else
　　returnf
　　}
　　template
　　typemy_stack::Top()
　　{
　　if(top!=-1)
　　{
　　returnmy_s[top];
　　}
　　else
　　{
　　cout<“栈空“;
　　exit(1);
　　}
　　}
　　template
　　typemy_stack::Top(intn)
　　{
　　if((top-n)>-1)
　　{
　　returnmy_s[top-n];
　　}
　　else
　　{
　　cout<“栈空“;
　　exit(1);
　　}
　　}
　　node*my_stack::Push(nodetp)
　　{
　　node*temp=new
　　*temp=tp;
　　temp->index=
　　n++;
　　if(top+1　　{
　　my_s[++top]=*
　　}
　　else
　　{
　　cout<“栈满“;
　　exit(1);
　　}
　　return
　　}
　　template
　　intmy_stack::Num(){
　　retur
　　}
　　template
　　voidmy_stack::Pop()
　　{
　　if(top>=0)
　　{
　　top--;
　　}
　　else
　　{
　　cout<“栈空“;
　　exit(1);
　　}
　　}
　　template
　　intmy_stack::Size()
　　{
　　returntop+1;
　　}
　　template
　　stringmy_stack::Show(){
　　str
　　for(inti=0;i<=top;i++)
　　s+=my_s[i].
　　ret
　　}
　　stringmy_stack::show(){
　　str
　　for(inti=0;i<=top;i++)
　　s+=(my_s[i].index->text)+““;
　　ret
　　}
　　voidS_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(S)，“;
　　nodet10=sheet[10];
　　nodet9=sheet[9];
　　switch(a[ip].id){
　　case10:
　　stack.Push(t9);
　　stack.Push(B);
　　stack.Push(t10);
　　stack.Push(A);
　　cout<“push(AB;)“;
　　b
　　case17:
　　stack.Push(t9);
　　stack.Push(B);
　　stack.Push(t10);
　　stack.Push(A);
　　cout<“push(AB;)“;
　　b
　　case21:
　　b
　　default:
　　cout<“error:NOPATTERNFORS!“;
　　flag=0;
　　b
　　}
　　}
　　voidA_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(A)，“;
　　nodet9=sheet[9];
　　switch(a[ip].id){
　　case10:
　　b
　　case17:
　　stack.Push(A);
　　stack.Push(t9);
　　stack.Push(C);
　　cout<“push(C;A)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORA!“;
　　flag=0;
　　b
　　}
　　}
　　voidB_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(B)，“;
　　switch(a[ip].id){
　　case0:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case1:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case2:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case3:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case4:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case5:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case6:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case7:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case12:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case17:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case18:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case19:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　case20:
　　stack.Push(E);
　　stack.Push(D);
　　cout<“push(DE)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORB!“;
　　flag=0;
　　b
　　}
　　}
　　voidC_P(node*sheet，node*a，my_stack&stack)
　　{
　　cout<“pop(C)，“;
　　nodet17=sheet[17];
　　nodet15=sheet[15];
　　switch(a[ip].id){
　　case17:
　　stack.Push(B);
　　stack.Push(t15);
　　stack.Push(t17);
　　cout<“push(var=B)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORC!“;
　　flag=0;
　　b
　　}
　　}
　　voidD_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(D)，“;
　　switch(a[ip].id){
　　case0:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case1:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case2:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case3:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case4:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　case5:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case6:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case7:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case12:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case17:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case18:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　b
　　case19:
　　stack.Push(G);
　　stack.Push(F);
　　cout<“push(FG)“;
　　case20:
　　stack.Push(G);
　　stack.Push(F);
　　b
　　cout<“push(FG)“;
　　b
　　b
　　default:
　　flag=0;
　　cout<“error:NOPATTERNFORD!“;
　　b
　　}
　　}
　　voidE_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(E)，“;
　　nodet11=sheet[11]，t12=sheet[12];
　　switch(a[ip].id){
　　case8:
　　b
　　case9:
　　b
　　case11:
　　stack.Push(E);
　　stack.Push(D);
　　stack.Push(sheet[11]);
　　cout<“push(+DE)“;
　　b
　　case12:
　　stack.Push(E);
　　stack.Push(D);
　　stack.Push(sheet[12]);
　　cout<“push(-DE)“;
　　b
　　default:
　　flag=0;
　　cout<“error:NOPATTERNFORE!“;
　　b
　　}
　　}
　　voidF_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(F)，“;
　　switch(a[ip].id){
　　case0:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);
　　stack.Push(sheet[0]);
　　cout<“push(sin(H))“;
　　b
　　case1:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);
　　stack.Push(sheet[1]);
　　cout<“push(cos(H))“;
　　b
　　case2:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);

　　stack.Push(sheet[2]);
　　cout<“push(tg(H))“;
　　b
　　case3:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);
　　stack.Push(sheet[3]);
　　cout<“push(ctg(H))“;
　　b
　　case4:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);
　　stack.Push(sheet[4]);
　　cout<“push(log(H))“;
　　b
　　case5:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);
　　stack.Push(sheet[5]);
　　cout<“push(lg(H))“;
　　b
　　case6:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[7]);
　　stack.Push(sheet[6]);
　　cout<“push(ln(H))“;
　　b
　　case7:
　　stack.Push(I);
　　stack.Push(H);
　　cout<“push(HI)“;
　　b
　　case12:
　　stack.Push(I);
　　stack.Push(H);
　　cout<“push(HI)“;
　　b
　　case17:
　　stack.Push(I);
　　stack.Push(H);
　　cout<“push(HI)“;
　　b
　　case18:
　　stack.Push(I);
　　stack.Push(H);
　　cout<“push(HI)“;
　　b
　　case19:
　　stack.Push(I);
　　stack.Push(H);
　　cout<“push(HI)“;
　　b
　　case20:
　　stack.Push(I);
　　stack.Push(H);
　　cout<“push(HI)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORF!“;
　　flag=0;
　　b
　　}
　　}
　　voidG_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(G)，“;
　　switch(a[ip].id){
　　case8:
　　b
　　case9:
　　b
　　case11:
　　b
　　case12:
　　b
　　case13:
　　stack.Push(G);
　　stack.Push(F);
　　stack.Push(sheet[13]);
　　cout<“push(*FG)“;
　　b
　　case14:
　　stack.Push(G);
　　stack.Push(F);
　　stack.Push(sheet[14]);
　　cout<“push(/FG)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORG!“;
　　flag=0;
　　b
　　}
　　}
　　voidH_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(H)，“;
　　switch(a[ip].id){
　　case7:
　　stack.Push(sheet[8]);
　　stack.Push(B);
　　stack.Push(sheet[7]);
　　cout<“push((B))“;
　　b
　　case12:
　　stack.Push(H);
　　stack.Push(sheet[12]);
　　cout<“push(-H)“;
　　b
　　case17:
　　stack.Push(sheet[17]);
　　cout<“push(var)“;
　　b
　　case18:
　　stack.Push(sheet[18]);
　　cout<“push(con)“;
　　b
　　case19:
　　stack.Push(sheet[18]);
　　cout<“push(con)“;
　　b
　　case20:
　　stack.Push(sheet[18]);
　　cout<“push(con)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORH!“;
　　flag=0;
　　b
　　}
　　}
　　voidI_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(I)，“;
　　switch(a[ip].id){
　　case8:
　　b
　　case9:
　　b
　　case11:
　　b
　　case12:
　　b
　　case13:
　　b
　　case14:
　　b
　　case16:
　　stack.Push(H);
　　stack.Push(sheet[16]);
　　cout<“push(^H)“;
　　b
　　default:
　　cout<“error:NOPATTERNFORI!“;
　　flag=0;
　　b
　　}
　　}
　　voidJ_P(node*sheet，node*a，my_stack&stack){
　　cout<“pop(J)，“;
　　switch(a[ip].id){
　　case8:
　　stack.Push(sheet[8]);
　　cout<“push())“;
　　b
　　case22:
　　stack.Push(sheet[8]);
　　stack.Push(H);
　　stack.Push(sheet[22]);
　　cout<“push(，H))“;
　　default:
　　cout<“error:NOPATTERNFORJ!“;
　　flag=0;
　　b
　　}
　　}
　　stringshow(node*a){
　　str
　　for(inti=ip;i　　{
　　s+=a[i].
　　}
　　ret
　　}
　　voidana(my_stack&stack，node*a){
　　inti=0;
　　while(flag){
　　p=stack.Top().i//当前指针
　　i++;
　　cout　　cout　　cout　　switch(stack.Top().id){
　　case23:
　　stack.Pop();
　　S_P(sheet，a，stack);
　　b
　　case24:
　　stack.Pop();
　　A_P(sheet，a，stack);
　　b
　　case25:
　　stack.Pop();
　　B_P(sheet，a，stack);
　　b
　　case26:
　　stack.Pop();
　　C_P(sheet，a，stack);
　　b
　　case27:
　　stack.Pop();
　　D_P(sheet，a，stack);
　　b
　　case28:
　　stack.Pop();
　　E_P(sheet，a，stack);
　　b
　　case29:
　　stack.Pop();
　　F_P(sheet，a，stack);
　　b
　　case30:
　　stack.Pop();
　　G_P(sheet，a，stack);
　　b
　　case31:
　　stack.Pop();
　　H_P(sheet，a，stack);
　　b
　　case32:
　　stack.Pop();
　　I_P(sheet，a，stack);
　　b
　　case33:
　　stack.Pop();
　　J_P(sheet，a，stack);
　　b
　　default:
　　if(stack.Top().id==a[ip].id){
　　if(stack.Top().id==17)
　　stack.Top().index->text=a[ip].
　　elseif(stack.Top().id==1
　　{
　　if(a[ip].text==“PI“)
　　{
　　stack.Top().index->text=a[ip].
　　stack.Top().index->val=3.14
　　}
　　elseif(a[ip].text==“E“)
　　{
　　stack.Top().index->text=a[ip].
　　stack.Top().index->val=2.71
　　}
　　else{
　　stack.Top().index->text=a[ip].
　　stack.Top().index->val=stod(a[ip].text);
　　}
　　}
　　ip++;
　　if(stack.Top().id<23&&stack.Top().id>=0)
　　cout<“pop(“　　else
　　cout<“pop(“　　stack.Pop();
　　cout<“next(ip)“;
　　if(stack.Empty())cout<“Success“;
　　}
　　else{
　　cout<“error:Fail!“;
　　flag=0;
　　b
　　}
　　}
　　cout<
　　if(stack.Empty())b
　　if(n>0)
　　{p->child=stack.Top(0).i
　　node*temp=p->child->i
　　for(inti=1;i　　{
　　temp->bro=stack.Top(i).i
　　temp=temp->bro;
　　}
　　}
　　n=0;
　　}
　　}
　　/********************************************************************/
　　/*语义分析*/
　　voidsemanti_ana(my_stack&stack，node*s)//主体部分，对后序遍历得到的后缀树进行栈操作，得出最后结果，放在后序遍历循环体中
　　{
　　stringout=““;
　　boolhasundefine=f
　　if(s->id>=0&&s->id<19)
　　{
　　if(s->id==10)
　　{
　　cout　　cout<“ReturnTop[0].val“;
　　cout<
　　cout<“结果：“;
　　if(hasundefine)
　　cout　　else
　　cout　　}
　　elseif(s->id==0)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=sin(stack.Top().index->val);
　　else
　　{
　　out+=“sin(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f
　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=sin(Top[0].val)“;
　　}
　　elseif(s->id==1)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=cos(stack.Top().index->val);
　　else
　　{
　　out=“cos(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f
　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=cos(Top[0].val)“;
　　}
　　elseif(s->id==2)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=tan(stack.Top().index->val);
　　else
　　{
　　out=“tan(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f
　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=tg(Top[0].val)“;
　　}
　　elseif(s->id==3)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=tan(1.57-stack.Top().index->val);
　　else
　　{
　　out=“cot(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f
　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=ctg(Top[0].val)“;
　　}
　　elseif(s->id==4)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=log(stack.Top().index->val);
　　else
　　{
　　out=“log(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f

　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=log(Top[0].val)“;
　　}
　　elseif(s->id==5)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=log10(stack.Top().index->val);
　　else
　　{
　　out=“lg(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f
　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=lg(Top[0].val)“;
　　}
　　elseif(s->id==6)
　　{
　　if(s->index->hasval)
　　stack.Top().index->val=log(stack.Top().index->val);
　　else
　　{
　　out=“ln(“+stack.Top().index->text+“)“;
　　stack.Top().index->text=out;
　　stack.Top().index->hasval=f
　　}
　　cout　　cout<“Top[0].text=“
　　cout<“，Top[0].val=ln(Top[0].val)“;
　　}
　　elseif(s->id==11)
　　{
　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)
　　{
　　doubletemp=stack.Top().index->val;
　　stack.Pop();
　　stack.Top().index->val+=
　　stack.Top().index->text=to_string(stack.Top().index->val);
　　}
　　else{
　　out=“(“+stack.Top(1).index->text+“+“+stack.Top(0).index->text+“)“;
　　stack.Top(1).index->text=out;
　　stack.Top(1).index->hasval=f
　　stack.Pop();
　　}
　　cout　　cout<“Top[1].val+=Top[0].val，Pop()“;
　　}
　　elseif(s->id==12)
　　{
　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)
　　{
　　doubletemp=stack.Top().index->val;
　　stack.Pop();
　　stack.Top().index->val-=
　　stack.Top().index->text=to_string(stack.Top().index->val);
　　}
　　else{
　　out=“(“+stack.Top(1).index->text+“-“+stack.Top(0).index->text+“)“;
　　stack.Top(1).index->text=out;
　　stack.Top(1).index->hasval=f
　　stack.Pop();
　　}
　　cout　　cout<“Top[1].val-=Top[0].val，Pop()“;
　　}
　　elseif(s->id==13)
　　{
　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)
　　{
　　doubletemp=stack.Top().index->val;
　　stack.Pop();
　　stack.Top().index->val*=
　　stack.Top().index->text=to_string(stack.Top().index->val);
　　}
　　else{
　　out=stack.Top(1).index->text+“*“+stack.Top(0).index->
　　stack.Top(1).index->text=out;
　　stack.Top(1).index->hasval=f
　　stack.Pop();
　　}
　　cout　　cout<“Top[1].val*=Top[0].val，Pop()“;
　　}
　　elseif(s->id==14)
　　{
　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)
　　{
　　doubletemp=stack.Top().index->val;
　　stack.Pop();
　　stack.Top().index->val/=
　　stack.Top().index->text=to_string(stack.Top().index->val);
　　}
　　else{
　　out=stack.Top(1).index->text+“/“+stack.Top(0).index->
　　stack.Top(1).index->text=out;
　　stack.Top(1).index->hasval=f
　　stack.Pop();
　　}
　　cout　　cout<“Top[1].val/=Top[0].val，Pop()“;
　　}
　　elseif(s->id==15)
　　{
　　var[top].val=stack.Top().index->val;
　　stack.Push(*s);
　　cout　　stack.Pop();
　　cout<“Variable[top].val=“val;
　　stack.Pop();
　　top++;
　　}
　　elseif(s->id==16)
　　{
　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval){
　　doubletemp=stack.Top().index->val;
　　stack.Pop();
　　stack.Top().index->val=pow(stack.Top().index->val，temp);
　　stack.Top().index->text=to_string(stack.Top().index->val);
　　}
　　else{
　　out=stack.Top(1).index->text+“^“+stack.Top(0).index->
　　stack.Top(1).index->text=out;
　　stack.Top(1).index->hasval=f
　　stack.Pop();
　　}
　　cout　　cout<“Top[1].val=Top[1].val^Top[0].val，Pop()“;
　　}
　　elseif(s->id==1
　　{
　　stack.Push(*s);
　　cout　　cout<“Push(“val<“)“;
　　}
　　elseif(s->id==17)
　　{
　　if(var[top-1].name==““)
　　{
　　var[top-1].name=s->index->
　　stringtemp=to_string(var[top-1].val)+“=“+s->index->
　　cout　　cout<“Variable[Top].text=“index->text<“，Pop(3)“;
　　}
　　else
　　{
　　if(find_var(s->index->text)>=0)
　　{
　　s->index->val=var[find_var(s->index->text)].val;
　　stack.Push(*s);
　　cout　　cout<“Find(“index->text<“)=“index->val;
　　}
　　else
　　{
　　s->index->hasval=f
　　hasundefine=
　　stack.Push(*s);
　　cout　　cout<“NoDefine“index->
　　}
　　}
　　}
　　}
　　}
　　intcount_p=0;
　　voidpost(node*s)//对树的后序遍历
　　{
　　if(s!=NULL){
　　post(s->child);
　　post(s->bro);
　　if(s->id<23&&s->id!=7&&s->id!=8&&s->id!=9)cout
　　}
　　}
　　voidpost(my_stack&stack，node*s)//对树的后序遍历
　　{
　　if(s!=NULL){
　　post(stack，s->child);
　　post(stack，s->bro);
　　if(s->id<23&&s->id!=7&&s->id!=8&&s->id!=9)
　　{
　　cout　　count_p++;
　　semanti_ana(stack，s);
　　cout<
　　}
　　}
　　}
　　intmain()
　　{
　　node*start=&S;
　　sheet=newnode[23];
　　sheet[0].text=“sin“;
　　sheet[1].text=“cos“;
　　sheet[2].text=“tg“;
　　sheet[3].text=“ctg“;
　　sheet[4].text=“log“;
　　sheet[5].text=“lg“;
　　sheet[6].text=“ln“;
　　sheet[7].text=“(“;
　　sheet[8].text=“)“;
　　sheet[9].text=“;“;
　　sheet[10].text=““;
　　sheet[11].text=“+“;
　　sheet[12].text=“-“;
　　sheet[13].text=“*“;
　　sheet[14].text=“/“;
　　sheet[15].text=“=“;
　　sheet[16].text=“^“;
　　sheet[17].text=“var“;
　　sheet[18].text=“con“;
　　sheet[19].text=“PI“;
　　sheet[20].text=“E“;
　　sheet[21].text=“#“;
　　sheet[22].text=“，“;
　　S.id=23;S.text=“S“;
　　A.id=24;A.text=“A“;
　　B.id=25;B.text=“B“;
　　C.id=26;C.text=“C“;
　　D.id=27;D.text=“D“;
　　E.id=28;E.text=“E“;
　　F.id=29;F.text=“F“;
　　G.id=30;G.text=“G“;
　　H.id=31;H.text=“H“;
　　I.id=32;I.text=“I“;
　　J.id=33;J.text=“J“;
　　for(inti=0;i<23;i++)
　　sheet[i].id=i;
　　ifstre
　　in.open(“D:\\词法.txt“);
　　node*a=newnode[MAXSIZE];//当前输入
　　charbuffer[256];
　　while(in.getline(buffer，100))//读取输入内容，既词法分析结果
　　{
　　a[N].text=bu
　　intc1=a[N].text.find(“<“);
　　intc2=a[N].text.find(“，“);
　　intc3=a[N].text.find(“>“);
　　a[N].id=stoi(a[N].text.substr(c2+1，c3-1).data());
　　if(a[N].id==19||a[N].id==20)a[N].id=18;
　　a[N].text=a[N].text.substr(c1+1，c2-1);
　　N++;
　　}
　　a[N].text=“#“;
　　a[N].id=-1;
　　a[N].child=
　　a[N].bro=
　　in.close();
　　N++;
　　my_stacks
　　stack.Push(a[N-1]);
　　stack.Push(S);
　　start=stack.Top().i
　　n-=2;
　　cout<“**************************************************语法分析***************************************************“;
　　cout<“步骤栈内容当前输入操作“;
　　stringc=“--------------------------------------------------------------------------------------------------------------“;
　　cout　　ana(stack，a);
　　cout<“**************************************************语法分析***************************************************“;
　　cout<“**************************************************语义分析***************************************************“;
　　my_stackl//语义分析栈
　　cout<
　　cout<“后缀式：“;
　　post(start);
　　cout<
　　cout<
　　cout<“步骤栈内容操作“;
　　cout　　post(lexme，start);
　　cout<“**************************************************语义分析***************************************************“;
　　ret
　　}