SNL语法分析器以及语法树的绘画

最新推荐文章于 2022-05-26 11:02:53 发布

吾等前方绝无敌手

最新推荐文章于 2022-05-26 11:02:53 发布

阅读量7k

点赞数 7

分类专栏：风雨飘摇路

本文链接：https://blog.csdn.net/lisc741/article/details/8858968

版权

前几天做了语法分析器，，，最近才有时间发表出来

总共有四个包，12个类，

common包主要是公用的变量和公用类：

Enum（是枚举类型的类）

Error（表示错误的类）

Node（词法token节点）

Predict（predict集的数据结构）

SNLPredict（SNL的predict集）

production（产生式的数据结构）

SNLproduction（SNL的产生式集）

treeNode（语法树节点的数据结构）

lex包是用于词法分析的：

scanner（词法分析器）

main包就不解释了

parser包是用于语法分析的：

Parser（语法分析器）

drawTree（画树）

接下来就是代码了：

Enum.java

package common;

public interface Enum {
	public enum lexType{
		/* 簿记单词符号 */
	    ENDFILE,	ERROR,
		/* 保留字 */
	    PROGRAM,	 PROCEDURE,	    TYPE,	        VAR,		 IF,
		THEN,		 ELSE,		    FI,		        WHILE,		 DO,
		ENDWH,		 BEGIN,		    END,	        READ,		 WRITE,
		ARRAY,		 OF,		    RECORD,	        RETURN, 

		INTEGER,	 CHAR,
		/* 多字符单词符号 */
	    ID,			 INTC,		    CHARC,
	    /*特殊符号 */
		ASSIGN,		 EQ,		    LT,		        PLUS,		 MINUS,
		TIMES,		 OVER,		    LPAREN,	        RPAREN,		 DOT,
		COLON,		 SEMI,		    COMMA,	        LMIDPAREN,	 RMIDPAREN,
		UNDERANGE ; 
	}
	/*非终极符*/
	public enum nonTerminals{
		Program,     ProgramHead,   ProgramName,    DeclarePart, TypeDecpart,
		TypeDec,     TypeDecList,   TypeDecMore,    TypeId,      TypeDef,
		BaseType,    StructureType, ArrayType,      Low,         Top,
		RecType,     FieldDecList,  FieldDecMore,   IdList,      IdMore,
		VarDecpart,  VarDec,        VarDecList,     VarDecMore,  VarIdList,   VarIdMore,
		ProcDecpart, ProcDec,       ProcDecMore,    ProcName,    ParamList,   ProcDeclaration ,
		ParamDecList,ParamMore,     Param,          FormList,    FidMore,
		ProcDecPart, ProcBody,      ProgramBody,    StmList,     StmMore,     Stm,
		AssCall,     AssignmentRest,ConditionalStm, LoopStm,     InputStm,
		Invar,		 OutputStm,     ReturnStm,      CallStmRest, ActParamList,
		ActParamMore,RelExp,        OtherRelE,      Exp,         OtherTerm,
		Term,        OtherFactor,   Factor,         Variable,    VariMore,    FieldVar,
		FieldVarMore,CmpOp,         AddOp,          MultOp ;
	}
	public enum nodeKind {
		ProK ,  PheadK , TypeK , VarK , ProcDecK , StmLK , DecK , StmtK , ExpL ;
	}
	public enum decKind {
		ArrayK , CharK , IntegerK , RecordK , IdK ;
	}
	public enum stmtKind {
		IfK , WhileK , AssignK , ReadK , WriteK , CallK , ReturnK ;
	}
	public enum expKind {
		OpK , ConstK , VariK ; 
	}
	public enum varKind {
		IdV , ArrayMembV , FieldMembV ;
	}
	public enum expType {
		Void , Integer , Boolean ;
	}
	public enum paramType {
		ValParamType , VarparamType ; 
	}
}

Error.java:

package common;

