📄 parsell1.cpp

📁 snl语言是一个简单的具有嵌套过程定义的过程式语言
💻 CPP
📖 第 1 页 / 共 3 页
字号:
上一页 1 23
   Push(2,RPAREN);
   Push(1,ActParamList);
   Push(2,LPAREN);	

   PushPA(&(currentP->child[1]));
 
}
void process77()
{
   PopPA();
}
void process78()
{
   Push(1,ActParamMore);
   Push(1,Exp);

   TreeNode *t=newExpNode(OpK);
   t->attr.ExpAttr.op = END ;
   PushOp(t);  //操作符栈的栈底存入一个特殊的操作符作为标志
}

void process79()
{
}
void process80()
{ 
   Push(1,ActParamList);
   Push(2,COMMA);
   
   PushPA(&(currentP->sibling));
}


/*设定操作符的优先级，值越大优先级越高*/
int  Priosity( LexType  op)
{ int  pri=0;
  switch(op)
  { case END:
			pri = -1; break;//栈底标识，优先级最低
    case LPAREN: 
		    pri = 0;
    case LT:
    case EQ:
		    pri = 1; break;
	case PLUS:
	case MINUS:
		pri = 2; break;
	case TIMES:
	case OVER:
			pri = 3; break;
    default:  {fprintf(listing ,"no such  operator !");
		       fprintf(listing,"%d\n",op);
			   pri= -1;
			  }  
  }
  return  pri;
}  

/*********************表达式部分************************/

void process81()
{
   Push(1,OtherRelE);
   Push(1,Exp);
   
   TreeNode *t=newExpNode(OpK);
   t->attr.ExpAttr.op = END ;
   PushOp(t);  //操作符栈的栈底存入一个特殊的操作符作为标志	

   getExpResult=FALSE;
}

void process82()
{   
   Push(1,Exp);
   Push(1,CmpOp);

   TreeNode  *currentP=newExpNode(OpK);
   currentP->attr.ExpAttr.op = currentToken.Lex; 
 
   LexType  sTop=ReadOpStack();
   while ( Priosity(sTop) >= Priosity(currentToken.Lex) )
   /*如果操作符栈顶运算符的优先级高于或等于当前读到的操作符*/
   {   TreeNode *t=PopOp();
	   TreeNode *Rnum=PopNum();
	   TreeNode *Lnum=PopNum();
       t->child[1]=Rnum;
	   t->child[0]=Lnum;
       PushNum(t);

       sTop=ReadOpStack();
   }  
   
   PushOp(currentP);
   /*处理完关系操作符右部的表达式时，要弹语法树栈，故
     设置getExpResult为真*/
   getExpResult	= TRUE;
}

void process83()
{ 
   Push(1,OtherTerm);
   Push(1,Term);
}

void process84()
{
  if ((currentToken.Lex==RPAREN)&&(expflag!=0))
     //说明当前右括号是表达式中的一部分
    { while (ReadOpStack()!=LPAREN)
          {TreeNode   *t=PopOp();
	        TreeNode  *Rnum=PopNum();
	        TreeNode  *Lnum=PopNum();

            t->child[1] = Rnum;
			t->child[0] = Lnum;
			PushNum(t);
         }
		PopOp(); //弹出左括号
        expflag--; 
     }
  else
  { if ((getExpResult)||(getExpResult2))
    {  while  (ReadOpStack()!=END)
	  {TreeNode  *t=PopOp();
	   TreeNode  *Rnum=PopNum();
	   TreeNode  *Lnum=PopNum();

       t->child[1] = Rnum;
	   t->child[0] = Lnum;
	   PushNum(t);  
	  }
      PopOp();//弹出栈底标志
	  currentP=PopNum();
    
	  TreeNode  **t=PopPA();
	  (*t)=currentP;
      
	  /*处理完数组变量，标志恢复初始值假，
	    遇到下一个数组下标表达式时，再将其设置为真值*/
	  if (getExpResult2==TRUE)
	      getExpResult2 = FALSE;
	}
 }
}

void process85()
{ 
   Push(1,Exp);
   Push(1,AddOp);
   
   TreeNode  *currentP=newExpNode(OpK);
   currentP->attr.ExpAttr.op = currentToken.Lex; 
   LexType  sTop=ReadOpStack();
   while ( Priosity(sTop) >= Priosity(currentToken.Lex) )
   /*如果操作符栈顶运算符的优先级高于或等于当前读到的操作符*/
   {   TreeNode *t=PopOp();
	   TreeNode *Rnum=PopNum();
	   TreeNode *Lnum=PopNum();
       t->child[1]=Rnum;
	   t->child[0]=Lnum;
       PushNum(t);
       sTop=ReadOpStack();
   }  
   PushOp(currentP);
}

