}
MatchToken(Token_Type.R_BRACKET);call_match(\back(\return;
//-------------------RotStatement的递归子程序--------------------------- protected void RotStatement()throws Exception //the RotStatement is: //ROT IS double. { }
//-------------------ForStatement的递归子程序--------------------------- protected void ForStatement()throws Exception //the ForStatement is:
//FOR t FROM double TO double STEP double //DRAW (double,double) {
ExprNode start_ptr = new ExprNode(); ExprNode end_ptr = new ExprNode(); ExprNode step_ptr = new ExprNode(); ExprNode x_ptr = new ExprNode(); ExprNode y_ptr = new ExprNode(); //?????????????????????
enter(\
MatchToken(Token_Type.FOR);call_match(\MatchToken(Token_Type.T);call_match(\
MatchToken(Token_Type.FROM);call_match(\start_ptr = Expression();
MatchToken(Token_Type.TO);call_match(\
end_ptr = Expression();
ExprNode tmp = new ExprNode();
enter(\
MatchToken(Token_Type.ROT);call_match(\
MatchToken(Token_Type.IS);call_match(\tmp = Expression(); back(\return;
}
MatchToken(Token_Type.STEP);call_match(\step_ptr = Expression();
MatchToken(Token_Type.DRAW);call_match(\
MatchToken(Token_Type.L_BRACKET);call_match(\x_ptr = Expression();
MatchToken(Token_Type.COMMA);call_match(\y_ptr = Expression();
MatchToken(Token_Type.R_BRACKET);call_match(\back(\return;
//-------------------Expression的递归子程序--------------------------- protected ExprNode Expression()throws Exception { }
//-------------------Term的递归子程序--------------------------- protected ExprNode Term()throws Exception {
ExprNode left = new ExprNode(); ExprNode right = new ExprNode(); Token_Type token_tmp; ExprNode left = new ExprNode(); ExprNode right = new ExprNode(); Token_Type token_tmp;
enter(\left = Term();
while(token.type == Token_Type.PLUS||token.type == Token_Type.MINUS) { }
Tree_trace(left);
//System.out.println(\back(\
return left;
token_tmp = token.type; MatchToken(token_tmp); right = Term();
left = MakeExprNode(token_tmp,left,right);
//System.out.println(\
}
//System.out.println(\left = Factor();
//System.out.println(\
while(token.type == Token_Type.MUL||token.type == Token_Type.DIV) { }
return left;
token_tmp = token.type; MatchToken(token_tmp); right = Factor();
left = MakeExprNode(token_tmp,left,right); //System.out.println(\
//-------------------Factor的递归子程序--------------------------- protected ExprNode Factor()throws Exception {
ExprNode left = new ExprNode(); ExprNode right = new ExprNode(); //System.out.println(\if(token.type == Token_Type.PLUS) { }
else if(token.type == Token_Type.MINUS)
//若为一元减??则需要小心，要在这个时候就要转化为0.0-x { } else { }
return right;
//System.out.println(\right = Component();
//System.out.println(\MatchToken(Token_Type.MINUS); right = Factor(); left = new ExprNode();
left.OpCode = Token_Type.CONST_ID; left.content.CaseConst = 0.0;
right = MakeExprNode(Token_Type.MINUS,left,right); MatchToken(Token_Type.PLUS); //?????????????????????????????? //?????????????????????????????? right = Factor();
}
//-------------------Component的递归子程序------------------------ protected ExprNode Component()throws Exception { }
//----------------------Atom的递归子程序-------------------------- protected ExprNode Atom()throws Exception {
Token t = token;
//System.out.println(\//System.out.println(t.type); //System.out.println(t.lexeme); //System.out.println(t.value); //System.out.println(t.FunPtr); //System.out.println(\ //???
ExprNode address = new ExprNode(); ExprNode tmp = new ExprNode();
switch(token.type) {
case CONST_ID:
MatchToken(Token_Type.CONST_ID); //System.out.println(\
address = MakeExprNode(Token_Type.CONST_ID,t.value); //System.out.println(\break;
MatchToken(Token_Type.T); ExprNode left = new ExprNode(); ExprNode right = new ExprNode();
//System.out.println(\left = Atom();
//System.out.println(\if(token.type == Token_Type.POWER) { }
return left;
MatchToken(Token_Type.POWER); right = Component();
left = MakeExprNode(Token_Type.POWER,left,right);
case T:
}
}
address = MakeExprNode(Token_Type.T); break;
MatchToken(Token_Type.FUNC); MatchToken(Token_Type.L_BRACKET);
tmp = Expression(); //此时用来存放函数
address = MakeExprNode(Token_Type.FUNC,t.FunPtr,tmp); MatchToken(Token_Type.R_BRACKET); break;
MatchToken(Token_Type.L_BRACKET); address = Expression(); //round robin to Expression()
MatchToken(Token_Type.R_BRACKET); break; SyntaxError(2);
//the token is right,but not the token we expect!!
case FUNC:
case L_BRACKET:
default:
return address;
//-----------------生成语法树的一个节点---------------------------- /**
* every time,we need to allocate new node,and * return it! * */
protected ExprNode MakeExprNode(Token_Type opcode) //T
//还需要看看的?? { }
protected ExprNode MakeExprNode(Token_Type opcode,double value) //CONST_ID
//need to modify the type of token,and the value. {
//System.out.println(\ExprNode ExprPtr = new ExprNode(); ExprPtr.OpCode = opcode;
ExprPtr.content.CaseParmPtr = parameter; return ExprPtr;