public class Error {
	static int  Line ;
	static int Row;
	static int  ErrorType  ;
	static boolean  Flag ;
	public Error(){
		Line = 0 ; 
		Row  = 0 ;
		ErrorType = 0 ; 
		Flag = false ;
	}
	public static void printError() {
		if( ErrorType == 1 ) System.out.print( "词法错误" ) ; 
		else if( ErrorType == 2 ) System.out.print( "语法错误" ) ;
		System.out.println( "  行:" + Line + "  列: " + Row  ) ; 
	}
	public static void setLine( int line ) {
		Line = line ; 
	}
	public static void setRow( int row ) {
		Row = row ; 
	}
	public static void setErrorType( int type ) {
		ErrorType = type ;
	}
	public static void setFlag( boolean flag ) {
		Flag = flag ; 
	}
	public static int getLine() {
		return Line ;
	}
	public static int getRow()  {
		return Row  ;
	}
	public static int getErrorType() {
		return ErrorType ;
	}
	public static boolean getFlag() {
		return Flag ; 
	}
	public static void setError( int line , int row , int type ) {
		Line = line ; 
		Row  = row  ;
		ErrorType = type ;
		Flag = true    ;
	}
}

Node.java:

package common;

import common.Enum.*;

public class Node {
	String Data ;
	int    Line , Row ;
	lexType    type ;
	public Node(){
	}
	public String getData() {
		return Data;
	}
	public void setData(String data) {
		Data = data;
	}
	public int getLine() {
		return Line;
	}
	public void setLine(int line) {
		Line = line;
	}
	public int getRow() {
		return Row;
	}
	public void setRow(int row) {
		Row = row;
	}
	public lexType getType() {
		return type;
	}
	public void setType(lexType integer) {
		this.type = integer;
	}
}

predict.java:

package common;

public class Predict {
	int         predictNum ;
	Enum.lexType[] predict = new Enum.lexType[20] ;
	
	public Predict() {
		predictNum = 0 ; 
	}
	
	public void setPredict( Enum.lexType pre ) {
		predict[predictNum] = pre ;
		predictNum ++ ;
	}
	
	public int getPredictNum() {
		return predictNum ;
	}
	
	public Enum.lexType getPredict( int number ) {
		return predict[number] ;
	}
}

SNLPredict:

package common;