void process86()
{ 
   Push(1,OtherFactor);
   Push(1,Factor);
}
void process87()
{
}
void process88()
{
   Push(1,Term);
   Push(1,MultOp);

   TreeNode  *currentP=newExpNode(OpK);
   currentP->attr.ExpAttr.op = currentToken.Lex; 
   
   LexType  sTop=ReadOpStack();
   while ( Priosity(sTop) >= Priosity(currentToken.Lex) )
   /*如果操作符栈顶运算符的优先级高于或等于当前读到的操作符*/
   {   TreeNode *t=PopOp();
	   TreeNode *Rnum=PopNum();
	   TreeNode *Lnum=PopNum();
       t->child[1]=Rnum;
	   t->child[0]=Lnum;
       PushNum(t);

       sTop=ReadOpStack();
   }  
   PushOp(currentP);
}

void process89()
{
   Push(2,RPAREN);
   Push(1,Exp);
   Push(2,LPAREN);

   TreeNode *t=newExpNode(OpK);
   t->attr.ExpAttr.op = currentToken.Lex; /*把左括号也压入栈中*/
   PushOp(t);
   expflag++;
}

void process90()
{
  Push(2,INTC);
	
  TreeNode *t=newExpNode(ConstK);
  t->attr.ExpAttr.val = atoi(currentToken.Sem);
  /*常数节点入操作数栈*/
  PushNum(t);

}

void process91()
{
 Push(1,Variable);
}

void process92()
{
	Push(1,VariMore);
	Push(2,ID);
	
	currentP=newExpNode(VariK);
	strcpy( currentP->name[0] , currentToken.Sem );
	currentP->idnum++;
	/*变量节点入操作数栈*/
	PushNum(currentP);

}

void process93()
{
 /*标识符变量*/
 currentP->attr.ExpAttr.varkind=IdV;
}

void process94()
{  
	Push(2, RMIDPAREN);
	Push(1, Exp);
	Push(2, LMIDPAREN);
    /*数组成员变量*/
    currentP->attr.ExpAttr.varkind=ArrayMembV;
	PushPA(&currentP->child[0]);

	/*要进入表达式处理，初始化操作符栈*/
	//操作符栈的栈底存入一个特殊的操作符作为标志
    TreeNode *t=newExpNode(OpK);
    t->attr.ExpAttr.op = END ;
    PushOp(t);  	

   	/*要进入数组下标表达式处理，在函数process84处理中，要
	  操作语法树栈，故将标志getExpResult2设置为真值*/
    getExpResult2 = TRUE;


}

void process95()
{
	Push(1, FieldVar);
	Push(2, DOT);
    /*域成员变量*/
	currentP->attr.ExpAttr.varkind=FieldMembV;
	PushPA(&currentP->child[0]);
}

void process96()
{
	Push(1,FieldVarMore);
	Push(2,ID);
    
	/*纪录域的成员*/
	currentP=newExpNode(VariK);
	strcpy( currentP->name[0] , currentToken.Sem );
	currentP->idnum++;

	TreeNode **t=PopPA( );
	(*t)=currentP;


}

void process97()
{
  /*域成员是标识符变量*/
  currentP->attr.ExpAttr.varkind=IdV;
}

void process98()
{
	Push(2,RMIDPAREN);
	Push(1,Exp);
	Push(2,LMIDPAREN);
	/*域成员是数组变量*/
	currentP->attr.ExpAttr.varkind=ArrayMembV;
	/*指向数组成员表达式*/
	PushPA(&currentP->child[0]);

    //操作符栈的栈底存入一个特殊的操作符作为标志
    TreeNode *t=newExpNode(OpK);
    t->attr.ExpAttr.op = END ;
    PushOp(t);  	

	/*要进入数组下标表达式处理，在函数process84处理中，要
	  操作语法树栈，故将标志getExpResult2设置为真值*/
    getExpResult2 = TRUE;
}
void process99()
{ 
    Push(2,LT);
}

void process100()
{  
	Push(2,EQ);
}

void process101()
{  
	Push(2,PLUS);
}

void process102()
{ 
	Push(2,MINUS);
}

void process103()
{
	Push(2,TIMES);
}

void process104()
{
    Push(2,OVER);
}