public class SNLpredict {
	public Predict[] predict = new Predict[105] ;
	public SNLpredict() {
		for( int i = 0 ; i <= 104 ; i ++ )
			predict[i] = new Predict() ;
		predict[1].setPredict( Enum.lexType.PROGRAM ) ;
		
		predict[2].setPredict( Enum.lexType.PROGRAM ) ;
		
		predict[3].setPredict( Enum.lexType.ID ) ;
		
		predict[4].setPredict( Enum.lexType.TYPE ) ; 			predict[4].setPredict( Enum.lexType.VAR ) ;
		predict[4].setPredict( Enum.lexType.PROCEDURE ) ;		predict[4].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[5].setPredict( Enum.lexType.VAR ) ;				predict[5].setPredict( Enum.lexType.PROCEDURE ) ;
		predict[5].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[6].setPredict( Enum.lexType.TYPE ) ;
		
		predict[7].setPredict( Enum.lexType.TYPE ) ;
		
		predict[8].setPredict( Enum.lexType.ID ) ;
		
		predict[9].setPredict( Enum.lexType.VAR ) ;				predict[9].setPredict( Enum.lexType.PROCEDURE ) ;
		predict[9].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[10].setPredict( Enum.lexType.ID ) ;
		
		predict[11].setPredict( Enum.lexType.ID ) ;
		
		predict[12].setPredict( Enum.lexType.INTEGER ) ;		predict[12].setPredict( Enum.lexType.CHAR ) ;
		
		predict[13].setPredict( Enum.lexType.ARRAY ) ;			predict[13].setPredict( Enum.lexType.RECORD ) ;
		
		predict[14].setPredict( Enum.lexType.ID ) ;
		
		predict[15].setPredict( Enum.lexType.INTEGER ) ;
		
		predict[16].setPredict( Enum.lexType.CHAR ) ;
		
		predict[17].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[18].setPredict( Enum.lexType.RECORD ) ;
		
		predict[19].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[20].setPredict( Enum.lexType.INTC ) ;
		
		predict[21].setPredict( Enum.lexType.INTC ) ;
		
		predict[22].setPredict( Enum.lexType.RECORD ) ;
		
		predict[23].setPredict( Enum.lexType.INTEGER ) ; 		predict[23].setPredict( Enum.lexType.CHAR ) ;
		
		predict[24].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[25].setPredict( Enum.lexType.END ) ;
		
		predict[26].setPredict( Enum.lexType.INTEGER ) ;		predict[26].setPredict( Enum.lexType.CHAR ) ;
		predict[26].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[27].setPredict( Enum.lexType.ID ) ;
		
		predict[28].setPredict( Enum.lexType.SEMI ) ;
		
		predict[29].setPredict( Enum.lexType.COMMA ) ;
		
		predict[30].setPredict( Enum.lexType.PROCEDURE ) ; 		predict[30].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[31].setPredict( Enum.lexType.VAR ) ;
		
		predict[32].setPredict( Enum.lexType.VAR ) ;
		
		predict[33].setPredict( Enum.lexType.INTEGER ) ;		predict[33].setPredict( Enum.lexType.CHAR ) ;
		predict[33].setPredict( Enum.lexType.ARRAY ) ;			predict[33].setPredict( Enum.lexType.RECORD ) ;
		predict[33].setPredict( Enum.lexType.ID ) ;
		
		predict[34].setPredict( Enum.lexType.PROCEDURE ) ;		predict[34].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[35].setPredict( Enum.lexType.INTEGER ) ;		predict[35].setPredict( Enum.lexType.CHAR ) ;
		predict[35].setPredict( Enum.lexType.ARRAY ) ;			predict[35].setPredict( Enum.lexType.RECORD ) ;
		predict[35].setPredict( Enum.lexType.ID ) ;
		
		predict[36].setPredict( Enum.lexType.ID ) ;
		
		predict[37].setPredict( Enum.lexType.SEMI ) ;
		
		predict[38].setPredict( Enum.lexType.COMMA ) ;
		
		predict[39].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[40].setPredict( Enum.lexType.PROCEDURE ) ;
		
		predict[41].setPredict( Enum.lexType.PROCEDURE ) ;
		
		predict[42].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[43].setPredict( Enum.lexType.PROCEDURE ) ;
		
		predict[44].setPredict( Enum.lexType.ID ) ;
		
		predict[45].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[46].setPredict( Enum.lexType.INTEGER ) ;		predict[46].setPredict( Enum.lexType.CHAR ) ;
		predict[46].setPredict( Enum.lexType.ARRAY ) ;			predict[46].setPredict( Enum.lexType.RECORD ) ;
		predict[46].setPredict( Enum.lexType.ID	) ;				predict[46].setPredict( Enum.lexType.VAR ) ;
		
		predict[47].setPredict( Enum.lexType.INTEGER ) ;		predict[47].setPredict( Enum.lexType.CHAR ) ;
		predict[47].setPredict( Enum.lexType.ARRAY ) ;			predict[47].setPredict( Enum.lexType.RECORD ) ;
		predict[47].setPredict( Enum.lexType.ID	) ;				predict[47].setPredict( Enum.lexType.VAR ) ;
		
		predict[48].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[49].setPredict( Enum.lexType.SEMI ) ;
		
		predict[50].setPredict( Enum.lexType.INTEGER ) ;		predict[50].setPredict( Enum.lexType.CHAR ) ;
		predict[50].setPredict( Enum.lexType.ARRAY ) ;			predict[50].setPredict( Enum.lexType.RECORD ) ;
		predict[50].setPredict( Enum.lexType.ID ) ;
		
		predict[51].setPredict( Enum.lexType.VAR ) ;
		
		predict[52].setPredict( Enum.lexType.ID ) ;
		
		predict[53].setPredict( Enum.lexType.SEMI ) ;			predict[53].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[54].setPredict( Enum.lexType.COMMA ) ;
		
		predict[55].setPredict( Enum.lexType.TYPE ) ;			predict[55].setPredict( Enum.lexType.VAR ) ;

最低0.47元/天解锁文章

吾等前方绝无敌手

关注

7
点赞
踩
41

收藏

觉得还不错? 一键收藏
1
评论
SNL语法分析器以及语法树的绘画

前几天做了语法分析器，，，最近才有时间发表出来总共有四个包，12个类，common包主要是公用的变量和公用类：Enum（是枚举类型的类）Error（表示错误的类）Node（词法token节点）Predict（predict集的数据结构）SNLPredict（SNL的predict集）production（产生式的数据结构）SNLproduction（
复制链接

扫一扫