/****************************************************/
/* 函数名  predict									*/
/* 功  能  选择产生式函数							*/
/* 说  明  										    */
/****************************************************/
void predict(int num)
{  switch( num )
    { case 1:     process1();	break;	  
      case 2:     process2();	break;
      case 3:     process3();	break;
      case 4:     process4();   break;
	  case 5:	  process5();   break;
      case 6:	  process6();	break;
      case 7:	  process7();	break;
      case 8:	  process8();	break;
	  case 9:	  process9();   break;
      case 10:	  process10();	break;
      case 11:	  process11();	break;
      case 12:	  process12();	break;
      case 13:	  process13();	break;
      case 14:	  process14();	break;
      case 15:	  process15();	break;
      case 16:	  process16();	break;
      case 17:	  process17();	break;
      case 18:	  process18();	break;
      case 19:	  process19();	break;
      case 20:	  process20();	break;
      case 21:	  process21();	break;
	  case 22:	  process22();  break;
      case 23:	  process23();  break;
      case 24:	  process24();	break;
	  case 25:	  process25();  break;
      case 26:	  process26();  break;
      case 27:	  process27();  break;
      case 28:	  process28();  break;
      case 29:	  process29();	break;
      case 30:	  process30();	break;
	  case 31:	  process31();  break;
      case 32:	  process32();  break;
      case 33:	  process33();	break;
	  case 34:	  process34();  break;
      case 35:	  process35();  break;
     
	  case 36:	  process36();  break;
      case 37:	  process37();  break;
      case 38:	  process38();	break;
      case 39:	  process39();	break;
      case 40:	  process40();  break;
	  
      case 41:	  process41();  break;
      case 42:	  process42();	break;
	  case 43:	  process43();  break;
      case 44:	  process44();  break;
      case 45:	  process45();	break;
	  
	  case 46:    process46();  break;
      case 47:	  process47();	break;
      case 48:	  process48();  break;
      case 49:	  process49();  break;
      case 50:	  process50();	break;
  
	  case 51:	  process51();  break;
      case 52:	  process52();	break;
      case 53:	  process53();	break;
      case 54:	  process54();  break;
      case 55:	  process55();  break;
      case 56:	  process56();	break;

	  case 57:	  process57();  break;
      case 58:	  process58();	break;
      case 59:	  process59();	break;
      case 60:	  process60();	break;
      case 61:	  process61();	break;
      case 62:	  process62();	break;
      case 63:	  process63();	break;
      case 64:	  process64();	break;
      case 65:	  process65();	break;
      case 66:	  process66();	break;
      case 67:	  process67();	break;
      case 68:	  process68();	break;
	  case 69:    process69();  break;
	  case 70:    process70();  break;
               
      case 71:	  process71();	break;
      case 72:	  process72();	break;
      case 73:	  process73();  break;
      case 74:	  process74();  break;
      case 75:	  process75();  break;
	 
	  case 76:	  process76();  break;
      case 77:	  process77();	break;
	  case 78:    process78();  break;
      case 79:    process79();  break;
	  case 80:	  process80();  break;
      case 81:	  process81();  break;
      case 82:	  process82();	break;
      case 83:	  process83();  break;
      case 84:	  process84();  break;
      case 85:	  process85();	break;
	  case 86:	  process86();  break;
      case 87:	  process87();  break;
      case 88:	  process88();	break;
	  case 89:	  process89();  break;
      case 90:	  process90();	break;
      case 91:	  process91();	break;
      case 92:	  process92();	break;
      case 93:	  process93();	break;
      case 94:	  process94();	break;
      case 95:	  process95();	break;
      case 96:	  process96();	break;
      case 97:    process97();  break;
	  case 98:    process98();  break;
	  case 99:    process99();  break;
	  case 100:   process100(); break;
	  case 101:   process101(); break;
	  case 102:   process102(); break;
	  case 103:   process103(); break;
	  case 104:   process104(); break;
	  case 0:
	  default:	  { 
		             syntaxError("unexpected token ->");  
					 fprintf(listing,"  %s",currentToken.Sem);
				  }
   }		  
}   

/****************************************************/
/* 函数名  parseLL1									*/
/* 功  能  LL1语法分析主函数						*/
/* 说  明  										    */
/****************************************************/

 TreeNode  * parseLL1()
{
 
  NontmlType  stacktopN;

  TmlType     stacktopT;    

  /*语法树的根节点*/
  TreeNode *rootPointer=NULL;
 
  int pnum=0; //纪录选中的产生式编号

  CreatLL1Table();
 
  STACKEMPTY = TRUE;
  
  /*指向整个语法树根节点的指针，由它得到语法树*/
  rootPointer = newRootNode();
  
  /*从这里开始进行语法分析和语法树的生成*/
  PushPA ( &(rootPointer->child[2])); 
  PushPA ( &(rootPointer->child[1])); 
  PushPA ( &(rootPointer->child[0])); 

  Push(1,Program);
  
  /*取一个token*/
  gettoken(&currentToken);
  lineno=currentToken.lineshow;


  while  (!(STACKEMPTY)) 
  {
	  if ( readStackflag() == 2) /*检测终极符是否匹配*/
		 {   
			 stacktopT=readstackT();
            
			 if (stacktopT==currentToken.Lex)
			 {
				Pop(); 
				gettoken(&currentToken);
				lineno=currentToken.lineshow;
		
			 }
             else
			 {    syntaxError("unexpected  token ->  ");
                  fprintf(listing,"  %s",currentToken.Sem); 
                  fprintf(listing,"		");
				  //printf("terminal not match!\n");
				  //printf("%d\n",stacktopT);
			      exit(0);
			 } 
		 }    
		else {  /*根据非终极符和栈中符号进行预测*/
			    stacktopN=readstackN();
		        
				pnum= LL1Table[stacktopN][currentToken.Lex];
			    Pop(); 
			//	if (0==pnum)
			//	{	printf("no predict!\n");
            //        printf("%d\n",stacktopN);
			//	}
				predict(pnum);  
				
		     }
  }
if  (currentToken.Lex != ENDFILE)
  syntaxError("Code  ends  before  file \n");

return  rootPointer;

}
上一页 1 23
💿 文件大小 228 K
👤 上传用户 k_oyy
📂 所属分类编译器/解释器
🏷️ 相关标签

#snl #语言 #过程 #嵌套
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -